public ActionResult <Course> Post([FromBody] CourseCreateDto courseCreateDto)
{
if (courseCreateDto == null)
{
return(BadRequest());
}
this.HttpContext.Items.TryGetValue("UserId", out var userId);
courseCreateDto.CreatedBy = Guid.Parse(userId.ToString());
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (_readCourseRepository.GetByName(courseCreateDto.Name) != null)
{
return(BadRequest("Name of Course already exists."));
}
Course course = _mapper.DtoToEntity(courseCreateDto);
_writeCourseRepository.Create(course);
_writeCourseRepository.SaveChanges();
return(CreatedAtRoute("GetByCourseId", new { id = course.Id }, course));
}
public async Task <ActionResult <CourseDto> > CreateCourseForAuthor(Guid authorId,
[FromBody] CourseCreateDto course)
{
if (!await _authorRepository.AuthorExistsAsync(authorId))
{
return(NotFound());
}
try
{
var courseEntity = _mapper.Map <Course>(course);
await _courseRepository.AddCourseAsync(authorId, courseEntity);
var courseToReturn = _mapper.Map <CourseDto>(courseEntity);
// Return - successful post - 201 - CreatedAtRoute() - 201 SC and a location header with
// URI for newly created Course
return(CreatedAtRoute("GetCourseForAuthor",
new { authorId = authorId, courseId = courseEntity.Id },
courseToReturn));
}
catch (Exception e)
{
return(BadRequest());
}
}
public async Task <DataResult <CourseDto> > CreateAsync(CourseCreateDto categoryDto)
{
var course = _mapper.Map <Course>(categoryDto);
await _courseCollection.InsertOneAsync(course);
return(DataResult <CourseDto> .Success(_mapper.Map <CourseDto>(course), StatusCode.Ok));
}
public async Task <Response <CourseDto> > CreateAsync(CourseCreateDto courseCreateDto)
{
var newCourse = _mapper.Map <Course>(courseCreateDto);
newCourse.CreatedTime = DateTime.Now;
await _courseCollection.InsertOneAsync(newCourse);
return(Response <CourseDto> .Success(_mapper.Map <CourseDto>(newCourse), 200));
}
public async Task <Response <CourseDto> > CreateAsync(CourseCreateDto courseCreateDto)
{
var course = _mapper.Map <Course>(courseCreateDto);
course.CreatedTime = DateTime.Now;
await courseCollection.InsertOneAsync(course);
var dto = _mapper.Map <CourseDto>(course);
return(Response <CourseDto> .Success(dto, StatusCodes.Status201Created));
}
public ActionResult <CourseReadDto> CreateCourse(CourseCreateDto courseCreateDto)
{
var courseModel = _mapper.Map <Course>(courseCreateDto);
_repository.CreateCourse(courseModel);
_repository.SaveChanges();
var courseReadDto = _mapper.Map <CourseReadDto>(courseModel);
return(CreatedAtRoute(nameof(GetCourseById), new { CourseID = courseReadDto.CourseId }, courseReadDto));
}
public async Task <OkResponse <CourseDto> > CreateAsync(CourseCreateDto dto)
{
if (dto == null || string.IsNullOrEmpty(dto.Name))
{
return(OkResponse <CourseDto> .Error(HttpStatusCode.BadRequest, "Model is not valid!"));
}
var newCourse = _mapper.Map <Course>(dto);
newCourse.CreatedTime = DateTime.Now;
await _courseCollection.InsertOneAsync(newCourse);
var mapDto = _mapper.Map <CourseDto>(newCourse);
return(OkResponse <CourseDto> .Success(HttpStatusCode.OK, mapDto));
}
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 async Task <IActionResult> Create(CourseCreateDto courseCreateDto)
{
var response = await _courseService.CreateAsync(courseCreateDto);
return(CreateActionResultInstance(response));
}
public async Task <IActionResult> Create(CourseCreateDto input)
{
var response = await _courseService.CreateAsync(input);
return(CreateActionResult(response));
}
public async Task <IActionResult> Create([FromBody] CourseCreateDto dto)
{
var response = await _courseService.CreateAsync(dto);
return(OkActionResult(response));
}
