public async Task <ActionResult <ArticleDto> > PostArticle(ArticleCreateDto articleCreateDto) { if (articleCreateDto == null) { return(BadRequest()); } var article = new Article(); if (articleCreateDto.Picture == null) { articleCreateDto.Picture = new ImageCreateDto() { IsMain = true, ImageName = "placeholder.png", ImagePath = "img", AltText = "img", Caption = "" }; } _mapper.Map(articleCreateDto, article); _context.Articles.Add(article); await _context.SaveChangesAsync().ConfigureAwait(false); return(CreatedAtAction("GetArticle", new { id = article.Id }, _mapper.Map <ArticleDto>(article))); }
public ActionResult <ArticleReadDto> CreateArticle([FromBody] ArticleCreateDto articleCreateDto) { try { if (articleCreateDto == null) { return(BadRequest("Article is null")); } if (!ModelState.IsValid) { return(BadRequest("Invalid model object")); } var articleModel = _mapper.Map <Article>(articleCreateDto); _repository.CreateArticle(articleModel); _repository.SaveChanges(); var articleReadDto = _mapper.Map <ArticleReadDto>(articleModel); return(CreatedAtRoute(nameof(GetArticleById), new { Id = articleReadDto.Id }, articleReadDto)); } catch (Exception ex) { Console.WriteLine($"Logging {ex}"); return(StatusCode(500, "Internal server error")); } }
public ActionResult UpdateArticle(int id, ArticleUpdateDto articleUpdateDto) { var articleModelFromRepo = _repository.GetArticleById(id); var processedData = new ArticleCreateDto { Image = articleUpdateDto.Image, Content = WebUtility.HtmlEncode(articleUpdateDto.Content), Name = articleUpdateDto.Name, ContentIntro = articleUpdateDto.ContentIntro, AuthorImg = articleModelFromRepo.AuthorImg, AuthorName = articleModelFromRepo.AuthorName, DateofPublish = articleModelFromRepo.DateofPublish, AuthorId = articleModelFromRepo.AuthorId }; if (articleModelFromRepo == null) { return(NotFound()); } _mapper.Map(processedData, articleModelFromRepo); _repository.UpdateArticle(articleModelFromRepo); _repository.SaveChanges(); return(Ok(articleModelFromRepo)); }
public ActionResult CreateArticle(ArticleCreateDto articleCreateDto) { _repositoryArticle.CreateArticle(_mapper.Map <Article>(articleCreateDto)); _repositoryArticle.saveChange(); return(StatusCode(StatusCodes.Status200OK, new { status = "Success", message = "Article has been added" })); }
public ActionResult <ArticleReadDto> CreateArticle(ArticleCreateDto articleCreateDto) { var ArticleModel = _mapper.Map <Article>(articleCreateDto); _repository.CreateArticle(ArticleModel); _repository.SaveChanges(); var articleReadDto = _mapper.Map <ArticleReadDto>(ArticleModel); return(CreatedAtRoute(nameof(GetArticleById), new { Id = ArticleModel.Id }, articleReadDto)); }
public async Task <long> CreateArticle(ArticleCreateDto articleCreate) { var article = _mapper.Map <Article>(articleCreate); var user = await _userRepository.GetById(articleCreate.UserId, u => u.Writer); article.WriterId = user.Writer.Id; await _repository.Insert(article); return(article.Id); }
public async Task CheckArticle_ReturnsOk() { // Arrange var articleDto = new ArticleCreateDto { Content = "string" }; var body = GetBody(articleDto); // Act var result = await _client.PostAsync($"/articles/check", body); var articles = await result.GetDataAsync <List <ArticleDto> >(); // Assert Assert.AreEqual(HttpStatusCode.OK, result.StatusCode); Assert.That(articles, Is.Not.Null); }
public async Task <IActionResult> CreateArticle([FromBody] ArticleCreateDto article) { var userType = User.Claims.FirstOrDefault(x => x.Type.Equals("UserType", StringComparison.InvariantCultureIgnoreCase)).Value; var userRole = User.Claims.FirstOrDefault(x => x.Type.Equals("UserRole", StringComparison.InvariantCultureIgnoreCase)).Value; var userCompanyId = User.Claims.FirstOrDefault(x => x.Type.Equals("CompanyId", StringComparison.InvariantCultureIgnoreCase)).Value; var userName = User.Claims.FirstOrDefault(x => x.Type.Equals("UserName", StringComparison.InvariantCultureIgnoreCase)).Value; if (article != null) { if (userType == "HelpDesk" && userRole == "Manager") { var _article = _mapper.Map <ArticleModel>(article); var user = await _repository.User.GetUserByUserName(userName); if (user != null) { _article.CreatedBy = user.UserName; _article.ArticleId = (Guid.NewGuid()).ToString(); _article.CreatedDate = DateTime.Now; } _repository.Article.Create(_article); await _repository.Save(); var insertArticle = await _repository.Article.GetArticleById(_article.ArticleId); return(Ok(_mapper.Map <ArticleDto>(insertArticle))); } else { return(StatusCode(401, "Unauthorized Access")); } } else { return(StatusCode(400, "Bad Request")); } }
public async Task <ArticleDto> AddAsync(ArticleCreateDto dto) { if (string.IsNullOrEmpty(dto.Title)) { throw new ArticleException(ArticleErrorCodes.ArticleTitleCannotBeNull, "Article Title field is mandatory.", dto); } if (string.IsNullOrEmpty(dto.Body)) { throw new ArticleException(ArticleErrorCodes.ArticleBodyCannotBeNull, "Article Body field is mandatory.", dto); } if (dto.CategoryId == Guid.Empty) { throw new ArticleException(ArticleErrorCodes.ArticleCategoryCannotBeNull, "Article Category Id field is mandatory.", dto); } else { var categoryEntity = await _categoryRepository.GetByIdAsync(dto.CategoryId); if (categoryEntity == null || categoryEntity.Id == Guid.Empty) { throw new ArticleException(ArticleErrorCodes.CategoryCouldNotBeFound, "Article Category Id could not be found..", dto); } } var entity = dto.Adapt <Domain.Article>(); entity = await _articleRepository.AddAsync(entity); if (dto.TagIds != null && dto.TagIds.Any()) { if (!await _tagRepository.CheckAllTagIdsExist(dto.TagIds)) { throw new ArticleException(ArticleErrorCodes.TagCouldNotBeFound, "Article cannot contain non-existed tagId", dto); } entity = await _articleRepository.AddTags(entity, dto.TagIds); } return(entity.Adapt <ArticleDto>()); }
public async Task <IActionResult> Post(ArticleCreateDto model) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } var article = mapper.Map <Article>(model); article.CreatedDate = DateTime.Now; article.UpdatedDate = DateTime.Now; await articleRepository.Add(article); if (await articleRepository.SaveChanges()) { return(Ok(article)); } return(StatusCode(304)); }
public async Task CreateArticle_ReturnsOk() { // Arrange var articleDto = new ArticleCreateDto { Content = "content" }; var body = GetBody(articleDto); // Act var result = await _client.PostAsync("/articles", body); var article = await result.GetDataAsync <ArticleDto>(); // Assert Assert.AreEqual(HttpStatusCode.OK, result.StatusCode); Assert.That(article.Id, Is.Not.Null); ArticleId = article.Id; }
public async Task <IActionResult> CreateArticleAsync( [FromBody] ArticleCreateDto newsArticleCreateDTO) { if (newsArticleCreateDTO == null) { return(BadRequest()); } if (!ModelState.IsValid) { return(BadRequest()); } var article = _mapper.Map <Article>(newsArticleCreateDTO); article.Author = _mapper.Map <Author>(User); var newsArticle = await _repository.Add(article); return(Ok(_mapper.Map <ArticleDto>(newsArticle))); }
public async Task <ArticleDto> CreateAsync(ArticleCreateDto articleCreateDto) { var articleToCreate = new Article { Content = articleCreateDto.Content, Tokens = _articleSimilarityService.Tokenize(articleCreateDto.Content) }; var article = await _bus.Send(new CreateArticleCommand(articleToCreate)); await _bus.Publish(new ArticleCreatedEvent(article)); return(new ArticleDto { Id = article.Id, Content = article.Content, CreatedTs = article.CreatedTs, UpdatedTs = article.UpdatedTs, DuplicateIds = await _articleSimilarityService.FindDuplicatesAsync(article) }); }
public ActionResult <ArticleReadDto> CreateArticle(ArticleCreateDto articleCreateDto) { var convertedData = new ArticleCreateDto { AuthorImg = articleCreateDto.AuthorImg, Content = WebUtility.HtmlEncode(articleCreateDto.Content), AuthorName = articleCreateDto.AuthorName, Image = articleCreateDto.Image, DateofPublish = DateTime.Now.ToString("dd/MM/yy"), Name = articleCreateDto.Name, ContentIntro = articleCreateDto.ContentIntro, AuthorId = articleCreateDto.AuthorId }; var articleModel = _mapper.Map <Article>(convertedData); _repository.CreateArticle(articleModel); _repository.SaveChanges(); var articleReadDto = _mapper.Map <ArticleReadDto>(articleModel); return(CreatedAtRoute(nameof(GetArticleById), new { Id = articleReadDto.Id }, articleReadDto)); }
public ArticleDto Add(ArticleCreateDto dto) { Article article = _articleDomainService.Create(Mapper.Map <Article>(dto)); return(Mapper.Map <ArticleDto>(article)); }
public Task <ArticleDto> Create([FromBody] ArticleCreateDto articleCreateDto) { return(_articleService.CreateAsync(articleCreateDto)); }
public async Task <IActionResult> CreateArticle([FromBody] ArticleCreateDto createArticle) { var id = await _articleService.CreateArticle(createArticle); return(Created($"api/articles/{id}", id)); }
public async Task <IActionResult> Create(ArticleCreateDto articleDto) { return(ActionResultInstance(await _articleService.AddAsync(ObjectMapper.Mapper.Map <ArticleDto>(articleDto)))); }
public ArticleDto Add([FromBody] ArticleCreateDto dto) { return(_articleAppService.Add(dto)); }
public ActionResult <ArticleDto> Post([FromBody] ArticleCreateDto dto) { var article = _app.Add(dto); return(CreatedAtAction(nameof(Get), new { id = article.Id }, article)); }
public async Task <IActionResult> CreateArticle([FromBody] ArticleCreateDto model) { var result = await _articleService.AddAsync(model); return(CreatedAtAction(nameof(GetArticleById), new { id = result.Id }, null)); }
public Task <List <ArticleDto> > Check([FromBody] ArticleCreateDto body) { return(_articleService.CheckDuplicatesAsync(body.Content)); }