public async Task CreateArticle_WithSucceedingCommit_ReturnsStatusCodeNoContent() { var articleForCreationDto = new ArticleForCreationDto() { Code = "New Test Article", Name1 = "1st article Updated", SupplierId = "supId", SupplierReference = "supRef", PurchasePrice = 99.99M, Unit = "ST" }; var newArticle = _writeMapper.Map <Article>(articleForCreationDto); var articleForReturnDto = _writeMapper.Map <ArticleForReturnDto>(newArticle); _createCommandMock.Setup(m => m.Execute(It.IsAny <ArticleForCreationDto>())).Returns(Task.FromResult(articleForReturnDto)); // act var result = await _articlesController.CreateArticle(articleForCreationDto); // assert _createCommandMock.Verify(m => m.Execute(It.IsAny <ArticleForCreationDto>()), Times.Once); Assert.That(result, Is.Not.Null); Assert.That(result.GetType(), Is.EqualTo(typeof(CreatedAtRouteResult))); Assert.That(((CreatedAtRouteResult)result).StatusCode, Is.EqualTo(201)); Assert.That(((CreatedAtRouteResult)result).RouteName, Is.EqualTo("GetArticle")); Assert.That(((CreatedAtRouteResult)result).RouteValues.First(), Is.EqualTo(new KeyValuePair <string, int>("id", articleForReturnDto.Id))); Assert.That(((CreatedAtRouteResult)result).Value, Is.EqualTo(articleForReturnDto)); }
public async Task CreateArticle_WithFailingCommit_ReturnsStatusBadRequest() { var articleForCreationDto = new ArticleForCreationDto() { Code = "New Test Article", Name1 = "1st article Updated", SupplierId = "supId", SupplierReference = "supRef", PurchasePrice = 99.99M, Unit = "ST" }; var newArticle = _writeMapper.Map <Article>(articleForCreationDto); var articleForReturnDto = _writeMapper.Map <ArticleForReturnDto>(newArticle); _createCommandMock.Setup(m => m.Execute(It.IsAny <ArticleForCreationDto>())).Returns(Task.FromResult <ArticleForReturnDto>(null)); // act var result = await _articlesController.CreateArticle(articleForCreationDto); // assert _createCommandMock.Verify(m => m.Execute(It.IsAny <ArticleForCreationDto>()), Times.Once); Assert.That(result, Is.Not.Null); Assert.That(result.GetType(), Is.EqualTo(typeof(BadRequestObjectResult))); Assert.That(((BadRequestObjectResult)result).StatusCode, Is.EqualTo(400)); Assert.That(((BadRequestObjectResult)result).Value, Is.EqualTo("Failed to create article")); }
public async Task Execute(ArticleForCreationDto articleForCreation) { // TODO mapping via DI !! // var newArticle = _mapper.Map<Article>(newArticleDto); var newArticle = Domain.Model.Entities.Articles.Article.Create( articleForCreation.Code, articleForCreation.SupplierId, articleForCreation.SupplierReference, articleForCreation.Name1, articleForCreation.PurchasePrice, articleForCreation.Unit ); _unitOfWork.ArticleRepository.Add(newArticle); await _unitOfWork.Commit(); // TODO: handle errors //if (await _unitOfWork.Commit()) //{ // var articleToReturn = _mapper.Map<ArticleForReturnDto>(newArticle); // return CreatedAtRoute("GetArticle", new { id = newArticle.Id }, articleToReturn); //} //return BadRequest("Failed to create article"); // evt. notifications }
public IResult InsertArticle(ArticleForCreationDto articleForCreationDto) { //TO DO: Implement transaction var articleToBeInserted = _mapper.Map <ArticleTranslation>(articleForCreationDto); var insertedArticle = _articleTranslationRepository.Insert(articleToBeInserted); articleForCreationDto.Pictures.ForEach(p => p.ArticleId = insertedArticle.ArticleId); var result = _pictureService.InsertPicturesForArticle(articleForCreationDto.Pictures); if (result.Success) { var imgRegex = new Regex("<img src=\"(?<url>(data:(?<type>.+?);base64),(?<data>[^\"]+))\""); foreach (var picture in result.Data.Where(x => !x.IsMain)) { insertedArticle.ContentMain = imgRegex.Replace(insertedArticle.ContentMain, m => $"<img src=\"{picture.Url}\"", 1); } _articleTranslationRepository.Update(insertedArticle); return(new SuccessResult(string.Format(Messages.SuccessfulInsert, nameof(Article)))); } else { return(new ErrorResult($"Picture couldn't be inserted Error Message {result.Message}")); } }
public IActionResult CreateArticleForProduct(Guid productId, [FromBody] ArticleForCreationDto article) { if (article == null) { return(BadRequest()); } if (!_libraryRepository.ProductExists(productId)) { return(NotFound()); } var articleEntity = Mapper.Map <Article>(article); _libraryRepository.AddArticleForProduct(productId, articleEntity); if (!_libraryRepository.Save()) { throw new Exception("Creating an article failed on save."); //return StatusCode(500, "An unexpected fault happened. Try again later."); } var articleToReturn = Mapper.Map <ArticleDto>(articleEntity); return(CreatedAtRoute("GetArticleForProduct", new { productId = productId, id = articleToReturn.Id }, articleToReturn)); }
public async Task Create_ValidObject_ReturnsNewArticle() { //Arrange var unitOfWork = new UnitOfWork(TestContext, new ArticleRepository(TestContext), null); var articleForCreation = new ArticleForCreationDto() { Code = "new code", Name1 = "new name", SupplierId = "sup id", SupplierReference = "sup ref", PurchasePrice = 99.99M, Unit = "ST", PhotoUrl = "www.retail4u.be/newarticle.jpg" }; var createArticleCommand = new CreateArticleCommand(unitOfWork, _writeMapper); var articleCountBefore = TestContext.Articles.Count(); //Act var result = await createArticleCommand.Execute(articleForCreation); //Assert Assert.That(result, Is.Not.Null); Assert.That(result.GetType(), Is.EqualTo(typeof(ArticleForReturnDto))); Assert.That(TestContext.Articles.Count, Is.EqualTo(articleCountBefore + 1)); Assert.That(result.Id, Is.Not.Null); Assert.That(result.Name1, Is.EqualTo(articleForCreation.Name1)); Assert.That(result.Photos, Is.Not.Null); Assert.That(result.Photos.First(), Is.Not.Null); Assert.That(result.Photos.First().Url, Is.EqualTo("www.retail4u.be/newarticle.jpg")); }
public async Task Create_InvalidObject_ReturnsNull() { //Arrange var testArticles = ArticleList.GetDefaultList(); var articleDbSetMock = testArticles.AsQueryable().BuildMockDbSet(); var dataContextMock = new Mock <CommandDbContext>(); dataContextMock.Setup(m => m.Articles).Returns(articleDbSetMock.Object); var articleRepository = new Mock <IArticleRepository>(); var unitOfWorkMock = new Mock <IUnitOfWork>(); unitOfWorkMock.Setup(uow => uow.ArticleRepository).Returns(articleRepository.Object); var articleForCreation = new ArticleForCreationDto(); var createArticleCommand = new CreateArticleCommand(unitOfWorkMock.Object, _writeMapper); unitOfWorkMock.Setup(uow => uow.Commit()).Returns(Task.FromResult(false)); //Act var result = await createArticleCommand.Execute(articleForCreation); //Assert articleRepository.Verify(r => r.Add(It.IsAny <Article>()), Times.Once); Assert.That(result, Is.Null); }
public async Task <IActionResult> CreateArticle(ArticleForCreationDto articleForCreationDto) { var createdArticle = await _createCommand.Execute(articleForCreationDto); if (createdArticle != null) { return(CreatedAtRoute("GetArticle", new { id = createdArticle.Id }, createdArticle)); } return(BadRequest("Failed to create article")); }
public IActionResult CreateArticle([FromBody] ArticleForCreationDto articleForCreationDto) { var articleModel = _mapper.Map <Article>(articleForCreationDto); _articleRepository.AddArticle(articleModel); _articleRepository.Save(); var articleReturn = _mapper.Map <ArticleDto>(articleModel); return(CreatedAtRoute( "GetArticle", new { articleId = articleReturn.Id }, articleReturn )); }
public async Task <IActionResult> CreateArticle(ArticleForCreationDto articleForCreationDto) { await _createCommand.Execute(articleForCreationDto); return(Ok()); // TODO: handle errors & return correct status //if (await _unitOfWork.Commit()) //{ // var articleToReturn = _mapper.Map<ArticleForReturnDto>(newArticle); // return CreatedAtRoute("GetArticle", new { id = newArticle.Id }, articleToReturn); //} //return BadRequest("Failed to create article"); }
public async Task PublishArticle_Success() { var articleDto = new ArticleForCreationDto() { Title = "test" }; var article = _mapper.Map <Article>(articleDto); _articleRepositoryMock.Setup(x => x.AddAsync(article)); _tagsMock.Setup(x => x.TryCreateManyToMany(It.IsAny <IEnumerable <ArticleTag> >())); _tagsMock.Setup(x => x.SaveAsync()); await _service.PublishArticle(articleDto); _tagsMock.Verify(x => x.TryCreateManyToMany(It.IsAny <IEnumerable <ArticleTag> >()), Times.Once()); _tagsMock.Verify(x => x.SaveAsync(), Times.Once()); }
public async Task <ActionResult> Create(ArticleForCreationDto article) { try { if (article == null) { return(BadRequest()); } await _articleService.PublishArticle(article); return(NoContent()); } catch (Exception ex) { return(BadRequest(ex.Message)); } }
public async Task PublishArticle(ArticleForCreationDto articleRequest) { try { var article = _mapper.Map <Article>(articleRequest); await _articleRepository.AddAsync(article); _tags.TryCreateManyToMany(articleRequest.Tags.Select(x => new ArticleTag { TagId = x.Id, ArticleId = article.Id })); await _tags.SaveAsync(); } catch (Exception ex) { throw new InvalidOperationException(ex.Message); } }
public async Task <ArticleForReturnDto> Execute(ArticleForCreationDto articleForCreation) { var newArticle = _mapper.Map <Article>(articleForCreation); if (!string.IsNullOrEmpty(articleForCreation.PhotoUrl)) { newArticle.Photos.Add(ArticlePhoto.Create(articleForCreation.PhotoUrl, true)); } _unitOfWork.ArticleRepository.Add(newArticle); if (await _unitOfWork.Commit()) { var articleForReturnDto = _mapper.Map <ArticleForReturnDto>(newArticle); return(articleForReturnDto); } return(null); }
public ActionResult <ArticleDto> CreateArticleForUser(Guid userId, ArticleForCreationDto article, Guid tagId) { if (!_articleLibraryRepository.UserExists(userId) || !_tagLibraryRepository.TagExists(tagId)) { return(NotFound()); } var articleEntity = _mapper.Map <Entities.Article>(article); _articleLibraryRepository.AddArticle(userId, articleEntity, tagId); _articleLibraryRepository.Save(); var articleToReturn = _mapper.Map <ArticleDto>(articleEntity); return(CreatedAtRoute("GetArticleForUser", new { userId = userId, articleId = articleToReturn.Id }, articleToReturn)); }
public IActionResult CreateArticleForAuthor(Guid authorId, [FromBody] ArticleForCreationDto article) { if (article == null) { return(BadRequest()); } if (article.Description == article.Title) { ModelState.AddModelError(nameof(ArticleForCreationDto), "The provided description should be different from the title."); } if (!ModelState.IsValid) { // return 422 return(new UnprocessableEntityObjectResult(ModelState)); } if (!_libraryRepository.AuthorExists(authorId)) { return(NotFound()); } var articleEntity = Mapper.Map <Article>(article); _libraryRepository.AddArticleForAuthor(authorId, articleEntity); if (!_libraryRepository.Save()) { throw new Exception($"Creating a article for author {authorId} failed on save."); } var articleToReturn = Mapper.Map <ArticleDto>(articleEntity); return(CreatedAtRoute("GetArticleForAuthor", new { authorId = authorId, id = articleToReturn.Id }, articleToReturn)); }