public bool Delete(DeleteCategoryRequest request)
{
var delete = _context.Categories.Where(w => w.category_id == request.category_id).FirstOrDefault();
if (delete != null)
{
_context.Remove(delete);
_context.SaveChanges();
return(true);
}
else
{
return(false);
}
}
public async Task <DeleteCategoryResult> DeleteCategory(DeleteCategoryRequest request)
{
try
{
DynamicParameters parameters = new DynamicParameters();
parameters.Add("@IdCategory", request.IdCategory);
return(await SqlMapper.QueryFirstOrDefaultAsync <DeleteCategoryResult>(cnn : connect,
sql : "sp_DeleteCategory",
param : parameters,
commandType : CommandType.StoredProcedure));
}
catch (Exception ex)
{
throw;
}
}
public DeleteCategoryResponse DeleteCategory(DeleteCategoryRequest request)
{
using (var db = new DotWEntities())
{
var Category = db.Categories.FirstOrDefault(x => x.Id == request.Id);
if (Category != null)
{
Category.NullDate = DateTime.Now;
db.SaveChanges();
}
return(new DeleteCategoryResponse());
}
}
public DeleteCategoryResponse DeleteCategory(DeleteCategoryRequest request)
{
DeleteCategoryResponse response = new DeleteCategoryResponse();
try
{
categoryRepository.Delete(request.CategoryId);
response.Success = true;
}
catch (Exception ex)
{
response.Success = false;
response.Message = ex.Message;
}
return(response);
}
public async Task <ResponseResult <bool> > RemoveCategoryAsync(DeleteCategoryRequest categoryRequest)
{
var removedCategory = await _shopRepository.RemoveCategoryAsync(categoryRequest.CategoryId);
if (!removedCategory)
{
return(new ResponseResult <bool>
{
Errors = new[] { "Category not found" }
});
}
return(new ResponseResult <bool>
{
Success = true
});
}
public DeleteCategoryResponse DeleteCategory(DeleteCategoryRequest request)
{
var response = new DeleteCategoryResponse();
WithErrorHandling(() =>
{
var category = _categoryRepository.FindCategoryById(request.Id);
_categoryRepository.DeleteCategory(category);
var categoryDto = category.MapToCategoryDto();
response.Category = categoryDto;
response.Messages.Add("Successfully deleted the category");
response.StatusCode = HttpStatusCode.OK;
}, response);
return(response);
}
public ActionResult Delete(int categoryId)
{
DeleteCategoryRequest request = new DeleteCategoryRequest();
DeleteCategoryResponse response = new DeleteCategoryResponse();
request.CategoryId = categoryId;
response = categoryService.DeleteCategory(request);
if (response.Success)
{
return(RedirectToAction("Index"));
}
else
{
CategoryListPageViewModel model = new CategoryListPageViewModel();
model.Success = false;
model.ErrorMessage = response.Message;
return(View("Index", model));
}
}
/// <summary>
/// DeleteCategory
/// </summary>
/// <param name="request">DeleteCategoryRequest</param>
/// <returns>bool</returns>
public async Task <bool> DeleteCategory(DeleteCategoryRequest request)
{
bool result = false;
try
{
var param = new DeleteCategoryParameter()
{
id = request.id
};
_dataAccess.DeleteCategory(param);
result = true;
return(await Task.FromResult(result));
}
catch (Exception)
{
result = false;
return(await Task.FromResult(result));
}
}
public IActionResult DeleteCategory([FromBody] DeleteCategoryRequest request)
{
if (request == null)
{
return(BadRequest(new ErrorViewModel
{
ErrorCode = "400",
ErrorMessage = "Please provide input information correctly."
}));
}
if (request.CategoryId <= 0)
{
return(BadRequest(new ErrorViewModel
{
ErrorCode = "400",
ErrorMessage = "Category not found"
}));
}
var category = _categoryRepository.FindById(request.CategoryId);
if (category == null)
{
return(BadRequest(new ErrorViewModel
{
ErrorCode = "400",
ErrorMessage = "Category not found"
}));
}
var response = _categoryServices.DeleteCategory(category);
if (response != "OK")
{
return(BadRequest("Can not execute. Plz contact admin"));
}
return(Ok(response));
}
public Task <BaseResponse> DeleteCategory(DeleteCategoryRequest request, int UserID)
{
throw new NotImplementedException();
}
/// <summary>
/// 删除敏感数据分类
/// </summary>
/// <param name="request">请求参数信息</param>
/// <returns>请求结果信息</returns>
public async Task <DeleteCategoryResponse> DeleteCategory(DeleteCategoryRequest request)
{
return(await new DeleteCategoryExecutor().Client(this).Execute <DeleteCategoryResponse, DeleteCategoryResult, DeleteCategoryRequest>(request).ConfigureAwait(false));
}
/// <summary>
/// 删除敏感数据分类
/// </summary>
/// <param name="request">请求参数信息</param>
/// <returns>请求结果信息</returns>
public DeleteCategoryResponse DeleteCategory(DeleteCategoryRequest request)
{
return(new DeleteCategoryExecutor().Client(this).Execute <DeleteCategoryResponse, DeleteCategoryResult, DeleteCategoryRequest>(request));
}
public async Task DeleteCategory([FromUri] DeleteCategoryRequest request)
{
await _categoriesManagementService.DeleteCategory(request);
}
public async Task <OkObjectResult> Delete(DeleteCategoryRequest request)
{
return(Ok(await categoryService.DeleteCategory(request)));
}
/// <summary>
/// Deletes the specified request.
/// </summary>
/// <param name="request">The request.</param>
/// <returns><c>DeleteCategoryResponse</c> with success status.</returns>
public DeleteCategoryResponse Delete(DeleteCategoryRequest request)
{
if (request.Data == null || request.Id.HasDefaultValue())
{
return new DeleteCategoryResponse { Data = false };
}
var itemToDelete = repository
.AsQueryable<Module.Root.Models.Category>()
.Where(p => p.Id == request.Id)
.FirstOne();
if (request.Data.Version > 0 && itemToDelete.Version != request.Data.Version)
{
throw new ConcurrentDataException(itemToDelete);
}
unitOfWork.BeginTransaction();
repository.Delete(itemToDelete);
unitOfWork.Commit();
Events.RootEvents.Instance.OnCategoryDeleted(itemToDelete);
return new DeleteCategoryResponse { Data = true };
}
public async Task <DeleteCategoryResult> DeleteCategory(DeleteCategoryRequest request)
{
return(await categoryRepository.DeleteCategory(request));
}
public async Task <int> DeleteCategory(DeleteCategoryRequest request)
{
return(await _db.Database.ExecuteSqlCommandAsync("Delete From Category Where Id={0}", request.CategoryId));
}
public IHttpActionResult DeleteCategory(DeleteCategoryRequest request)
{
var result = _businessLogic.DeleteCategory(request);
return(new ActionResult <bool>(result.Result, Request));
}
public async Task DeleteCategory(DeleteCategoryRequest request)
{
await ProcessRequest(request, _categoriesRepository.DeleteCategory);
}
public DeleteCategoryResponse DeleteCategory(DeleteCategoryRequest request)
{
return(dao.DeleteCategory(request));
}
public override async Task <Empty> DeleteCategory(DeleteCategoryRequest deleteCategoryRequest, ServerCallContext context)
{
var deleteCategory = _mapper.Map <DeleteCategoryRequest, DeleteCategory>(deleteCategoryRequest);
return(_mapper.Map <Unit, Empty>(await _mediator.Send(deleteCategory)));
}
public async Task <DeleteCategoryResponse> Delete([FromBody] DeleteCategoryRequest request)
{
return(await _mediator.Send(request));
}
