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