public async Task UpdateStudent_returns_ArgumentException_on_not_found()
{
var studentToUpdate = new UpdateStudentDTO {
Id = Guid.NewGuid()
};
await Assert.ThrowsAsync <ArgumentException>(() => repository.UpdateStudentAsync(studentToUpdate));
}
public async Task <IActionResult> UpdateSource(int id, [FromBody] UpdateStudentDTO source)
{
try
{
if (source == null)
{
return(BadRequest());
}
if (!ModelState.IsValid)
{
return(BadRequest("Invalid model object"));
}
var sourceEntity = await _repositoryWrapper.StudentRepo.GetDataByIdAsync(id);
if (sourceEntity == null)
{
return(NotFound());
}
_mapper.Map(source, sourceEntity);
_repositoryWrapper.StudentRepo.UpdateData(sourceEntity);
await _repositoryWrapper.SaveAsync();
return(Ok("Update successfully!"));
}
catch (Exception ex)
{
//_logger.LogError($"Something went wrong inside CreateSources action: {ex.Message}");
if (ex.InnerException != null)
{
return(BadRequest(ex.Message + "," + ex.InnerException.Message));
}
return(BadRequest(ex.Message));
}
}
public async Task <bool> UpdateStudentAsync(UpdateStudentDTO student)
{
var entity = await context.Students.FindAsync(student.Id);
if (entity == null)
{
throw new ArgumentException($"Could not remove student with id {student.Id}, because it does not exist.");
}
// Remove the previous keywords, as they are a primary key
var keywordsForStudent = from k in context.StudentKeywords
where k.StudentId.Equals(entity.Id)
select k;
context.StudentKeywords.RemoveRange(keywordsForStudent);
entity.Agreement = student.Agreement;
entity.Degree = student.Degree;
entity.Keywords = GetKeywords(student.KeywordNames).ToList();
entity.Location = student.Location;
entity.MaxWorkingHours = student.MaxWorkingHours;
entity.MinWorkingHours = student.MinWorkingHours;
entity.MinSalary = student.MinSalary;
await context.SaveChangesAsync();
return(true);
}
public async Task <IHttpActionResult> PutStudentAsync(int id, UpdateStudentDTO student)
{
if (!ModelState.IsValid)
{
LoggingService.SaveErrorLog($"Updating student error. Id in url: {id}, id in model: {student.RecordBookNumber}");
_logger.Error($"Updating student error. Id in url: {id}, id in model: {student.RecordBookNumber}");
return(BadRequest(ModelState));
}
if (id != student.RecordBookNumber)
{
LoggingService.SaveErrorLog($"Updating student error. Model: {JsonConvert.SerializeObject(student)} invalid");
_logger.Error($"Updating student error. Model: {JsonConvert.SerializeObject(student)} invalid");
return(BadRequest());
}
var updateResult = await StudentService.UpdateStudentAsync(student);
if (updateResult.Updated)
{
return(Ok(updateResult));
}
return(StatusCode(HttpStatusCode.NoContent));
}
public async Task <CreatedStudentDTO> UpdateAsync(UpdateStudentDTO student)
{
if (!_accessProvider.CurrentUserId.HasValue)
{
throw new ForbiddenException($"The current user doesn't access for document.");
}
User user = _userRepository.Get(_accessProvider.CurrentUserId.Value)
.Include(s => s.Student)
.FirstOrDefault(s => s.Id == _accessProvider.CurrentUserId.Value);
if (user is null)
{
throw new NotFoundException($"User with {_accessProvider.CurrentUserId.Value} dont found");
}
user.Firstname = student.Name;
user.Lastname = student.Lastname;
user.Student.FacultyId = student.FacultyId;
user.Student.SpecialityByFacultyId = student.SpecialityByFacultyId;
user.Student.SpecializationId = student.SpecializationId;
user.Student.UniversityId = student.UniversityId;
user.Student.CanHelpWithDormitory = student.CanHelp;
user.Student.CourseNumber = student.Course;
_userRepository.Update(user);
await _storage.SaveAsync();
return(new CreatedStudentDTO(user));
}
public async Task <(bool, string)> Update(int id, ReadStudentDTO newT)
{
using (var client = new HttpClient())
{
DataMessage message = null;
client.DefaultRequestHeaders.Clear();
client.BaseAddress = new Uri(WebAPIUrl);
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue(mediaType: "application/json"));
var token = Session.GetString("Token");
var UpdateStudentDTO = new UpdateStudentDTO()
{
Name = newT.Name, Surname = newT.Surname, DateOfBirth = newT.DateOfBirth, DepartmentId = newT.DepartmentId, Index = newT.Index, StatusId = newT.StatusId
};
if (string.IsNullOrEmpty(token))
{
return(false, "You are not logged in!");
}
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue(scheme: "Bearer", parameter: token);
var responseMessage = await client.PutAsJsonAsync <UpdateStudentDTO>(requestUri : "/api/Students/UpdateStudent/" + id, UpdateStudentDTO);
var resultMessage = await responseMessage.Content.ReadAsStringAsync();
message = JsonConvert.DeserializeObject <DataMessage>(resultMessage);
return(responseMessage.IsSuccessStatusCode, message.Message);
}
}
private async void AddSTudent_Click(object sender, RoutedEventArgs e)
{
object @object;
if (this.VM.IsItemSelected)
{
@object = new UpdateStudentDTO
{
Name = Name.Text,
Surname = Surname.Text,
StudentId = this.VM.StudentId,
StudentNumber = this.VM.StudentNumber
};
}
else
{
@object = new AddStudentDTO
{
Name = Name.Text,
Surname = Surname.Text,
StudentNumber = Factory.RandomStudentNumberGenerator.Next(Config.StudentNumber_MinValue, Config.StudentNumber_MaxValue)
};
}
try
{
if (this.VM.IsItemSelected)
{
await AppData.Client.PutAsync(Config.REST_Endpoints_Students, @object);
}
else
{
await AppData.Client.Post(Config.REST_Endpoints_Students, @object);
}
await AppData.RefreshStudentsAsync();
this.VM.Students = AppData.Students;
this.VM.Name = string.Empty;
this.VM.Surname = string.Empty;
this.VM.StudentNumber = 0;
}
catch (Exception ex)
{
string title = $"OH SNAP! Failed to add the following student : {((Student)@object).StudentNumber}";
string msg = $"Couldn't add student : {((Student)@object).ToString()}. \n Exception : {ex.Message}. \n Inner Exception : {ex.InnerException?.Message}.";
var dialog = new MessageDialog(msg, title);
await dialog.ShowAsync();
// Log error
}
}
/// <summary>
/// The student can update himself.
/// </summary>
/// <param name="updateStudentDTO"></param>
/// <returns></returns>
public async Task UpdateCurrentStudentAsync(UpdateStudentDTO updateStudentDTO)
{
var currentStudent = await _userManager.FindByNameAsync(_loggedUser).ConfigureAwait(false);
currentStudent.ThrowIfNullForGuidObject();
currentStudent.Student.Name = updateStudentDTO.Name;
currentStudent.Student.Surname = updateStudentDTO.Surname;
currentStudent.Student.University = updateStudentDTO.University;
currentStudent.Student.Age = updateStudentDTO.Age;
currentStudent.Student.Dream = updateStudentDTO.Dream;
currentStudent.Student.HomeAddress = updateStudentDTO.HomeAddress;
await _studentRepository.UpdateAsync(currentStudent.Student).ConfigureAwait(false);
}
public async Task Update_returns_500_on_internal_error()
{
var student = new UpdateStudentDTO {
Degree = Degree.Bachelor
};
repository.Setup(r => r.UpdateStudentAsync(student)).ThrowsAsync(new Exception());
var controller = new StudentRepositoryController(repository.Object);
var actual = await controller.Update(student, true);
var actionResult = Assert.IsType <ActionResult <bool> >(actual);
var code = Assert.IsType <StatusCodeResult>(actionResult.Result);
Assert.Equal(500, code.StatusCode);
}
public async Task Update_returns_404_on_not_found()
{
var student = new UpdateStudentDTO {
Id = Guid.NewGuid()
};
repository.Setup(r => r.UpdateStudentAsync(student)).ThrowsAsync(new ArgumentException());
var controller = new StudentRepositoryController(repository.Object);
var actual = await controller.Update(student, true);
var actionResult = Assert.IsType <ActionResult <bool> >(actual);
var code = Assert.IsType <StatusCodeResult>(actionResult.Result);
Assert.Equal(404, code.StatusCode);
}
public async Task Update_returns_200_and_true()
{
var student = new UpdateStudentDTO {
Degree = Degree.Bachelor
};
repository.Setup(r => r.UpdateStudentAsync(student)).ReturnsAsync(true);
var controller = new StudentRepositoryController(repository.Object);
var actual = await controller.Update(student, true);
var actionResult = Assert.IsType <ActionResult <bool> >(actual);
var okResult = Assert.IsType <OkObjectResult>(actionResult.Result);
var hasBeenUpdated = Assert.IsType <bool>(okResult.Value);
Assert.Equal(200, okResult.StatusCode);
Assert.True(hasBeenUpdated);
}
public IActionResult UpdateStudent(UpdateStudentDTO updateStudentDto, [FromRoute] string id)
{
var student =
_studentsDbContext.Student.FirstOrDefault(x => x.IndexNumber == id);
if (student == null)
{
return(NotFound($"Nie znaleziono studenta o id {id}"));
}
student.FirstName = updateStudentDto.FirstName;
student.LastName = updateStudentDto.LastName;
student.BirthDate = updateStudentDto.BirthDate;
_studentsDbContext.SaveChanges();
return(Ok(student));
}
public async Task <ActionResult <bool> > Update([FromBody] UpdateStudentDTO student, bool isTest = false)
{
try
{
var isUpdated = await repository.UpdateStudentAsync(student);
return(Ok(isUpdated));
}
catch (ArgumentException e)
{
Util.LogError(e, isTest);
return(StatusCode(StatusCodes.Status404NotFound));
}
catch (Exception e)
{
Util.LogError(e, isTest);
return(StatusCode(StatusCodes.Status500InternalServerError));
}
}
public async Task UpdateStudent_returns_true_on_updated()
{
var studentToUpdate = await Context.Students.FirstAsync();
var dto = new UpdateStudentDTO
{
Id = studentToUpdate.Id,
KeywordNames = new [] { "Testing", "C#" },
Degree = Degree.Other,
MinSalary = 1,
MinWorkingHours = 1,
MaxWorkingHours = 2,
Agreement = true,
Location = "København"
};
var actual = await repository.UpdateStudentAsync(dto);
Assert.True(actual);
Assert.Equal(dto.Id, studentToUpdate.Id);
Assert.Equal(dto.KeywordNames, studentToUpdate.Keywords.Select(k => k.Keyword.Name).ToList());
}
public async Task <ActionResult> UpdateStudentAsync(UpdateStudentDTO student)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var s = _mapper.Map <Student>(student);
try
{
await this._service.UpdateAsync(s);
await this._service.SaveAsync();
}
catch (Exception ex)
{
return(Problem(detail: $"Failed to update student ({s.Name}). Error: {ex.Message}. InnerException: {ex.InnerException?.Message}"));
}
return(Ok());
}
public async Task <UpdateStudentResultDTO> UpdateStudentAsync(UpdateStudentDTO student)
{
var updateResult = new UpdateStudentResultDTO
{
Updated = false,
Student = null
};
var studentEntity = _repository.GetStudentByID(student.RecordBookNumber);
var user = await _userManager.FindByIdAsync(studentEntity.UserId);
user.FirstName = string.IsNullOrWhiteSpace(student.FirstName) ? user.FirstName : student.FirstName;
user.LastName = string.IsNullOrWhiteSpace(student.LastName) ? user.LastName : student.LastName;
//TODO: zrobić ładniejszy kod
studentEntity.CurrentSemester = student.CurrentSemester;
studentEntity.Pesel = student.Pesel;
studentEntity.EnrollmentDate = student.EnrollmentDate;
studentEntity.UserId = user.Id;
studentEntity.UserData = user;
//var newStudent = Mapper.Map<Student>(student);
//newStudent.UserId = user.Id;
//newStudent.UserData = user;
updateResult.Student = Mapper.Map <GetStudentDTO>(studentEntity);
_repository.UpdateStudent(studentEntity);
if (_repository.Save())
{
updateResult.Updated = true;
return(updateResult);
}
return(updateResult);
}
public async Task <IActionResult> UpdateStudentAsync(int id, UpdateStudentDTO updateStudentDTO)
{
if (ModelState.IsValid)
{
try
{
var student = _mapper.Map <Student>(updateStudentDTO);
await _context.Update(id, student);
_log.AddLog(Request, _httpContextAccessor, this.ControllerContext.RouteData.Values["controller"].ToString(), this.ControllerContext.RouteData.Values["action"].ToString(), $"Eshte edituar studenti me id: {id}");
return(Ok(new DataMessage("Studenti eshte edituar me sukses!")));
}
catch (Exception ex)
{
_log.AddLog(Request, _httpContextAccessor, this.ControllerContext.RouteData.Values["controller"].ToString(), this.ControllerContext.RouteData.Values["action"].ToString(), $"Deshtim ne editimin e studentit me id: {id}");
return(BadRequest(new DataMessage("Editimi deshtoi " + ex.Message)));
}
}
else
{
return(BadRequest(ModelState));
}
}
public async Task <IActionResult> UpdateCurrentStudent([FromBody] UpdateStudentDTO updateStudent)
{
return(await _studentService.UpdateCurrentStudentAsync(updateStudent).ConfigureAwait(false).GetObjectResponseAsync <UpdateStudentDTO>("Success").ConfigureAwait(false));
}
