public IActionResult UpdateCourseForAthor(Guid authorId, Guid courseId, UpdateCourseDto courseToUpdate) { if (!_courseLibraryRepository.AuthorExists(authorId)) { return(NotFound()); } var course = _courseLibraryRepository.GetCourse(authorId, courseId); if (course == null) { var courseToCreate = _mapper.Map <Course>(courseToUpdate); courseToCreate.Id = courseId; _courseLibraryRepository.AddCourse(authorId, courseToCreate); _courseLibraryRepository.Save(); var courseToReturn = _mapper.Map <CoursDto>(courseToCreate); return(CreatedAtRoute("GetCourseForAuhtor", new { authorId, courseId = courseToReturn.Id }, courseToReturn)); } _mapper.Map(courseToUpdate, course); _courseLibraryRepository.UpdateCourse(course); _courseLibraryRepository.Save(); return(NoContent()); }
public async Task <IActionResult> OnGetAsync(int?id) { if (id == null) { return(NotFound()); } Course course; try { course = await courseService.GetCourseAsync(id.Value); } catch (ApplicationException) { return(NotFound()); } CourseDto = new UpdateCourseDto { Id = course.Id, Name = course.Name, Description = course.Description, CourseType = course.CourseType, CourseImageURL = course.CourseImageURL }; return(Page()); }
public ActionResult UpdateCourse(Guid authorId, Guid courseId, UpdateCourseDto updateCourseDto) { if (!_courseLibraryRepository.AuthorExists(authorId)) { return(NotFound()); } var course = _courseLibraryRepository.GetCourse(authorId, courseId); if (course == null) { var newCourse = _mapper.Map <Course>(updateCourseDto); newCourse.Id = courseId; _courseLibraryRepository.AddCourse(authorId, newCourse); _courseLibraryRepository.Save(); var courseDto = _mapper.Map <CourseDto>(newCourse); return(CreatedAtRoute( "GetCourse", new { authorId, courseId = courseDto.Id }, courseDto )); } _mapper.Map(updateCourseDto, course); _courseLibraryRepository.UpdateCourse(course); _courseLibraryRepository.Save(); return(NoContent()); }
public async Task <IActionResult> UpdateCourse(int courseId, UpdateCourseDto dto) { var course = await _context.Courses.FindAsync(courseId); course.UpdateDetails(dto.Title, dto.Description); var validPeriod = ValidPeriod.Create(dto.BeginYear, dto.EndYear); if (validPeriod.IsFailure) { return(BadRequest(validPeriod.Error)); } course.ChangeValidPeriod(validPeriod.Value); course.ChangeCreditDetails(dto.CreditRecoveryAvailable, dto.CreditAdvancementAvailable, dto.CreditUnits); var lowGrade = _context.Grades.Find(dto.LowGradeId); var highGrade = _context.Grades.Find(dto.HighGradeId); var result = course.ChangeGradeRange(lowGrade, highGrade); if (result.IsFailure) { return(BadRequest(result.Error)); } var courseType = _context.CourseTypes.Find(dto.CourseTypeId); var courseLevel = _context.CourseLevels.Find(dto.CourseLevelId); course.ChangeCourseType(courseType, courseLevel); _context.SaveChanges(); return(Ok()); }
public ActionResult UpdateCoursePartially( Guid authorId, Guid courseId, JsonPatchDocument <UpdateCourseDto> patchDocument) { if (!_courseLibraryRepository.AuthorExists(authorId)) { return(NotFound()); } var course = _courseLibraryRepository.GetCourse(authorId, courseId); if (course == null) { var newCourseDto = new UpdateCourseDto(); patchDocument.ApplyTo(newCourseDto, ModelState); if (!TryValidateModel(newCourseDto)) { return(ValidationProblem(ModelState)); } var newCourse = _mapper.Map <Course>(newCourseDto); newCourse.Id = courseId; _courseLibraryRepository.AddCourse(authorId, newCourse); _courseLibraryRepository.Save(); var courseDto = _mapper.Map <CourseDto>(newCourse); return(CreatedAtRoute( "GetCourse", new { authorId, courseId = courseDto.Id }, courseDto )); } var updateCourseDto = _mapper.Map <UpdateCourseDto>(course); patchDocument.ApplyTo(updateCourseDto, ModelState); if (!TryValidateModel(updateCourseDto)) { return(ValidationProblem(ModelState)); } _mapper.Map(updateCourseDto, course); _courseLibraryRepository.UpdateCourse(course); _courseLibraryRepository.Save(); return(NoContent()); }
public async Task MarkAttendance(UpdateCourseDto input) { var conductedDays = (from coursetable in _courseRepository.GetAll() where coursetable.Id == input.Id select coursetable.ConductedDays).ToList(); conductedDays[0]++; input.ConductedDays = conductedDays[0]; var @course = input.MapTo <Course>(); await _courseRepository.UpdateAsync(@course); }
public async Task <IActionResult> UpdateCourse([FromForm] UpdateCourseDto input) { try { await _courseAppService.UpdateCourse(input); return(Ok()); } catch (Exception e) { Console.WriteLine(e); throw; } }
public ActionResult PartiallyUpdateCourseForAuthor(Guid authorId, Guid id, JsonPatchDocument <UpdateCourseDto> patchDocument) { if (!AuthorRepository.Exists(authorId)) { return(NotFound()); } var course = CourseRepository.GetAuthorCourse(authorId, id); if (course == null) { var courseDto = new UpdateCourseDto(); patchDocument.ApplyTo(courseDto, ModelState); if (!TryValidateModel(courseDto)) { return(ValidationProblem(ModelState)); } var courseToAdd = CourseMapper.ToCourse(courseDto, authorId); courseToAdd.Id = id; CourseRepository.Create(courseToAdd); _unitOfWork.Commit(); return(CreatedAtRoute( "GetCourseForAuthor", new { authorId, id = courseToAdd.Id }, CourseMapper.ToCourseDto(courseToAdd) )); } var courseToPatch = new UpdateCourseDto() { Description = course.Description, Title = course.Title, }; patchDocument.ApplyTo(courseToPatch, ModelState); if (!TryValidateModel(courseToPatch)) { return(ValidationProblem(ModelState)); } CourseMapper.ToCourse(courseToPatch, authorId, course); CourseRepository.Update(course); _unitOfWork.Commit(); return(NoContent()); }
public IActionResult PartiallyUpdateCourseForAthor(Guid authorId, Guid courseId, JsonPatchDocument <UpdateCourseDto> patchDocument) { if (!_courseLibraryRepository.AuthorExists(authorId)) { return(NotFound()); } var course = _courseLibraryRepository.GetCourse(authorId, courseId); if (course == null) { var courseDto = new UpdateCourseDto(); patchDocument.ApplyTo(courseDto, ModelState); if (!TryValidateModel(courseDto)) { return(ValidationProblem(ModelState)); } var courseToCreate = _mapper.Map <Course>(courseDto); courseToCreate.Id = courseId; _courseLibraryRepository.AddCourse(authorId, courseToCreate); _courseLibraryRepository.Save(); var courseToReturn = _mapper.Map <CoursDto>(courseToCreate); return(CreatedAtRoute("GetCourseForAuhtor", new { authorId, courseId = courseToReturn.Id }, courseToReturn)); } var courseToPatch = _mapper.Map <UpdateCourseDto>(course); patchDocument.ApplyTo(courseToPatch, ModelState); if (!TryValidateModel(courseToPatch)) { return(ValidationProblem(ModelState)); } _mapper.Map(courseToPatch, course); _courseLibraryRepository.UpdateCourse(course); _courseLibraryRepository.Save(); return(NoContent()); }
public async Task <ActionResult <CourseDto> > PutCourse(long id, UpdateCourseDto courseDto) { //if (id != courseModel.Id) return BadRequest(); if (!ModelState.IsValid) { return(BadRequest()); } var updatedCourse = await _coursesService.UpdateCourseAsync(id, courseDto); if (updatedCourse != null) { return(Ok(updatedCourse)); } return(StatusCode(409, "Course already exists!")); }
public async Task <IActionResult> UpdateCourse(UpdateCourseDto updateCourseDto) { var course = _mapper.Map <Course>(updateCourseDto); var result = await _courseLibraryService.UpdateCourse(course); if (result.Success) { var successOperation = result as SuccessOperationResult <Course>; var courseDto = _mapper.Map <CourseDto>(successOperation.Result); return(Ok(new SuccessOperationResult <CourseDto> { Code = successOperation.Code, Result = courseDto, })); } var failedOperation = result as FailedOperationResult <Course>; return(Ok(failedOperation)); }
public async Task <CourseDto> UpdateCourseAsync(long id, UpdateCourseDto courseModel) { try { var updatedEntity = _mapper.Map <Course>(courseModel); updatedEntity.Id = id; _unitOfWork.CourseRepository.Update(updatedEntity); await _unitOfWork.CommitAsync(); return(_mapper.Map <CourseDto>(updatedEntity)); } catch { _unitOfWork.Rollback(); return(null); } }
public async Task <Course> UpdateCourseAsync(UpdateCourseDto courseDto) { var course = await db.SelectCourseByIdAsync(courseDto.Id); course.Name = courseDto.Name; course.Description = courseDto.Description; course.CourseType = courseDto.CourseType; course.CourseImageURL = courseDto.CourseImageURL; try { this.ValidateCourseOnUpdate(course); } catch (Exception ex) { logger.LogError(ex, "Attempted to update invalid course."); throw; } return(await db.UpdateCourseAsync(course)); }
public IActionResult UpdateCourseForAuthor( [FromRoute] Guid authorId, [FromRoute] Guid id, [FromBody] UpdateCourseDto courseDto ) { if (!AuthorRepository.Exists(authorId)) { return(NotFound()); } if (courseDto == null) { return(BadRequest()); } var course = CourseRepository.GetAuthorCourse(authorId, id); if (course == null) { var courseToAdd = CourseMapper.ToCourse(courseDto, authorId); courseToAdd.Id = id; CourseRepository.Create(courseToAdd); return(CreatedAtRoute( "GetCourseForAuthor", new { authorId, id = courseToAdd.Id }, CourseMapper.ToCourseDto(courseToAdd) )); } CourseMapper.ToCourse(courseDto, authorId, course); CourseRepository.Update(course); _unitOfWork.Commit(); return(NoContent()); }
public async Task UpdateCourseAsync_ShouldReturnExpectedCourse() { // given (arrange) DateTime updateTime = DateTime.UtcNow; DateTime createTime = updateTime.AddDays(-5); Filler <UpdateCourseDto> courseFiller = new Filler <UpdateCourseDto>(); UpdateCourseDto courseToUpdateDto = courseFiller.Create(); courseToUpdateDto.Id = 1; Course courseToUpdate = this.mapper.Map <Course>(courseToUpdateDto); courseToUpdate.DateCreated = courseToUpdate.DateUpdated = createTime; Course databaseCourse = this.mapper.Map <Course>(courseToUpdate); databaseCourse.DateUpdated = updateTime; this.appDbContextMock.Setup(db => db.SelectCourseByIdAsync(courseToUpdateDto.Id)) .ReturnsAsync(courseToUpdate); this.appDbContextMock.Setup(db => db.UpdateCourseAsync(It.IsAny <Course>())) .ReturnsAsync(databaseCourse); // when (act) Course actualCourse = await subject.UpdateCourseAsync(courseToUpdateDto); // then (assert) actualCourse.Should().BeEquivalentTo(databaseCourse); Assert.Equal(actualCourse.DateUpdated, updateTime); appDbContextMock.Verify(db => db.SelectCourseByIdAsync(actualCourse.Id), Times.Once); appDbContextMock.Verify(db => db.UpdateCourseAsync(It.IsAny <Course>()), Times.Once); appDbContextMock.VerifyNoOtherCalls(); }
public async Task <Result <CourseDto> > UpdateCourseAsync(long id, UpdateCourseDto updateCourseDto) { try { if (updateCourseDto == null) { return(Result <CourseDto> .GetError(ErrorCode.ValidationError, "CourseDto is null")); } if (!await _unitOfWork.CourseRepository.IsEntityExistAsync(id)) { return(Result <CourseDto> .GetError(ErrorCode.NotFound, "Course id not found")); } if (await IsCourseNameTakenAsync(updateCourseDto.Name)) { return(Result <CourseDto> .GetError(ErrorCode.UnprocessableEntity, "Course already exists")); } var updatedEntity = _mapper.Map <Course>(updateCourseDto); updatedEntity.Id = id; _unitOfWork.CourseRepository.Update(updatedEntity); await _unitOfWork.CommitAsync(); return(Result <CourseDto> .GetSuccess(_mapper.Map <CourseDto>(updatedEntity))); } catch { _unitOfWork.Rollback(); return(Result <CourseDto> .GetError(ErrorCode.InternalServerError, "Internal error")); } }
public async Task UpdateCourseAsync_ShouldThrowExceptionForInvalidDataAnnotationRequirement() { // given (arrange) Filler <UpdateCourseDto> courseFiller = new Filler <UpdateCourseDto>(); UpdateCourseDto invalidCourseToUpdateDto = courseFiller.Create(); Course invalidCourseToUpdate = this.mapper.Map <Course>(invalidCourseToUpdateDto); invalidCourseToUpdateDto.Name = null; this.appDbContextMock.Setup(db => db.SelectCourseByIdAsync(invalidCourseToUpdateDto.Id)) .ReturnsAsync(invalidCourseToUpdate); // when (act) var actualCourseTask = subject.UpdateCourseAsync(invalidCourseToUpdateDto); // then (assert) await Assert.ThrowsAsync <ValidationException>(() => actualCourseTask); appDbContextMock.Verify(db => db.SelectCourseByIdAsync(invalidCourseToUpdateDto.Id), Times.Once); appDbContextMock.VerifyNoOtherCalls(); }
public bool UpdateCourseForAuthor(Guid authorId, Guid courseId, UpdateCourseDto course) { if (!_repo.AuthorExists(authorId)) { return(false); } var courseToUpdate = _repo.GetCourse(authorId, courseId); if (courseToUpdate == null) { return(false); } // EF is tracking "courseToUpdate" so by executing the next line _mapper.Map the entity has changed // to a modified state so executing the Save will write the changes to the database. // We could just omit the Update statement, however this would be incorrect, in the future something // may change which would require some functionality in the update process. // The user of the repository does not need to know this. _mapper.Map(course, courseToUpdate); _repo.UpdateCourse(courseToUpdate); _repo.Save(); return(true); }
public ActionResult UpdateCourseForAuthor(Guid authorId, Guid courseId, UpdateCourseDto course) { var x = _manager.UpdateCourseForAuthor(authorId, courseId, course); return(x ? NoContent() : (ActionResult)NotFound()); }
public async Task Update(UpdateCourseDto input) { var @course = input.MapTo <Course>(); await _courseRepository.UpdateAsync(@course); }
public async Task <ActionResult <CourseDto> > PutCourse(long id, UpdateCourseDto courseDto) { var updatedCourse = await _coursesService.UpdateCourseAsync(id, courseDto); return(updatedCourse.ToActionResult()); }
public async Task UpdateCourse(UpdateCourseDto input) { var isExistCourse = await _courseRepository.GetAll().AnyAsync(x => x.Id == input.Id); if (!isExistCourse) { throw new Exception("Bu kurs mevcut degil!"); } var course = await _courseRepository.GetAll().FirstAsync(x => x.Id == input.Id); course.Id = input.Id; course.Description = input.Description; course.Title = input.Title; course.Price = input.Price; course.Quota = input.Quota; course.Address = input.Address; course.OnlineVideo = input.OnlineVideo; course.Certificate = input.Certificate; course.CertificateOfParticipation = input.CertificateOfParticipation; course.Requirements = input.Requirements; course.Teachings = input.Teachings; course.DurationCount = input.DurationCount; course.DurationType = input.DurationType; course.DiscountPrice = input.DiscountPrice; course.StartDate = input.StartDate; course.EndDate = input.EndDate; course.CategoryId = input.CategoryId; if (input.File != null) { var imagePath = await _blobService.InsertFile(input.File); course.ImagePath = imagePath; } await _courseRepository.UpdateAsync(course); if (input.EducatorId == null) { long[] a = new long[0]; input.EducatorId = a; } if (input.TenantId == null) { long[] b = new long[0]; input.TenantId = b; } var givenCourses = await _givenCourseRepository.GetAll().Where(x => x.CourseId == input.Id).ToListAsync(); var count = (input.TenantId.Length > input.EducatorId.Length) ? input.TenantId.Length : input.EducatorId.Length; var loopCount = givenCourses.Count > count ? givenCourses.Count : count; for (var i = 0; i <= loopCount; i++) { // db deki her column tenantId educatorId degerini sirayla gunceller.Inputta karsiligi yoksa null degeri atar. // en son ikiside null ise egitmen ve kurum sayisi azalmistir. Columnu siler. if (givenCourses.Count > i) { if (input.TenantId.Length > i) { givenCourses[i].TenantId = input.TenantId[i]; } else { if (givenCourses[i].TenantId.HasValue) { givenCourses[i].TenantId = null; } } if (input.EducatorId.Length > i) { givenCourses[i].EducatorId = input.EducatorId[i]; } else { if (givenCourses[i].EducatorId.HasValue) { givenCourses[i].EducatorId = null; } } await _givenCourseRepository.UpdateAsync(givenCourses[i]); if (givenCourses[i].TenantId != null || givenCourses[i].EducatorId != null) { continue; } await _givenCourseRepository.DeleteAsync(givenCourses[i]); } // tablodaki data input dan az ise geri kalanlari db ye ekler. Fazladan egitmen yada kurum eklenmistir. else if (input.TenantId.Length > i || input.EducatorId.Length > i) { var givenCourse = new GivenCourse { CourseId = course.Id, }; if (input.TenantId.Length > i) { givenCourse.TenantId = input.TenantId[i]; } if (input.EducatorId.Length > i) { givenCourse.EducatorId = input.EducatorId[i]; } await _givenCourseRepository.AddAsync(givenCourse); } } }
public async Task UpdateCourse() { //Arrange long notExistingCourseId = -10; var updateCourseDto = new UpdateCourseDto() { Name = "new_test_name" }; var existingCourseDto = new UpdateCourseDto() { Name = "Test_name" }; var existingCourse = new Course() { Id = 10, Name = "Test_name" }; var courseRepositoryMock = new Mock <ICourseRepository>(); courseRepositoryMock.Setup(x => x.IsEntityExistAsync(notExistingCourseId)) .ReturnsAsync(false); courseRepositoryMock.Setup(x => x.IsEntityExistAsync(existingCourse.Id)) .ReturnsAsync(true); courseRepositoryMock.Setup(x => x.IsCourseNameTakenAsync(updateCourseDto.Name)) .ReturnsAsync(false); courseRepositoryMock.Setup(x => x.IsCourseNameTakenAsync(existingCourse.Name)) .ReturnsAsync(true); _unitOfWorkMock.Setup(x => x.CourseRepository).Returns(courseRepositoryMock.Object); var courseService = new CourseService( _unitOfWorkMock.Object, _mapper ); //Act var successResult = await courseService.UpdateCourseAsync(existingCourse.Id, updateCourseDto); var courseNameExistResult = await courseService.UpdateCourseAsync(existingCourse.Id, existingCourseDto); var courseNotExistResult = await courseService.UpdateCourseAsync(notExistingCourseId, updateCourseDto); var nullCourseResult = await courseService.UpdateCourseAsync(existingCourse.Id, null); //Assert Assert.NotNull(successResult.Data); Assert.Equal(successResult.Data.Name, successResult.Data.Name); Assert.Equal(ErrorCode.UnprocessableEntity, courseNameExistResult.Error.Code); Assert.Equal(ErrorCode.NotFound, courseNotExistResult.Error.Code); Assert.Equal(ErrorCode.ValidationError, nullCourseResult.Error.Code); }