/// <summary> /// /// </summary> /// <param name="request"></param> /// <returns></returns> public UpdateArticleResponse UpdateArticle(UpdateArticleRequest request) { using (var client = DbFactory.CreateClient()) { var article = client.Queryable <Article>().InSingle(request.Id); if (article == null) { throw new AlertException("找不到该条信息"); } article.CategoryId = request.CategoryId; article.Title = request.Title; article.SubTitle = request.SubTitle; article.TitleColor = request.TitleColor; article.TitleBold = request.TitleBold; article.Summary = request.Summary; article.Content = request.Content; article.Tags = request.Tags; article.ThumbImage = request.ThumbImage; article.Video = request.Video; article.Source = request.Source; article.Author = request.Author; article.Hits = request.Hits; article.Addtime = request.Addtime; article.OrderIndex = request.OrderIndex; article.IsTop = request.IsTop; article.IsRecommend = request.IsRecommend; article.SeoTitle = request.SeoTitle; article.SeoKeyword = request.SeoKeyword; article.SeoDescription = request.SeoDescription; article.String1 = request.String1; article.String2 = request.String2; article.String3 = request.String3; article.String4 = request.String4; article.Int1 = request.Int1; article.Int2 = request.Int2; article.Int3 = request.Int3; article.Int4 = request.Int4; article.Decimal1 = request.Decimal1; article.Decimal2 = request.Decimal2; article.Decimal3 = request.Decimal3; article.Decimal4 = request.Decimal4; article.Datetime1 = request.Datetime1; article.Datetime2 = request.Datetime2; article.Datetime3 = request.Datetime3; article.Datetime4 = request.Datetime4; article.Bool1 = request.Bool1; article.Bool2 = request.Bool2; article.Bool3 = request.Bool3; article.Bool4 = request.Bool4; article.Text1 = request.Text1; article.Text2 = request.Text2; article.Text3 = request.Text3; article.Text4 = request.Text4; client.Updateable(article).ExecuteCommand(); _eventPublisher.EntityUpdated(article); return(new UpdateArticleResponse()); } }
public async Task <IActionResult> UpdateArticle(int articleId, UpdateArticleRequest updatedArticle) { if (!ModelState.IsValid) { return(BadRequest()); } try { var article = await articleService.UpdateArticleAsync(articleId, updatedArticle); if (article == null) { return(NotFound()); } return(NoContent()); } catch (ResourceHasConflictException ex) { return(Conflict(ex.Message)); } catch (ResourceNotFoundException ex) { return(NotFound(ex.Message)); } }
public void SetUp() { createRequest = new CreateArticleRequest() { Title = "title", Content = "content", Category = ArticleCategoryType.News, Image = It.IsAny <IFormFile>() }; updateRequest = new UpdateArticleRequest() { ArticleId = It.IsAny <string>(), Title = "title", Content = "content", Category = ArticleCategoryType.News, Image = It.IsAny <IFormFile>(), IsImageDeleted = false }; database = new Mock <IDatabase>(); filesManager = new Mock <IFilesManager>(); mapper = new Mock <IMapper>(); articleService = new ArticleService(database.Object, filesManager.Object, mapper.Object); }
public async Task <IActionResult> UpdateArticle([FromForm] UpdateArticleRequest request) { var response = await mediator.Send(request); Log.Information($"User #{HttpContext.GetCurrentUserId()} updated article #{request.ArticleId}"); return(this.CreateResponse(response)); }
public IHttpActionResult CreateArticle(UpdateArticleRequest request) { var command = _mapper.Map <UpdateArticleCommand>(request); _commandBus.Send(command); return(Ok()); }
public async Task <IActionResult> UpdateArticle([FromBody] UpdateArticleRequest request) { var res = await _articleBusiness.UpdateAsync(request); if (res.IsSuccess) { return(Ok()); } return(BadRequest(res.ResultInfo)); }
public async Task <IActionResult> UpdateArticle(string id, [FromBody] UpdateArticleRequest updateRequest) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } await _service.UpdateArticle(id, updateRequest); return(NoContent()); }
public async Task <UpdateArticleResponse> Update(UpdateArticleRequest request) { request.ValidateAndThrow(); var result = await _articlesService.Update(request); return(new UpdateArticleResponse { Article = result }); }
public async Task <IActionResult> CreateArticle([FromBody] UpdateArticleRequest createRequest) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } var category = await _service.CreateArticle(createRequest); var location = string.Format("/api/articles/{0}", category.Id); return(Created(location, category)); }
public async Task UpdateArticleAsyncTest() { // Create an article var now = DateTime.Now; dynamic obj = new Article("object"); obj.intfield = 1; obj.decimalfield = 10.0m; obj.datefield = "2012-12-20"; obj.stringfield = "initial"; obj.Tags.Add("initial"); var createdResponse = await(new CreateArticleRequest() { Article = obj }).ExecuteAsync(); Assert.IsNotNull(createdResponse, "Article creation failed."); Assert.IsNotNull(createdResponse.Status, "Status is null."); Assert.IsTrue(createdResponse.Status.IsSuccessful, createdResponse.Status.Message ?? "Create article failed."); var created = createdResponse.Article; // Update the article var updateRequest = new UpdateArticleRequest() { Id = created.Id, Type = created.Type }; updateRequest.PropertyUpdates["intfield"] = "2"; updateRequest.PropertyUpdates["decimalfield"] = 20.0m.ToString(); updateRequest.PropertyUpdates["stringfield"] = null; updateRequest.PropertyUpdates["datefield"] = "2013-11-20"; updateRequest.AddedTags.AddRange(new[] { "tag1", "tag2" }); updateRequest.RemovedTags.AddRange(new[] { "initial" }); var updatedResponse = await updateRequest.ExecuteAsync(); Assert.IsNotNull(updatedResponse, "Update article response is null."); Assert.IsNotNull(updatedResponse.Status, "Update article response status is null."); Assert.IsNotNull(updatedResponse.Article, "Updated article is null."); var updated = updatedResponse.Article; Assert.IsTrue(updated.Get <string>("intfield") == "2"); Assert.IsTrue(updated.Get <string>("decimalfield") == "20.0"); Assert.IsTrue(updated.Get <string>("stringfield") == null); Assert.IsTrue(updated.Get <string>("datefield") == "2013-11-20"); Assert.IsTrue(updated.Tags.Count() == 2); Assert.IsTrue(updated.Tags.Intersect(new[] { "tag1", "tag2" }).Count() == 2); }
public async Task <IActionResult> Put([FromRoute] string slug, [FromBody] UpdateArticleRequest updateArticleRequest) { try { var tokenHeader = Request.Headers["Authorization"]; var token = tokenHeader.Count > 0 ? tokenHeader.First().Split(' ')[1] : null; User currentUser = null; if (!string.IsNullOrWhiteSpace(token)) { currentUser = UserService.GetCurrentUser(token); } if (currentUser == null) { return(Unauthorized()); } var article = await ArticleService.UpdateArticle(updateArticleRequest.Article, slug, token); return(article != null ? Ok(new SingleArticleResponse { Article = new ArticleModel( article.Slug, article.Title, article.Description, article.Body, article.ArticleTags.Select(t => t.Tag.TagName).ToList(), article.CreatedAt, article.UpdatedAt, article.GetFavorited(currentUser), article.FavoritesCount, article.Author.Profile ) }) : (IActionResult)BadRequest("Not updated.")); } catch (ApplicationException ae) when(ae.Message == "Not found.") { return(NotFound()); } catch (Exception ex) { var genericErrorModel = new GenericErrorModel(new GenericErrorModelErrors(new[] { ex.ToString() })); return(BadRequest(genericErrorModel)); } }
public void Put_Article_Should_Update_Article(DataFormat dataFormat) { var createArticleRequest = new CreateArticleRequest() { Title = GetUniqueStringValue("title_"), Body = GetUniqueStringValue("body_"), IsPublished = false, PublishDate = null, Author = "God", }; CreateArticle(createArticleRequest, dataFormat, out HttpResponseMessage createHttpResponseMessage, out string createResponseString, out ArticleResponse createArticleResponse); Assert.AreEqual(HttpStatusCode.Created, createHttpResponseMessage.StatusCode); Assert.AreEqual(createArticleRequest.Title, createArticleResponse.Title); Assert.AreEqual(createArticleRequest.Body, createArticleResponse.Body); Assert.AreEqual(createArticleRequest.Author, createArticleResponse.Author); Assert.IsTrue(createArticleResponse.Id > 1); var updateArticleRequest = new UpdateArticleRequest() { Author = GetUniqueStringValue(createArticleRequest.Author), Body = GetUniqueStringValue(createArticleRequest.Body), IsPublished = createArticleRequest.IsPublished, PublishDate = createArticleRequest.PublishDate, Title = GetUniqueStringValue(createArticleRequest.Title) }; UpdateArticle(createArticleResponse.Id, updateArticleRequest, dataFormat, out HttpResponseMessage updateHttpResponseMessage, out string updateResponseString); Assert.AreEqual(HttpStatusCode.NoContent, updateHttpResponseMessage.StatusCode); GetArticle(createArticleResponse.Id, out HttpResponseMessage getHttpResponseMessage, out string getResponseString, out ArticleResponse getArticleResponse); getHttpResponseMessage.EnsureSuccessStatusCode(); Assert.AreEqual(HttpStatusCode.OK, getHttpResponseMessage.StatusCode); Assert.AreEqual(updateArticleRequest.Title, getArticleResponse.Title); Assert.AreEqual(updateArticleRequest.Body, getArticleResponse.Body); Assert.AreEqual(updateArticleRequest.Author, getArticleResponse.Author); Assert.AreEqual(updateArticleRequest.IsPublished, getArticleResponse.IsPublished); Assert.AreEqual(updateArticleRequest.PublishDate, getArticleResponse.PublishDate); }
public void UpdateArticle_DeletingImageFailed_ThrowDatabaseException() { updateRequest = updateRequest with { IsImageDeleted = true, Image = It.IsNotNull <IFormFile>() }; var article = SetUpUpdateArticleWhenImageIsDeleted(); database.Setup(d => d.ArticleImageRepository.DeleteByColumn(new(ArticleId, article.Id))) .ReturnsAsync(false); Assert.That(() => articleService.UpdateArticle(updateRequest), Throws.Exception.TypeOf <DatabaseException>()); }
public async Task <IActionResult> Update(string id, [FromBody] UpdateArticleRequest updateArticleIn) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } var userId = HttpContext.User.Claims.First().Value; updateArticleIn.UserId = userId; await _articleService.UpdateArticleAsync(id, updateArticleIn); return(NoContent()); }
public async Task UpdateArticle_ImageIsDeleted_DeleteImageShouldBeCalled() { updateRequest = updateRequest with { IsImageDeleted = true, Image = It.IsNotNull <IFormFile>() }; var article = SetUpUpdateArticleWhenImageIsDeleted(); database.Setup(d => d.ArticleImageRepository.DeleteByColumn(new(ArticleId, article.Id))).ReturnsAsync(true); await articleService.UpdateArticle(updateRequest); database.Verify(d => d.ArticleImageRepository.DeleteByColumn(new(ArticleId, article.Id))); filesManager.Verify(fm => fm.DeleteDirectory(It.IsAny <string>(), true)); }
public async Task UpdateArticle_ImageIsDeleted_ReturnArticle() { updateRequest = updateRequest with { IsImageDeleted = true, Image = It.IsNotNull <IFormFile>() }; var article = SetUpUpdateArticleWhenImageIsDeleted(); database.Setup(d => d.ArticleImageRepository.DeleteByColumn(new(ArticleId, article.Id))).ReturnsAsync(true); var result = await articleService.UpdateArticle(updateRequest); Assert.That(result, Is.Not.Null); Assert.That(result, Is.TypeOf <Article>()); Assert.That(result.Id, Is.EqualTo(article.Id)); }
public async Task <IActionResult> Create([FromBody] UpdateArticleRequest updateArticleIn) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } var userId = HttpContext.User.Claims.First().Value; updateArticleIn.UserId = userId; var article = await _articleService.AddArticleAsync(updateArticleIn); var location = $"api/[controller]/{article.Id}"; return(Created(location, article)); }
/// <summary> /// 更新文章 /// </summary> /// <param name="request">文章信息</param> /// <returns></returns> public async Task <ResultModel <string> > UpdateAsync(UpdateArticleRequest request) { var response = new ResultModel <string>(); var article = new ArticleInfo() { Abstract = request.Abstract, Title = request.Title, Id = request.Id.ObjToInt(), Likes = request.Likes, Views = request.Views, Comments = request.Comments, IsPublished = request.IsPublished, ImageUrl = request.ImageUrl, ModifyTime = DateTime.Now }; var content = new ArticleContent() { Content = request.Content, ArticleId = article.Id, ModifyTime = DateTime.Now }; var result = await _articleRepository.UseTranAsync(async() => { await _articleRepository.UpdateAsync(article); await _articleContentRepository.UpdateAsync(content, it => it.ArticleId); ////先删除再添加 await _articleTagRepository.DeleteAsync(x => x.ArticleId == article.Id); await _articleCategoryRepository.DeleteAsync(x => x.ArticleId == article.Id); var articleTags = request.TagIds.Select(tagId => new ArticleTag() { TagId = tagId.ObjToInt(), ArticleId = article.Id, }).ToList(); await _articleTagRepository.InsertAsync(articleTags); var articleCategories = request.CategoryIds.Select(categoryId => new ArticleCategory() { ArticleId = article.Id, CategoryId = categoryId.ObjToInt() }).ToList(); await _articleCategoryRepository.InsertAsync(articleCategories); }); response.IsSuccess = result.IsSuccess; response.ResultInfo = result.ErrorMessage; return(response); }
public async Task <ResponseArticle> UpdateArticle(string id, UpdateArticleRequest updateRequest) { if (updateRequest.UserId is null) { throw new ArgumentException("No user"); } var dbArticles = await _context.Articles.Find(p => p.Title == updateRequest.Title && p.Id != id).ToListAsync(); if (dbArticles.Count > 0) { throw new RequestedResourceHasConflictException("address"); } //!!!!!!!!!!!!!!!!!! // look here if smth wrong var dbCategory = await _categoryContext.Categories.Find(c => c.CategoryName == updateRequest.CategoryName).FirstOrDefaultAsync(); var dbUser = await _userContext.Users.Find(new BsonDocument("_id", new ObjectId(updateRequest.UserId))).ToListAsync(); dbArticles = _context.Articles.Find(p => p.Id == id).ToList(); if (dbArticles.Count == 0) { throw new NotFoundItemException("Article not found"); } if (dbUser is null) { throw new NotFoundItemException("User not found"); } if (dbCategory is null) { throw new NotFoundItemException("Category not found"); } var dbArticle = dbArticles[0]; _mapper.Map(updateRequest, dbArticle); await _context.Articles.ReplaceOneAsync(new BsonDocument("_id", new ObjectId(id)), dbArticle); var article = await GetFullUserInfo(dbArticle); return(article); }
public void UpdateArticle_DuringChangingImageDeletingFailed_ThrowDatabaseException(bool imageInserted) { updateRequest = updateRequest with { IsImageDeleted = false, Image = new FormFile(It.IsNotNull <Stream>(), It.IsNotNull <long>(), It.IsNotNull <long>(), It.IsNotNull <string>(), It.IsNotNull <string>()) }; var article = SetUpUpdateArticleWhenImageIsChanged(imageInserted); database.Setup(d => d.ArticleImageRepository.DeleteByColumn(new(ArticleId, article.Id))) .ReturnsAsync(false); Assert.That(() => articleService.UpdateArticle(updateRequest), Throws.Exception.TypeOf <DatabaseException>()); }
/// <summary> /// Update an article (or it's translation) with the requested data. /// /// c.f. https://developers.freshdesk.com/api/#solution_article_attributes /// </summary> /// /// <param name="articleId"> /// The unique identifier for the article. /// </param> /// /// <param name="request"> /// Defines the properties to be updated. /// </param> /// /// <param name="languageCode"> /// Optional. If set then the languageCode version of the article will /// be updated instead of the default article. /// </param> /// /// <param name="cancellationToken"></param> /// /// <returns> /// The updated article (translated if languageCode is passed) /// </returns> public async Task <Article> UpdateArticleAsync( long articleId, UpdateArticleRequest request, string languageCode = null, CancellationToken cancellationToken = default) { if (request == null) { throw new ArgumentNullException(nameof(request), "The request must not be null"); } var url = string.IsNullOrWhiteSpace(languageCode) ? $"/api/v2/solutions/articles/{articleId}" : $"/api/v2/solutions/articles/{articleId}/{languageCode}"; return(await _freshdeskClient.ApiOperationAsync <Article>(HttpMethod.Put, url, request, cancellationToken).ConfigureAwait(false)); }
public async Task <Article> UpdateArticle(UpdateArticleRequest request) { var article = await database.ArticleRepository.FindById(request.ArticleId) ?? throw new EntityNotFoundException("Article not found"); article = mapper.Map(request, article); if (request.IsImageDeleted && !string.IsNullOrEmpty(article.ImageUrl)) { await DeleteImage(article); } else if (!request.IsImageDeleted && request.Image != null) { await DeleteImage(article); await UploadImage(request.Image, article); } return(await database.ArticleRepository.Update(article) ? article : throw new DatabaseException()); }
public async Task UpdateArticle_ImageIsChanged_ReturnArticle(bool imageInserted) { updateRequest = updateRequest with { IsImageDeleted = false, Image = new FormFile(It.IsNotNull <Stream>(), It.IsNotNull <long>(), It.IsNotNull <long>(), It.IsNotNull <string>(), It.IsNotNull <string>()) }; var article = SetUpUpdateArticleWhenImageIsChanged(imageInserted); database.Setup(d => d.ArticleImageRepository.DeleteByColumn(new(ArticleId, article.Id))).ReturnsAsync(true); var result = await articleService.UpdateArticle(updateRequest); Assert.That(result, Is.Not.Null); Assert.That(result, Is.TypeOf <Article>()); Assert.That(result.Id, Is.EqualTo(article.Id)); }
public async Task <IActionResult> UpdateArticle(int libraryId, int periodicalId, int volumeNumber, int issueNumber, int articleId, ArticleView chapter, CancellationToken token = default(CancellationToken)) { if (!ModelState.IsValid) { return(new BadRequestObjectResult(ModelState)); } var request = new UpdateArticleRequest(libraryId, periodicalId, volumeNumber, issueNumber, articleId, chapter.Map()); await _commandProcessor.SendAsync(request, cancellationToken : token); var renderResult = _articleRenderer.Render(request.Result.Article, libraryId, periodicalId, volumeNumber, issueNumber); if (request.Result.HasAddedNew) { return(new CreatedResult(renderResult.Links.Self(), renderResult)); } return(new OkObjectResult(renderResult)); }
protected override async Task <Entity> UpdateAsync(IDictionary <string, object> propertyUpdates, IDictionary <string, string> attributeUpdates, IEnumerable <string> addedTags, IEnumerable <string> removedTags, int specificRevision) { var request = new UpdateArticleRequest { Id = this.Id, Type = this.Type }; if (propertyUpdates != null && propertyUpdates.Count > 0) { propertyUpdates.For(x => request.PropertyUpdates[x.Key] = x.Value); } if (attributeUpdates != null && attributeUpdates.Count > 0) { attributeUpdates.For(x => request.AttributeUpdates[x.Key] = x.Value); } if (addedTags != null) { request.AddedTags.AddRange(addedTags); } if (removedTags != null) { request.RemovedTags.AddRange(removedTags); } // Check if an update is needed. if (request.PropertyUpdates.Count == 0 && request.AttributeUpdates.Count == 0 && request.AddedTags.Count == 0 && request.RemovedTags.Count == 0) { return(null); } var response = await request.ExecuteAsync(); if (response.Status.IsSuccessful == false) { throw response.Status.ToFault(); } // 3. Update the last known state based on the differences Debug.Assert(response.Article != null, "If status is successful, then updated article should not be null."); return(response.Article); }
public void Put_Article_Should_Return_BadRequest_Response_When_Creating_Article_With_Invalid_Data(DataFormat dataFormat) { ArticleResponse CreateArticleRequestAndAssert() { var createArticleRequest = new CreateArticleRequest() { Title = GetUniqueStringValue("title_"), Body = GetUniqueStringValue("body_"), IsPublished = false, PublishDate = null, Author = "God", }; CreateArticle(createArticleRequest, dataFormat, out HttpResponseMessage createHttpResponseMessage, out string createResponseString, out ArticleResponse createArticleResponse); Assert.AreEqual(HttpStatusCode.Created, createHttpResponseMessage.StatusCode); Assert.AreEqual(createArticleRequest.Title, createArticleResponse.Title); Assert.AreEqual(createArticleRequest.Body, createArticleResponse.Body); Assert.AreEqual(createArticleRequest.Author, createArticleResponse.Author); Assert.IsTrue(createArticleResponse.Id > 1); return(createArticleResponse); } var createArticleResponse1 = CreateArticleRequestAndAssert(); var createArticleResponse2 = CreateArticleRequestAndAssert(); var updateArticleRequest = new UpdateArticleRequest() { Title = null, Body = GetUniqueStringValue("body_"), IsPublished = true, PublishDate = DateTime.UtcNow, Author = "God", }; UpdateArticle(createArticleResponse2.Id, updateArticleRequest, dataFormat, out HttpResponseMessage updateHttpResponseMessage, out string updateResponseString); Assert.AreEqual(HttpStatusCode.BadRequest, updateHttpResponseMessage.StatusCode); }
public async Task BugId14Test() { // Ref: https://github.com/appacitive/Gossamer/issues/14 // Updating a null property with a null value fails // Create an article var now = DateTime.Now; dynamic obj = new Article("object"); obj.intfield = 1; obj.decimalfield = 10.0m; obj.stringfield = null; var createdResponse = await(new CreateArticleRequest() { Article = obj }).ExecuteAsync(); Assert.IsNotNull(createdResponse, "Article creation failed."); Assert.IsNotNull(createdResponse.Status, "Status is null."); Assert.IsTrue(createdResponse.Status.IsSuccessful, createdResponse.Status.Message ?? "Create article failed."); var created = createdResponse.Article; // Update the article twice for (int i = 0; i < 2; i++) { var updateRequest = new UpdateArticleRequest() { Id = created.Id, Type = created.Type }; updateRequest.PropertyUpdates["stringfield"] = null; var updatedResponse = await updateRequest.ExecuteAsync(); Assert.IsNotNull(updatedResponse, "Update article response is null."); Assert.IsNotNull(updatedResponse.Status, "Update article response status is null."); Assert.IsTrue(updatedResponse.Status.IsSuccessful, updatedResponse.Status.Message ?? "NULL"); Assert.IsNotNull(updatedResponse.Article, "Updated article is null."); var updated = updatedResponse.Article; Assert.IsTrue(updated["stringfield"] is NullValue); } }
public async Task UpdateArticle_ImageIsChanged_DeleteImageAndInsertImageShouldBeCalled( bool imageInserted) { updateRequest = updateRequest with { IsImageDeleted = false, Image = new FormFile(It.IsNotNull <Stream>(), It.IsNotNull <long>(), It.IsNotNull <long>(), It.IsNotNull <string>(), It.IsNotNull <string>()) }; var article = SetUpUpdateArticleWhenImageIsChanged(imageInserted); database.Setup(d => d.ArticleImageRepository.DeleteByColumn(new(ArticleId, article.Id))).ReturnsAsync(true); await articleService.UpdateArticle(updateRequest); database.Verify(d => d.ArticleImageRepository.DeleteByColumn(new(ArticleId, article.Id))); filesManager.Verify(fm => fm.DeleteDirectory(It.IsAny <string>(), true)); filesManager.Verify(fm => fm.Upload(It.IsNotNull <IFormFile>(), It.IsNotNull <string>())); database.Verify(d => d.ArticleImageRepository.Insert(It.IsNotNull <ArticleImage>(), false)); }
/// <inheritdoc/> public async Task <Article> UpdateArticleAsync(int id, UpdateArticleRequest updateRequest) { var dbArticles = await _articles.Articles.Where(article => article.Id != id).ToArrayAsync(); if (dbArticles.Length == 0) { throw new RequestedResourceNotFoundException(); } if (_articles.Articles.Where(article => article.Title == updateRequest.Title).ToArrayAsync().Result.Length > 0) { throw new RequestedResourceHasConflictException("title"); } var dbArticle = dbArticles[0]; _mapper.Map(updateRequest, dbArticle); await _articles.SaveChangesAsync(); return(_mapper.Map <Article>(dbArticle)); }
public async Task <ArticleDetails> UpdateArticleAsync(string articleId, UpdateArticleRequest updateArticle) { var article = await this.GetDbArticle(articleId); if (article.CategoryId != updateArticle.CategoryId) { var oldCategory = await this.categoryService.GetCategory(article.CategoryId); await this.categoryService.DeleteArticleFromCategory(oldCategory, articleId); } this.mapper.Map(updateArticle, article); await this.CheckUpdateArticleConflicts(article); var newCategory = await this.categoryService.GetCategory(updateArticle.CategoryId); await this.context.Articles.FindOneAndReplaceAsync(a => a.Id == articleId, article); await this.categoryService.AddArticleToCategory(newCategory, articleId); return(this.mapper.Map <ArticleDetails>(article)); }