/// <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));
}
