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()); }