public ActionResult <CourseDto> CreateCourseForAuthor(Guid authorId, CourseForCreationDto course)
{
try
{
if (!_courseLibraryRepository.AuthorExists(authorId))
{
return(NotFound());
}
var courseEntity = _mapper.Map <Course>(course);
_courseLibraryRepository.AddCourse(authorId, courseEntity);
_courseLibraryRepository.Save();
var courseToReturn = _mapper.Map <CourseDto>(courseEntity);
return(CreatedAtRoute("GetCourseForAuthor",
new
{
authorId = authorId,
courseId = courseToReturn.Id
}, courseToReturn));
}
catch (Exception ex)
{
_logger.LogError(ex, $"{ex.Message}");
return(StatusCode(500, "Internal server error, try again later."));
}
}
public ActionResult <CourseDto> CreateCoursesForAuthor(Guid authorId, [FromBody] CreateCourseDto createCourseDto)
{
if (!_courseLibraryRepository.AuthorExists(authorId))
{
return(NotFound("Author does not exist please check and try again"));
}
var createCourse = _mapper.Map <Course>(createCourseDto);
_courseLibraryRepository.AddCourse(authorId, createCourse);
var solution = _courseLibraryRepository.Save();
var courseReturn = _mapper.Map <CourseDto>(createCourse);
if (solution)
{
return(CreatedAtRoute(
"GetCourseForAuthor",
new{
authorId = courseReturn.AuthorId,
courseId = courseReturn.Id
},
courseReturn));
}
return(BadRequest("An error occurred unable to save changes"));
}
public ActionResult <CourseDto> CreateCourseForAuthor(
Guid authorId,
[FromBody] CourseCreationDto courseCreationDto)
{
if (!_repository.AuthorExists(authorId))
{
return(NotFound());
}
var course = _mapper.Map <Course>(courseCreationDto);
_repository.AddCourse(authorId, course);
var isSaved = _repository.Save();
if (!isSaved)
{
throw new InvalidOperationException("Error occurred: Unable to create course");
}
var courseDto = _mapper.Map <CourseDto>(course);
return(CreatedAtAction(
"GetCourseForAuthor",
new
{
authorId,
courseId = courseDto.Id
},
courseDto));
}
public ActionResult <CourseDTO> CreateCouse(
Guid authorId, CourseForCreationDTO course
)
{
if (_clRepo.AuthorExists(authorId))
{
return(NotFound());
}
var courseEntity = _mapper.Map <Course>(course);
_clRepo.AddCourse(authorId, courseEntity);
_clRepo.Save();
var courseToReturn = _mapper.Map <CourseDTO>(courseEntity);
return(CreatedAtRoute(
"GetCourseForAuthor",
new {
authorId = courseToReturn.AuthorId,
courseId = courseToReturn.Id
},
courseToReturn
));
}
public IActionResult AddCourseForAuthor(Guid authorId, CourseForCreationDto courseDto)
{
var entity = mapper.Map <Course>(courseDto);
courseLibraryRepository.AddCourse(authorId, entity);
courseLibraryRepository.Save();
return(CreatedAtRoute("GetCourse", new { authorId = authorId, courseId = entity.Id }, entity));
}
public ActionResult <CourseDto> CreateCourseForAuthor(Guid authorId, CourseForCreationDto courseDtoForCreation)
{
var courseEntity = _mapper.Map <Course>(courseDtoForCreation);
_courseLibraryRepository.AddCourse(authorId, courseEntity);
_courseLibraryRepository.Save();
var courseToReturn = _mapper.Map <CourseDto>(courseEntity);
return(CreatedAtRoute("GetCourseForAuthor", new { authorId = authorId, courseId = courseToReturn.Id }, courseToReturn));
}
public ActionResult <CourseDto> Post(Guid authorId, CourseForCreationDto course)
{
if (!_repository.AuthorExists(authorId))
{
return(NotFound());
}
var newCourse = _mapper.Map <Course>(course);
_repository.AddCourse(authorId, newCourse);
_repository.Save();
return(CreatedAtRoute("GetCourse", new { authorId, courseId = newCourse.Id }, newCourse));
}
public ActionResult <CourseDto> CreateCourseForAuthor(Guid authorId, CourseForCreationDto courseForCreation)
{
if (!_courseLibraryRepository.AuthorExists(authorId))
{
return(NotFound());
}
var courseEntity = _mapper.Map <Course>(courseForCreation);
_courseLibraryRepository.AddCourse(authorId, courseEntity);
_courseLibraryRepository.Save();
var courseToReturn = _mapper.Map <CourseDto>(courseEntity);
return(CreatedAtAction("GetCourseForAuthor", new { authorId = authorId, CourseId = courseToReturn.Id }, courseToReturn));
}
public ActionResult <IEnumerable <CourseDto> > CreateCourseForAuthor(Guid authorId, CourseForCreationDto courseForCreationDto)
{
if (!_courseLibraryRepository.AuthorExists(authorId))
{
return(NotFound());
}
var courseForCreation = _mapper.Map <Course>(courseForCreationDto);
_courseLibraryRepository.AddCourse(authorId, courseForCreation);
_courseLibraryRepository.Save();
return(CreatedAtRoute("GetCourseForAuthor", new { authorId, courseId = courseForCreation.Id }, _mapper.Map <CourseDto>(courseForCreation)));
}
public ActionResult <CoursesDto> CreateCourseForAuthor(Guid authorId, CourseForCreationDto courseForCreationDto)
{
if (!_courselibraryRepository.AuthorExists(authorId))
{
return(NotFound());
}
var courseEntity = _mapper.Map <Entities.Course>(courseForCreationDto);
_courselibraryRepository.AddCourse(authorId, courseEntity);
_courselibraryRepository.Save();
var courseDto = _mapper.Map <CoursesDto>(courseEntity);
return(CreatedAtRoute("GetCoursesForAuthor", new { authorId = authorId, courseId = courseDto.Id }, courseDto));
}
public ActionResult <CourseDto> CreateCourse(Guid authorId, CreateCourseDto createCourseDto)
{
if (!_courseRepository.AuthorExists(authorId))
{
return(NotFound());
}
var course = _mapper.Map <Course>(createCourseDto);
_courseRepository.AddCourse(authorId, course);
_courseRepository.Save();
var courseDto = _mapper.Map <CourseDto>(course);
return(CreatedAtRoute("GetCoursesForAuthor", new { authorId = course.AuthorId, courseId = course.Id }, courseDto));
}
public ActionResult <CoursesDTO> CreateCourseForAuthor(int authorId, createCourseForAuthorDTOW createCourse)
{
//check if the author exists
var singleauthor = _courseLibrary.GetAuthor(authorId);
if (singleauthor == null)
{
return(NotFound(new JsonResponse <string>()
{
Success = false,
ErrorMessage = "AuthorId is Invalid."
}));
}
var course = _mapper.Map <Entities.Course>(createCourse);
//course.ID = authorId;
_courseLibrary.AddCourse(authorId, course);
_courseLibrary.Save();
var createdCourse = _mapper.Map <CoursesDTO>(course);
return(CreatedAtRoute("getCourseForAnAuthor", new { authorId = authorId, courseId = createdCourse.ID }, createdCourse));
//return Ok(new JsonResponses<AuhtorDTO>()
//{
// Success = true,
// Result = new List<AuhtorDTO>() {
// createdAuthor
// }
//});
}
public async Task <ActionResult <CourseDto> > CreateCourseForAnAuthor(Guid authorId, CourseForCreateDTO dto)
{
if (!await mRepository.AuthorExistsAsync(authorId))
{
return(NotFound());
}
var createdEntity = mMapper.Map <Course>(dto);
mRepository.AddCourse(authorId, createdEntity);
await mRepository.SaveChangesAsync();
var createdDto = mMapper.Map <CourseDto>(createdEntity);
return(CreatedAtRoute("GetCourseOfAnAuthor", new { authorId, courseId = createdDto.Id },
createdDto));
}
public ActionResult <CourseDto> CreateCourseForAuthor(Guid authorId, [FromBody] CourseForCreationDto course)
{
if (!_courseLibraryRepository.AuthorExists(authorId))
{
return(NotFound());
}
var courseEntity = _mapper.Map <Entities.Course>(course);
_courseLibraryRepository.AddCourse(authorId, courseEntity);
_courseLibraryRepository.Save();
var courseDtoToReturn = _mapper.Map <Models.CourseDto>(courseEntity);
return(CreatedAtRoute("GetCourseForAuthor", new { authorId, courseId = courseDtoToReturn.Id }, courseDtoToReturn));
}
public ActionResult <CourseDto> CreateCourseForAuthor(Guid authorId, CourseForCreationDto courseForCreation)
{
if (!courseRepo.AuthorExists(authorId))
{
return(NotFound());
}
var course = mapper.Map <Course>(courseForCreation);
courseRepo.AddCourse(authorId, course);
courseRepo.Save();
var courseResult = mapper.Map <CourseDto>(course);
return(CreatedAtRoute("GetCourseForAuthor", new { authorId = authorId, courseId = courseResult.Id }, courseResult));
}
public ActionResult <CourseDto> createCourseForAuthor(Guid authorId, CourseForCreationDto course)
{
if (!_courseLibaryService.AuthorExists(authorId))
{
return(NotFound());
}
var courseEntity = _mapper.Map <Course>(course);
_courseLibaryService.AddCourse(authorId, courseEntity);
_courseLibaryService.Save();
var courseToReturn = _mapper.Map <CourseDto>(courseEntity);
return(CreatedAtRoute("getCourseForAuthor", new { authorId, courseId = courseToReturn.Id }, courseToReturn));
}
public ActionResult <CourseGetDto> CreateCourseForAuthor(Guid authorId, CourseCreateDto course)
{
if (!_repo.AuthorExists(authorId))
{
return(NotFound());
}
var courseEntity = _mapper.Map <Entities.Course>(course);
_repo.AddCourse(authorId, courseEntity);
_repo.Save();
var courseToReturn = _mapper.Map <CourseGetDto>(courseEntity);
return(CreatedAtAction(nameof(GetCoursesForAuthor),
new { authorId = authorId, courseId = courseToReturn.Id },
courseToReturn));
}
public ActionResult <CourseDto> CreateCourseForAuthor([FromRoute] Guid authorId, [FromBody] CourseForCreationDto courseForCreation)
{
if (!_courseLibraryRepository.AuthorExists(authorId))
{
return(NotFound());
}
var course = _mapper.Map <Course>(courseForCreation);
_courseLibraryRepository.AddCourse(authorId, course);
_courseLibraryRepository.Save();
var result = _mapper.Map <CourseDto>(course);
return(CreatedAtRoute("GetAuthorCourse", new { authorId = authorId, courseId = course.Id }, result));
}
public ActionResult <CourseDTO> CreateCourse(Guid authorId, CourseForCreationDTO courseForCreationDTO)
{
if (!courseLibraryRepository.AuthorExists(authorId))
{
return(BadRequest());
}
var courseEntiy = _mapper.Map <Course>(courseForCreationDTO);
courseLibraryRepository.AddCourse(authorId, courseEntiy);
courseLibraryRepository.Save();
var courseToReturn = _mapper.Map <CourseDTO>(courseEntiy);
return(CreatedAtRoute("GetCourseForAuthor", new { authorId = authorId, courseId = courseToReturn.Id }, (courseToReturn)));
}
public async Task <IActionResult> CreateCourseForAuthor(Guid authorId, CourseCreationDto course)
{
if (!await _courseLibraryRepository.AuthorExistsAsync(authorId))
{
return(NotFound());
}
var courseEntity = _mapper.Map <Course>(course);
_courseLibraryRepository.AddCourse(authorId, courseEntity);
await _courseLibraryRepository.SaveAsync();
var courseToReturn = _mapper.Map <CourseDto>(courseEntity);
return(CreatedAtRoute("GetCourseForAuthor",
new { authorId, courseId = courseToReturn.Id },
courseToReturn));
}
public async Task <ActionResult <CourseForReturn> > CreateCourseForAuthor(Guid authorId, CourseForCreation course)
{
if (!await _repository.AuthorExists(authorId))
{
return(NotFound());
}
var courseForAdd = _mapper.Map <Course>(course);
_repository.AddCourse(authorId, courseForAdd);
if (!await _repository.Save())
{
return(BadRequest("Error Happens when saving in Data Base"));
}
var courseToReturn = _mapper.Map <CourseForReturn>(courseForAdd);
return(CreatedAtRoute("getCourse", new { authorId = authorId, courseId = courseForAdd.Id }, courseToReturn));
}
public IActionResult CreateCourseForAuthor([FromRoute] Guid authorId,
[FromBody] CourseForCreationDto course)
{
if (!_courseLibraryRepository.AuthorExists(authorId))
{
return(NotFound());
}
var courseEntity = _mapper.Map <Course>(course);
_courseLibraryRepository.AddCourse(authorId, courseEntity);
_courseLibraryRepository.Save();
var courseToReturn = _mapper.Map <CourseDto>(courseEntity);
return(CreatedAtRoute(nameof(GetCourseForAuthor),
new { authorId = authorId, courseId = courseToReturn.Id },
courseToReturn));
}
public ActionResult <CourseDto> CreateCourseForAuthor(
[FromRoute] Guid authorId,
[FromBody] CourseForCreationDto courseForCreationDto)
{
if (!AuthorExists(authorId))
{
return(NotFound());
}
var courseEntity = _mapper.Map <Course>(courseForCreationDto);
_courseLibraryRepository.AddCourse(authorId, courseEntity);
_courseLibraryRepository.Save();
var courseToReturn = _mapper.Map <CourseDto>(courseEntity);
return(CreatedAtRoute(
routeName: "GetCourseForAuthor",
routeValues: new { authorId = courseToReturn.AuthorId, courseId = courseToReturn.Id },
value: courseToReturn));
}
public CourseDto AddCourseForAuthor(Guid authorId, NewCourseDto course)
{
if (!_repo.AuthorExists(authorId))
{
return(null);
}
var courseEntity = _mapper.Map <Course>(course);
_repo.AddCourse(authorId, courseEntity);
_repo.Save();
return(_mapper.Map <CourseDto>(courseEntity));
}
public ActionResult <CourseDto> CreateCourseForAuthor(Guid authorId, CourseForCreationDto course)
{
if (!_courseLibraryRepository.AuthorExists(authorId))
{
return(NotFound());
}
// map source CourseForCreationDto to destination courseEntity
var courseEntity = _mapper.Map <Course>(course);
_courseLibraryRepository.AddCourse(authorId, courseEntity);
_courseLibraryRepository.Save();
// map source courseEntity to destination CourseDto
var courseToReturn = _mapper.Map <CourseDto>(courseEntity);
return(CreatedAtRoute("GetCourseForAuthor", new {
authorId,
courseId = courseToReturn.Id
}, courseToReturn));
}
public ActionResult <CourseForCreationDto> CreateCOurseForAuthor(Guid authorId, CourseForCreationDto course)
{
//Validate {authorId}
if (!_courseLibraryRepository.AuthorExists(authorId))
{
return(NotFound());
}
if (course == null)
{
return(BadRequest());
}
var courseEntity = _mapper.Map <Course>(course);
_courseLibraryRepository.AddCourse(authorId, courseEntity);
_courseLibraryRepository.Save();
var courseReturn = _mapper.Map <CourseDto>(courseEntity);
return(CreatedAtRoute("GetCourseFOrAuthor",
new { authorId = authorId, courseId = courseReturn.Id }, courseReturn));
}
public ActionResult <CourseDto> CreateCourseForAuthor(Guid authorId, CourseForCreationDto course)
{
if (!repository.AuthorExists(authorId))
{
return(NotFound());
}
var newCourse = mapper.Map <Course>(course);
repository.AddCourse(authorId, newCourse);
repository.Save();
var courseToReturn = mapper.Map <CourseDto>(newCourse);
return(CreatedAtRoute("GetCourseForAuthor", new { authorId = authorId, courseId = courseToReturn.Id }, courseToReturn));
}
public ActionResult PartiallyUpdateCourseForAuthor(Guid authorId, Guid courseId, JsonPatchDocument <CourseForUpdateDto> patchDocument)
{
if (!this.courseLibraryRepository.AuthorExists(authorId))
{
return(NotFound());
}
var courseForAuthorFromRepo = this.courseLibraryRepository.GetCourse(authorId, courseId);
if (courseForAuthorFromRepo == null)
{
var courseDto = new CourseForUpdateDto();
patchDocument.ApplyTo(courseDto, ModelState);
if (!TryValidateModel(courseDto))
{
return(ValidationProblem(ModelState));
}
var courseToAdd = this.mapper.Map <Entities.Course>(courseDto);
courseToAdd.Id = courseId;
courseLibraryRepository.AddCourse(authorId, courseToAdd);
courseLibraryRepository.Save();
var courseToReturn = mapper.Map <CourseDto>(courseToAdd);
return(CreatedAtRoute("GetCourseForAuthor", new { authorId, courseId = courseToReturn.Id }, courseToReturn));
}
var courseToPatch = this.mapper.Map <CourseForUpdateDto>(courseForAuthorFromRepo);
//add validation
patchDocument.ApplyTo(courseToPatch, ModelState);
if (!TryValidateModel(courseToPatch))
{
return(ValidationProblem(ModelState));
}
this.mapper.Map(courseToPatch, courseForAuthorFromRepo);
this.courseLibraryRepository.UpdateCourse(courseForAuthorFromRepo);
this.courseLibraryRepository.Save();
return(NoContent());
}
public IActionResult CreateCourseForAuthor([FromRoute] Guid authorId, CreateCourseDTO course)
{
if (!_courseLibrary.AuthorExists(authorId))
{
return(NotFound());
}
var courseToMap = _mapper.Map <Course>(course);
_courseLibrary.AddCourse(authorId, courseToMap);
_courseLibrary.Save();
var courseToReturn = _mapper.Map <CourseDTO>(courseToMap);
return(CreatedAtRoute("GetCourseForAuthor", new { authorId = authorId, courseId = courseToReturn.Id }
, courseToReturn));
}
public ActionResult <CourseDto> ADDNewCourse(Guid authorid, courseforCreation courseforCreation)
{
if (!_repo.AuthorExists(authorid))
{
return(NotFound());
}
var courseEntity = _map.Map <Course>(courseforCreation);
_repo.AddCourse(authorid, courseEntity);
_repo.Save();
var courseToReturn = _map.Map <CourseDto>(courseEntity);
return(CreatedAtRoute("GetCourse", new
{
AuthorId = authorid, courseId = courseToReturn.Id
}, courseToReturn));;
}