public async Task <IActionResult> PartiallyUpdateCourse(
Guid classId,
Guid studentId,
Guid courseId,
JsonPatchDocument <CourseUpdateDto> patchDocument
)
{
if (!await _studentRepository.StudentExitAsync(studentId))
{
return(NotFound());
}
var courseEntity = await _courseRepository.GetCourseAsync(studentId, courseId);
if (courseEntity == null)
{
var courseDto = new CourseUpdateDto();
patchDocument.ApplyTo(courseDto, ModelState);
if (!TryValidateModel(courseDto))
{
return(ValidationProblem(ModelState));
}
var courseToAdd = _mapper.Map <Course>(courseDto);
courseToAdd.CourseId = courseId;
courseToAdd.StudentId = studentId;
_courseRepository.AddCourse(courseId, courseToAdd);
await _courseRepository.SaveAsync();
var dtoToReturn = _mapper.Map <CourseDto>(courseEntity);
return(CreatedAtRoute(
nameof(GetCourse),
new{
classId = classId,
studentId = studentId,
courseId = dtoToReturn.CourseId
}, dtoToReturn
));
}
var dtoToPatch = _mapper.Map <CourseUpdateDto>(courseEntity);
patchDocument.ApplyTo(dtoToPatch, ModelState);
if (!TryValidateModel(dtoToPatch))
{
return(ValidationProblem(ModelState));
}
_mapper.Map(dtoToPatch, courseEntity);
_courseRepository.UpdateCourse(courseEntity);
await _courseRepository.SaveAsync();
return(NoContent());
}
public async Task <ActionResult> PutCourse(int id, [FromBody] CourseUpdateDto course)
{
_logger.LogInformation(ConstantVarriables.CourseApiPutCourseEnterMessage);
ObjectResult response;
if (id != course.CourseId)
{
response = BadRequest(ConstantVarriables.NoValidData);
}
else
{
try
{
var courseEntity = _mapper.Map <Course>(course);
await _courseService.UpdateCourse(id, courseEntity);
response = Ok(ConstantVarriables.DataUpdated);
}
catch (Exception ex)
{
_logger.LogError(ex, ex.Message);
response = BadRequest(ConstantVarriables.GenericExeptionMessage);
}
}
_logger.LogInformation(ConstantVarriables.CourseApiPutCourseExitMessage);
return(response);
}
public IActionResult AdminUpdateCourse(int courseId, CourseUpdateDto info)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
//check id
if (courseId != info.CourseId)
{
return(BadRequest("Unmatched course id."));
}
try
{
var course = courseManager.UpdateCourse(info);
return(Ok(course));
}
catch (CustomDbException e)
{
return(BadRequest(e.Message));
}
catch (UnauthorizedAccessException)
{
return(Forbid());
}
}
public IActionResult UpdateCourse(int courseId, CourseUpdateDto info)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
//authentication
if (!Int32.TryParse(User.FindFirst("userId").Value, out int userId))
{
return(Forbid());
}
;
if (info.PublisherId != userId)
{
return(Forbid());
}
try
{
var course = courseManager.UpdateCourse(info);
return(Ok(course));
}
catch (CustomDbException e)
{
return(BadRequest(e.Message));
}
}
public async Task <IActionResult> UpdateCourseForAuthor(Guid authorId,
Guid courseId,
CourseUpdateDto course)
{
//Check if author exists
if (!await _authorRepository.AuthorExistsAsync(authorId))
{
return(NotFound());
}
//Check if course exists
var courseForAuthorEntity = await _courseRepository.GetCourseAsync(authorId, courseId);
if (courseForAuthorEntity == null)
{
// return NotFound();
// Upsert pattern - need to create the course
var courseToAdd = _mapper.Map <Course>(course);
// Get course Id from URI
courseToAdd.Id = courseId;
await _courseRepository.AddCourseAsync(authorId, courseToAdd);
//201 return - correct sc since a new resource has been created.
var courseToReturn = _mapper.Map <CourseDto>(courseToAdd);
return(CreatedAtRoute("GetCourseForAuthor",
new { authorId, courseId = courseToReturn.Id }, courseToReturn));
}
// EF core - tracker marks entity as modified.
_mapper.Map(course, courseForAuthorEntity);
await _courseRepository.UpdateCourseAsync(courseForAuthorEntity);
// Status code 204 - no content returned
return(NoContent());
}
public async Task <ActionResult <CourseDto> > UpdateCourse(Guid courseId, CourseUpdateDto courseUpdateDto)
{
if (!await _courseRepository.CourseExistAsync(courseId))
{
return(NotFound());
}
var course = await _courseRepository.GetCourseAsync(courseId);
if (course == null)
{
var courseToAdd = _mapper.Map <Course>(courseUpdateDto);
courseToAdd.CourseId = courseId;
_courseRepository.AddCourse(courseToAdd);
await _courseRepository.SaveAsync();
var courseDtoNew = _mapper.Map <CourseDto>(courseToAdd);
return(CreatedAtRoute(nameof(GetCourse), new { courseId = course.CourseId }, courseDtoNew));
}
_mapper.Map(courseUpdateDto, course);
_courseRepository.UpdateCourse(course);
await _courseRepository.SaveAsync();
var courseDto = _mapper.Map <CourseDto>(course);
return(CreatedAtRoute(nameof(GetCourse), new { courseId = course.CourseId }, courseDto));
}
public IActionResult Put(Guid authorId, Guid courseId, CourseUpdateDto courseUpdateDto)
{
if (!_repository.AuthorExists(authorId))
{
return(NotFound());
}
var course = _repository.GetCourse(authorId, courseId);
if (course == null)
{
course = _mapper.Map <Course>(courseUpdateDto);
course.Id = courseId;
_repository.AddCourse(authorId, course);
_repository.Save();
return(base.CreatedAtAction(
"GetCourseForAuthor",
new
{
authorId,
courseId
},
_mapper.Map <CourseDto>(course)));
}
_mapper.Map(courseUpdateDto, course);
_repository.UpdateCourse(course);
_repository.Save();
return(NoContent());
}
public async Task <OkResponse <CourseDto> > UpdateAsync(CourseUpdateDto dto)
{
if (dto == null || string.IsNullOrEmpty(dto.Id) || string.IsNullOrEmpty(dto.Name))
{
return(OkResponse <CourseDto> .Error(HttpStatusCode.BadRequest, "Model is not valid!"));
}
var updateCourse = _mapper.Map <Course>(dto);
var result = await _courseCollection.FindOneAndReplaceAsync(x => x.Id == updateCourse.Id, updateCourse);
if (result == null)
{
return(OkResponse <CourseDto> .Error(HttpStatusCode.NotFound, "Course is not found."));
}
var mapDto = _mapper.Map <CourseDto>(result);
if (!string.IsNullOrEmpty(result.CategoryId))
{
var category = await _categoryCollection.Find(x => x.Id == result.CategoryId).FirstOrDefaultAsync();
mapDto.Category = _mapper.Map <CategoryDto>(category);
}
return(OkResponse <CourseDto> .Success(HttpStatusCode.OK, mapDto));
}
public IActionResult UpdateCourseForAuthor(Guid authorId, Guid courseId, CourseUpdateDto course)
{
if (!_courseLibraryRepository.AuthorExists(authorId))
{
return(NotFound());
}
var courseFromRepo = _courseLibraryRepository.GetCourse(authorId, courseId);
if (courseFromRepo == null)
{
// return NotFound();
var courseToAdd = _mapper.Map <Course>(course);
courseToAdd.Id = courseId;
_courseLibraryRepository.AddCourse(authorId, courseToAdd);
_courseLibraryRepository.Save();
var courseToReturn = _mapper.Map <CourseDto>(courseToAdd);
return(CreatedAtRoute(nameof(GetCourseForAuthor), new { authorId, courseId = courseToAdd.Id, }, courseToReturn));
}
_mapper.Map(course, courseFromRepo);
_courseLibraryRepository.UpdateCourse(courseFromRepo);
_courseLibraryRepository.Save();
return(NoContent());
}
public CourseDisplayDto UpdateCourse(CourseUpdateDto info)
{
var course = courseRepository.UpdateCourse(info);
var displayCourse = mapper.Map <Course, CourseDisplayDto>(course);
return(displayCourse);
}
public async Task <Response <NoContent> > UpdateAsync(CourseUpdateDto courseUpdateDto)
{
var course = _mapper.Map <Course>(courseUpdateDto);
var result = await courseCollection.FindOneAndReplaceAsync(x => x.Id == course.Id, course);
if (result is null)
{
return(Response <NoContent> .Fail(StatusCodes.Status404NotFound, "Course not found"));
}
return(Response <NoContent> .Success(StatusCodes.Status204NoContent));
}
public async Task <Response <NoContent> > UpdateAsync(CourseUpdateDto courseUpdateDto)
{
var updateCourse = _mapper.Map <Course>(courseUpdateDto);
var result = await _courseCollection.FindOneAndReplaceAsync(x => x.Id == courseUpdateDto.Id, updateCourse);
if (result == null)
{
return(Response <NoContent> .Fail("Course Not Found", 404));
}
return(Response <NoContent> .Success(204));
}
public async Task <IHttpActionResult> Update(CourseUpdateDto model)
{
var result = await _courseService.Update(model);
if (!result)
{
return(BadRequest());
}
return(Ok());
}
public async Task <MessageResult> UpdateAsync(CourseUpdateDto categoryDto)
{
var course = _mapper.Map <Course>(categoryDto);
var result = await _courseCollection.FindOneAndReplaceAsync(x => x.Id == course.Id, course);
if (result == null)
{
return(MessageResult.Error("Will update data not found", StatusCode.NotFound));
}
return(MessageResult.Success(StatusCode.Ok));
}
public async Task <Response <NoContent> > UpdateAsync(CourseUpdateDto input)
{
var updateCourse = _mapper.Map <Course>(input);
var result = await _courseCollection.FindOneAndReplaceAsync(a => a.Id == input.Id, updateCourse);
if (result == null)
{
return(Response <NoContent> .Fail("Course not found", 404));
}
return(Response <NoContent> .Success(204));
}
public async Task <Response <NoContent> > UpdateAsync(CourseUpdateDto courseUpdateDto)
{
var updataCourse = _mapper.Map <Course>(courseUpdateDto);
var result = await _courseCollection.FindOneAndReplaceAsync(x => x.Id == courseUpdateDto.Id, updataCourse); //find ile bulup virgülden sonraki ile güncelliyor
if (result == null)
{
return(Response <NoContent> .Fail("Course not found", 404));
}
return(Response <NoContent> .Success(204));//body'siz olmayan başarılı durum kodu
}
public ActionResult PartiallyUpdateCourseForAuthor(Guid authorId,
Guid courseId,
JsonPatchDocument <CourseUpdateDto> patchDocument)
{
if (!_courseRepository.AuthorExists(authorId))
{
return(NotFound());
}
var courseForAuthorFromRepo = _courseRepository.GetCourse(authorId, courseId);
if (courseForAuthorFromRepo == null)
{
var courseDto = new CourseUpdateDto();
patchDocument.ApplyTo(courseDto, ModelState);
if (!TryValidateModel(courseDto))
{
return(ValidationProblem(ModelState));
}
var courseToAdd = _mapper.Map <Course>(courseDto);
courseToAdd.Id = courseId;
_courseRepository.AddCourse(authorId, courseToAdd);
_courseRepository.Save();
var courseToReturn = _mapper.Map <CourseDto>(courseToAdd);
return(CreatedAtRoute("GetCourseForAuthor",
new { authorId, courseId = courseToReturn.Id },
courseToReturn));
}
var courseToPatch = _mapper.Map <CourseUpdateDto>(courseForAuthorFromRepo);
// add validation
patchDocument.ApplyTo(courseToPatch, ModelState);
if (!TryValidateModel(courseToPatch))
{
return(ValidationProblem(ModelState));
}
_mapper.Map(courseToPatch, courseForAuthorFromRepo);
_courseRepository.UpdateCourse(courseForAuthorFromRepo);
_courseRepository.Save();
return(NoContent());
}
public async Task <IActionResult> PartialUpdateProgrammeAsync(Guid authorId, Guid courseId,
// CourseUpdateDto cannot contain and Id
[FromBody] JsonPatchDocument <CourseUpdateDto> coursePatchDocument)
{
if (!await _authorRepository.AuthorExistsAsync(authorId))
{
return(NotFound());
}
var courseFromDb = await _courseRepository.GetCourseAsync(authorId, courseId);
if (courseFromDb == null)
{
// Upserting with PATCH. Includes normal validation
var courseDto = new CourseUpdateDto();
coursePatchDocument.ApplyTo(courseDto, ModelState);
if (!TryValidateModel(courseDto))
{
return(ValidationProblem(ModelState));
}
var courseToAdd = _mapper.Map <Course>(courseDto);
courseToAdd.Id = courseId;
await _courseRepository.AddCourseAsync(authorId, courseToAdd);
var courseToReturn = _mapper.Map <CourseDto>(courseToAdd);
return(CreatedAtRoute("GetCourseForAuthor",
new { authorId, courseToReturn.Id },
courseToReturn));
}
var courseToPatch = _mapper.Map <CourseUpdateDto>(courseFromDb);
// Validation - adding ModelState argument in ApplyTo will cause any errors in the patch document to make
// the ModelState invalid. TryValidateModel below looks after reporting validation issues found here
coursePatchDocument.ApplyTo(courseToPatch, ModelState);
// Add validation after completing work with jsonPatch document
// Validate that the incoming Dto class properties. Errors captured in ModelState
if (!TryValidateModel(courseToPatch))
{
// Creates an ActionResult - sc 400 bad request with errors from modelStateDictionary
return(ValidationProblem(ModelState));
}
_mapper.Map(courseToPatch, courseFromDb);
await _courseRepository.UpdateCourseAsync(courseFromDb);
return(NoContent());
}
public ActionResult UpdateCourse(int courseId, CourseUpdateDto courseUpdateDto)
{
var courseModelFromRepo = _baseLibRepository.GetCourse(courseId);
if (courseModelFromRepo == null)
{
return(NotFound());
}
_mapper.Map(courseUpdateDto, courseModelFromRepo);
_baseLibRepository.UpdateCourse(courseModelFromRepo);
_baseLibRepository.SaveChanges();
return(NoContent());
}
public async Task <Response <NoContent> > UpdateAsync(CourseUpdateDto model)
{
var course = await _courseRepository.GetByIdAsync(model.Id);
if (course == null)
{
var errors = new List <string>();
errors.Add("No valid course!");
return(Response <NoContent> .Fail(errors, 404));
}
await _courseRepository.UpdateAsync(_mapper.Map <Course>(model));
return(Response <NoContent> .Success(200, true));
}
public async Task <Response <NoContent> > UpdateAsync(CourseUpdateDto courseUpdateDto)
{
var updatedCourse = _mapper.Map <Course>(courseUpdateDto);
var result = await _courseCollection.FindOneAndReplaceAsync(x => x.Id == courseUpdateDto.Id, updatedCourse);
if (result == null)
{
return(Response <NoContent> .Fail("Course not found", 404));
}
await _publishEndpoint.Publish <CourseNameChangedEvent>(new CourseNameChangedEvent { CourseId = updatedCourse.Id, UpdatedName = courseUpdateDto.Name });
return(Response <NoContent> .Success(204));
}
public async Task Course_Put_Test()
{
CourseUpdateDto course = new CourseUpdateDto()
{
CourseId = 4,
CourseName = "Test Course Update",
ProgramId = 1
};
var results = await _courseApiController.PutCourse(course.CourseId, course);
var objectResult = results as ObjectResult;
Assert.NotNull(results);
Assert.NotNull(objectResult);
Assert.AreEqual(200, objectResult.StatusCode);
}
public ActionResult UpdateCourse(int id, CourseUpdateDto studentUpdateDto)
{
var courseModelFormRepo = _repository.GetCourseById(id);
if (courseModelFormRepo == null)
{
return(NotFound());
}
else
{
_mapper.Map(studentUpdateDto, courseModelFormRepo);
_repository.UpdateCourse(courseModelFormRepo);
_repository.SaveChanges();
return(Ok());
}
}
public IActionResult Update([FromBody] CourseUpdateDto courseUpdateDto)
{
Guid courseId;
if (Guid.TryParse(courseUpdateDto.Id, out courseId))
{
var courseToUpdate = _courseRepository.Get(courseId);
if (courseToUpdate == null)
{
return(NotFound());
}
if (!string.IsNullOrEmpty(courseUpdateDto.CourseDescription))
{
courseToUpdate.CourseDescription = courseUpdateDto.CourseDescription;
}
if (!string.IsNullOrEmpty(courseUpdateDto.CourseIdentifier))
{
courseToUpdate.CourseIdentifier = courseUpdateDto.CourseIdentifier;
}
if (!string.IsNullOrEmpty(courseUpdateDto.CourseName))
{
courseToUpdate.CourseName = courseUpdateDto.CourseName;
}
int hours;
if (Int32.TryParse(courseUpdateDto.CourseHours, out hours))
{
courseToUpdate.CourseHours = Convert.ToInt32(courseUpdateDto.CourseHours);
}
var response = _courseRepository.Update(courseToUpdate);
if (response.Success)
{
return(Ok($"Course with id {courseId} was successfully updated."));
}
else
{
return(StatusCode(500, response.Message));
}
}
else
{
return(NotFound());
}
}
public ActionResult PartiallyUpdatedCourseForAuthors
(
Guid authorId,
Guid courseId,
JsonPatchDocument <CourseUpdateDto> patchDocument
)
{
if (!_courseLibraryRepository.AuthorExists(authorId))
{
return(NotFound("Unable to find author"));
}
var courseFromRepo = _courseLibraryRepository.GetCourse(authorId, courseId);
if (courseFromRepo == null)
{
var newCourse = new CourseUpdateDto();
patchDocument.ApplyTo(newCourse);
var courseToAdd = _mapper.Map <Course>(newCourse);
courseToAdd.Id = courseId;
_courseLibraryRepository.AddCourse(authorId, courseToAdd);
_courseLibraryRepository.Save();
var returner = _mapper.Map <CourseDto>(courseToAdd);
return(CreatedAtRoute("GetCourseForAuthor",
new { authorId, courseId = courseToAdd.Id },
courseToAdd));
//return NotFound("Course not found");
}
var coursePatch = _mapper.Map <CourseUpdateDto>(courseFromRepo);
patchDocument.ApplyTo(coursePatch, ModelState);
if (!TryValidateModel(coursePatch))
{
return(ValidationProblem(ModelState));
}
_mapper.Map(coursePatch, courseFromRepo);
_courseLibraryRepository.UpdateCourse(courseFromRepo);
_courseLibraryRepository.Save();
return(NoContent());
}
public async Task <bool> Update(CourseUpdateDto model)
{
try
{
var query = _context.Course.FirstOrDefault(x => x.Id == model.Id);
query.Name = model.Name;
query.Comment = model.Comment;
query.LessonId = model.LessonId;
await _context.SaveChangesAsync();
return(true);
}
catch (Exception)
{
return(false);
}
}
public async Task <Response <NoContent> > UpdateAsync(CourseUpdateDto courseUpdateDto)
{
var updateCourse = _mapper.Map <Course>(courseUpdateDto);
//Buradaki yapı course tablosuna git.
//FindOneAndReplaceAsync => bull ve değiştir.
//courseUpdateDto daki Id ile courseleri ara
//eğer kayıt varsa git db de yakalanan "updateCourse" kaydını güncelle.
//Eğer kayıt yok ise result null olacaktır.
var result = await _courseCollection.FindOneAndReplaceAsync(t => t.Id == courseUpdateDto.Id, updateCourse);
if (result == null)
{
return(Response <NoContent> .Fail("Couse Not Found", 404));
}
//Güncelleme de 204 yani body'si olmayan sadece başarılı durum kodu dönülür..
return(Response <NoContent> .Success(204));
}
public async Task <ActionResult <CourseDto> > UpdateCourse(
Guid classId,
Guid studentId,
Guid courseId,
[FromBody] CourseUpdateDto course
)
{
if (!await _studentRepository.StudentExitAsync(studentId))
{
return(NotFound());
}
var courseEntity = await _courseRepository.GetCourseAsync(studentId, courseId);
if (courseEntity == null)
{
var courseToAddEntity = _mapper.Map <Course>(course);
courseToAddEntity.CourseId = courseId;
_courseRepository.AddCourse(studentId, courseToAddEntity);
await _courseRepository.SaveAsync();
var dtoToReturn = _mapper.Map <CourseDto>(courseToAddEntity);
return(CreatedAtRoute(
nameof(GetCourse),
new{
classId = classId,
courseId = dtoToReturn.CourseId
}, dtoToReturn
));
}
_mapper.Map(course, courseEntity);
_courseRepository.UpdateCourse(courseEntity);
await _courseRepository.SaveAsync();
return(NoContent());
}
public Course UpdateCourse(CourseUpdateDto info)
{
//check publisher has auth to publish
var user = context.Users
.Include(x => x.Role)
.Where(x => x.Id == info.PublisherId)
.FirstOrDefault();
if (!CanPublish(user))
{
throw new UnauthorizedAccessException();
}
//check course to be updated exists
var course = Records
.Where(x => x.CourseId == info.CourseId &&
x.PublisherId == info.PublisherId)
.FirstOrDefault();
if (course == null)
{
throw new UnauthorizedAccessException();
}
//check values
if (Records
.Any(x => x.CourseId != info.CourseId && x.Name == info.Name))
{
throw new CustomDbException("course name existed");
}
//update
var entry = context.Entry(course);
entry.CurrentValues.SetValues(info);
entry.State = EntityState.Modified;
context.SaveChanges();
return(course);
}
public ActionResult UpdateCourseForAuthor(
Guid authorId,
Guid courseId,
CourseUpdateDto courseUpdateDto)
{
if (!_courseLibraryRepository.AuthorExists(authorId))
{
return(NotFound("Author does not exist"));
}
var courseFromRepo = _courseLibraryRepository.GetCourse(authorId, courseId);
if (courseFromRepo == null)
{
//create a new entity (Upserting)
var courseAddition = _mapper.Map <Course>(courseUpdateDto);
courseAddition.Id = courseId;
_courseLibraryRepository.AddCourse(authorId, courseAddition);
_courseLibraryRepository.Save();
var returner = _mapper.Map <CourseDto>(courseAddition);
return(CreatedAtRoute(
"GetCourseForAuthor",
new
{
authorId,
courseId = courseAddition.Id
}, returner));
}
_mapper.Map(courseUpdateDto, courseFromRepo);
_courseLibraryRepository.UpdateCourse(courseFromRepo);
_courseLibraryRepository.Save();
return(NoContent());
}