public async Task <DeleteArticleResponse> DeleteArticleAsync(DeleteArticleRequest request)
{
var response = new DeleteArticleResponse();
try
{
var article = await this.articleRepository.GetByIdAsync(request.ArticleId);
if (article != null)
{
response.Title = article.ArticleVersions.FirstOrDefault(x => x.LanguageId == request.LanguageId)?.Title ?? article.ArticleVersions.FirstOrDefault(x => x.LanguageId == 1)?.Title;
this.articleRepository.Delete(article);
await this.unitOfWork.CommitAsync();
response.Status = StatusCode.OK;
}
else
{
response.Status = StatusCode.NotFound;
}
}
catch (Exception ex)
{
this.exceptionHandler.HandleException(ex);
response.Status = StatusCode.InternalServerError;
}
return(response);
}
public async Task <IActionResult> DeleteArticle(int libraryId, int periodicalId, int volumeNumber, int issueNumber, int articleId, CancellationToken token = default(CancellationToken))
{
var request = new DeleteArticleRequest(libraryId, periodicalId, volumeNumber, issueNumber, articleId);
await _commandProcessor.SendAsync(request, cancellationToken : token);
return(new NoContentResult());
}
public async Task <IActionResult> DeleteArticle([FromQuery] DeleteArticleRequest request)
{
var response = await mediator.Send(request);
Log.Information($"User #{HttpContext.GetCurrentUserId()} deleted article #{request.ArticleId}");
return(this.CreateResponse(response));
}
public async Task <IActionResult> Delete(Guid id)
{
DeleteArticleRequest request = new DeleteArticleRequest {
Id = id
};
return(Ok(await _mediator.Send(new DelteArticleCommand(request))));
}
/// Delete one Article entity by ID
/// <inheritdoc/>
public override async Task <EmptyReply> DeleteArticle(DeleteArticleRequest request, ServerCallContext context)
{
if (!await this.articlesRepository.DeleteAsync(request.ArticleId))
{
this.logger.LogInformation($"Article ID#{request.ArticleId} wasn't found");
throw new RpcException(new Status(StatusCode.NotFound, "Article wasn't not found"));
}
return(new EmptyReply());
}
public void Handle_DeleteArticleFailed_ThrowCrudException()
{
var request = new DeleteArticleRequest();
articleService.Setup(a => a.DeleteArticle(It.IsNotNull <string>()))
.ReturnsAsync(false);
Assert.That(
() => deleteArticleCommand.Handle(request, It.IsNotNull <CancellationToken>()),
Throws.TypeOf <CrudException>());
}
public async Task Handle_WhenCalled_ReturnDeleteArticleResponse()
{
var request = new DeleteArticleRequest {
ArticleId = "test"
};
articleService.Setup(a => a.DeleteArticle(It.IsNotNull <string>()))
.ReturnsAsync(true);
var result = await deleteArticleCommand.Handle(request, It.IsNotNull <CancellationToken>());
Assert.That(result, Is.TypeOf <DeleteArticleResponse>());
}
public JsonResult <object> DeleteArticle(DeleteArticleRequest request)
{
var baseInfo = GetBaseInfo();
if (request == null)
{
return(JsonError("请求数据错误"));
}
_articleService.DeleteArticle(request.ArticleID);
return(JsonNet("删除文章成功"));
}
/// <summary>
///
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
public DeleteArticleResponse DeleteArticle(DeleteArticleRequest request)
{
using (var client = DbFactory.CreateClient())
{
var article = client.Queryable <Article>().InSingle(request.Id);
if (article == null)
{
throw new AlertException("找不到该条信息");
}
client.Deleteable <Article>(request.Id).ExecuteCommand();
_eventPublisher.EntityDeleted(article);
return(new DeleteArticleResponse());
}
}
public async Task <ArticleResponse> DeleteArticleAsync(DeleteArticleRequest request)
{
if (request?.Id == null)
{
throw new ArgumentNullException();
}
Article result = await _articleRespository.GetAsync(request.Id);
if (result == null)
{
throw new ArgumentException($"Entity with {request.Id} is not present");
}
result.IsInactive = true;
_articleRespository.Update(result);
int modifiedRecords = await _articleRespository.UnitOfWork.SaveChangesAsync();
_logger.LogInformation(Logging.Events.Delete, Messages.NumberOfRecordAffected_modifiedRecords, modifiedRecords);
return(_articleMapper.Map(result));
}
public async Task <RedirectToRouteResult> Delete(int id)
{
var request = new DeleteArticleRequest
{
ArticleId = id
};
var response = await this.articleService.DeleteArticleAsync(request);
if (response.Status == StatusCode.OK)
{
TempData["SuccessMessage"] = string.Format("You have successfully deleted '{0}'.", response.Title);
}
else if (response.Status == StatusCode.NotFound)
{
TempData["FailureMessage"] = "The article you are trying to delete cannot be found.";
}
else
{
TempData["FailureMessage"] = "The article has not deleted successfully. Please try again.";
}
return(this.RedirectToAction("Index"));
}
//[AdminAuthorize(Permissions = "admin.article.delete")]
public IActionResult Delete(DeleteArticleRequest request)
{
var resp = _articleService.DeleteArticle(request);
return(RespJson(resp));
}
public async Task<RedirectToRouteResult> Delete(int id)
{
var request = new DeleteArticleRequest
{
ArticleId = id
};
var response = await this.articleService.DeleteArticleAsync(request);
if (response.Status == StatusCode.OK)
{
TempData["SuccessMessage"] = string.Format("You have successfully deleted '{0}'.", response.Title);
}
else if (response.Status == StatusCode.NotFound)
{
TempData["FailureMessage"] = "The article you are trying to delete cannot be found.";
}
else
{
TempData["FailureMessage"] = "The article has not deleted successfully. Please try again.";
}
return this.RedirectToAction("Index");
}
public async Task<DeleteArticleResponse> DeleteArticleAsync(DeleteArticleRequest request)
{
var response = new DeleteArticleResponse();
try
{
var article = await this.articleRepository.GetByIdAsync(request.ArticleId);
if (article != null)
{
response.Title = article.ArticleVersions.FirstOrDefault(x => x.LanguageId == request.LanguageId)?.Title ?? article.ArticleVersions.FirstOrDefault(x => x.LanguageId == 1)?.Title;
this.articleRepository.Delete(article);
await this.unitOfWork.CommitAsync();
response.Status = StatusCode.OK;
}
else
{
response.Status = StatusCode.NotFound;
}
}
catch (Exception ex)
{
this.exceptionHandler.HandleException(ex);
response.Status = StatusCode.InternalServerError;
}
return response;
}
public override async Task <Empty> DeleteArticle(DeleteArticleRequest deleteArticleRequest, ServerCallContext context)
{
var deleteArticle = _mapper.Map <DeleteArticleRequest, DeleteArticle>(deleteArticleRequest);
return(_mapper.Map <Unit, Empty>(await _mediator.Send(deleteArticle)));
}
