public async Task <ActionResult> Create(AddCategoryViewModel request)
{
if (!ModelState.IsValid)
{
Alert($"Invalid Request.", NotificationType.error, Int32.Parse(_appConfig.Value.NotificationDisplayTime));
return(View());
}
try
{
var addCategoryRequest = new AddCategoryRequest {
Name = request.Name, Description = request.Description
};
var result = await _categoryService.Create(addCategoryRequest);
if (!result.Success)
{
Alert($"{result.Message}", NotificationType.info, Int32.Parse(_appConfig.Value.NotificationDisplayTime));
return(View());
}
Alert($"Category Created Successfully", NotificationType.success, Int32.Parse(_appConfig.Value.NotificationDisplayTime));
return(RedirectToAction(nameof(Index)));
}
catch (Exception ex)
{
Alert($"Error! {ex.Message}.", NotificationType.error, Int32.Parse(_appConfig.Value.NotificationDisplayTime));
return(View());
}
}
public static RequestParamValidator[] CategoryAddValidator(AddCategoryRequest addRequest)
{
return(new[] {
new RequestParamValidator(() => addRequest == null, "Request has to be set"),
new RequestParamValidator(() => string.IsNullOrEmpty(addRequest?.Name), "Name has to be set for category")
});
}
public async Task <ServiceResponse <Category> > Create(AddCategoryRequest request)
{
try
{
var category = new Category
{
Code = GenerateCode(8),
Description = request.Description,
Name = request.Name
};
var exist = await _baseRepository.GetByIdAndCode(category.Id, category.Code);
if (exist != null)
{
return(new ServiceResponse <Category>($"A Category With the Provided Code and or Id Already Exist"));
}
var exist2 = await _baseRepository.FindOneByConditions(x => x.Name.ToLower().Equals(category.Name.ToLower()));
if (exist2 != null)
{
return(new ServiceResponse <Category>($"A Category With the Provided Name Already Exist"));
}
await _baseRepository.Create(category);
return(new ServiceResponse <Category>(category));
}
catch (Exception ex)
{
return(new ServiceResponse <Category>($"An Error Occured While Creating The Category. {ex.Message}"));
}
}
public async Task <BaseApiResponse> Add(AddCategoryRequest request)
{
request.CheckNotNull(nameof(request));
var newcategoryid = GuidUtil.NewSequentialId();
var command = new CreateCategoryCommand(
newcategoryid,
request.ParentId,
request.Name,
request.Url,
request.Thumb,
request.Type,
request.IsShow,
request.Sort);
var result = await ExecuteCommandAsync(command);
if (!result.IsSuccess())
{
return(new BaseApiResponse {
Code = 400, Message = "命令没有执行成功：{0}".FormatWith(result.GetErrorMessage())
});
}
//添加操作记录
var currentAdmin = _contextService.GetCurrentAdmin(HttpContext.Current);
RecordOperat(currentAdmin.AdminId.ToGuid(), "添加分类", newcategoryid, request.Name);
return(new BaseApiResponse());
}
public override async Task <BasicResponse> AddCategory(AddCategoryRequest request, ServerCallContext context)
{
var category = Category.New(request.CategoryData);
await categoryRepository.AddCategory(category);
return(await GetResponse(StatusCode.Ok));
}
public async Task AddProduct([FromBody] AddCategoryRequest category)
{
await billsModule.ExecuteCommandAsync(
new AddProductCategory
{
Name = category.Name
}
);
}
public void AddCategory(AddCategoryRequest request)
{
_cateringManager.CreateCategory(new Entities.CateringCategory
{
Name = request.Name,
Comment = request.Comment,
DisplayName = request.DisplayName,
});
}
public async Task <IActionResult> Add(AddCategoryRequest request)
{
if (!ModelState.IsValid)
{
return(Failure());
}
return(await _categoryService.Add(request));
}
public int AddCategory(AddCategoryRequest addCategoryRequest)
{
using (DataAccess dataAccess = new DataAccess())
{
Category category = new Category();
category.CategoryName = addCategoryRequest.CategoryName;
dataAccess.Categories.Add(category);
return(dataAccess.SaveChanges());
}
}
public async Task <ApiResult> AddCategoryAsync([FromBody] AddCategoryRequest request)
{
var user = GetUser();
if (user == null)
{
return(AuthorizeError());
}
return(await _categoryService.AddCategoryAsync(request, user.UserId));
}
public async Task <Response <Category> > AddCategory(AddCategoryRequest request)
{
var Category = new Category()
{
CategoryName = request.CategoryName
};
_context.Category.Add(Category);
await _context.SaveChangesAsync();
return(new Response <Category>());
}
public async Task <BaseResponse> AddAsync(AddCategoryRequest request)
{
var loggedUser = await _authenticationService.GetLoggedUserAsync();
var category = _mapper.Map <AddCategoryRequest, Category>(request);
category.UserId = loggedUser.User.Id;
await _categoryRepository.AddAsync(category);
await _unitOfWork.SaveChangesAsync();
return(new BaseResponse());
}
/// <summary>
/// 添加分类
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
public AddCategoryResponse AddCategory(AddCategoryRequest request)
{
AddCategoryResponse response = new AddCategoryResponse();
try
{
response = acsClient.GetAcsResponse(request);
}
catch (Exception ex)
{
}
return(response);
}
public async Task AddCategoryRequestValidator_FailsIfNameAlreadyExistsCaseInsensitive()
{
// Arrange
var request = new AddCategoryRequest {
CategoryName = _existingCategories.First().CategoryName.ToUpper()
};
// Act
var result = await _sut.ValidateAsync(request, default);
// Assert
result.IsValid.Should().BeFalse();
result.Errors.Should().Contain(e => e.PropertyName == nameof(AddCategoryRequest.CategoryName));
}
public async Task AddCategoryRequestValidator_SuccessIfNameIsOK(string categoryName)
{
// Arrange
var request = new AddCategoryRequest {
CategoryName = categoryName, DefaultSteps = new AddCategoryRequest.AddCategoryDefaultStep[10]
};
// Act
var result = await _sut.ValidateAsync(request, default);
// Assert
result.IsValid.Should().BeTrue();
result.Errors.Should().BeEmpty();
}
public async Task <IActionResult> CreateCategory(int libraryId, [FromBody] CategoryView category, CancellationToken token = default(CancellationToken))
{
if (!ModelState.IsValid)
{
return(new BadRequestObjectResult(ModelState));
}
var request = new AddCategoryRequest(libraryId, category.Map());
await _commandProcessor.SendAsync(request, cancellationToken : token);
var renderResult = _categoryRenderer.Render(request.Result, libraryId);
return(new CreatedResult(renderResult.Links.Self(), renderResult));
}
/// <summary>
/// 添加媒体资源分类
/// </summary>
/// <param name="input"></param>
/// <returns></returns>
public AddCategoryResponse CreateMediaCategory(AddCategoryRequest input)
{
// 父分类ID，若不填，则默认生成一级分类，根节点分类ID为 -1
if (!input.ParentId.HasValue)
{
input.ParentId = -1;
}
var client = InitVodClient();
var model = client.GetAcsResponse(input);
return(model);
}
/// <summary>
/// 添加分类
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
public async Task <ApiResult> AddCategoryAsync(AddCategoryRequest request, long userId)
{
var response = new ApiResult();
try
{
var isExist = await _categoryRepository.TableNotTracking
.AnyAsync(item => item.CategoryName == request.CategoryName);
if (isExist)
{
response.Code = Code.Error;
response.Message = "该分类名称以存在";
return(response);
}
var user = await _userRepository.TableNotTracking
.FirstOrDefaultAsync(item => item.Id == userId);
var category = new Category(true)
{
CategoryName = request.CategoryName,
Status = 1,
CreateTime = DateTime.Now,
Creator = user.UserName,
UserId = userId
};
var hasDefault = await _categoryRepository.TableNotTracking
.AnyAsync(item => item.Status == 1 && item.UserId == userId && item.IsDefault == 1);
if (!hasDefault)
{
category.IsDefault = 1;
}
await _categoryRepository.InsertAsync(category);
await _efContextWork.SaveChangesAsync();
response.Code = Code.Ok;
response.Message = "添加成功";
return(response);
}
catch (Exception ex)
{
_logger.LogError($"添加分类异常;method={nameof(AddCategoryAsync)};param={request.ToJson()};exception messges={ex.Message}");
response.Code = Code.Error;
response.Message = $"添加分类异常：{ex.Message}";
return(response);
}
}
public async Task <IActionResult> Add([FromBody] AddCategoryRequest request)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState.GetErrorMessages()));
}
var response = await _categoryService.AddAsync(request);
if (!response.IsValid)
{
return(BadRequest(response.Message));
}
return(Ok(response));
}
public async Task <CategoryResponse> AddCategoryAsync(AddCategoryRequest request)
{
if (request == null)
{
throw new ArgumentNullException();
}
var category = _mapper.Map <Entities.Category>(request);
var result = _categoryRepository.Add(category);
await _categoryRepository.UnitOfWork.SaveChangesAsync();
var response = _mapper.Map <CategoryResponse>(result);
return(response);
}
public async Task <IActionResult> Add(AddCategoryRequest request)
{
var userId = _jwtService.GetUserId();
var category = new Category()
{
Name = request.Name,
Type = request.Type,
UserId = userId
};
_context.Categories.Add(category);
await _context.SaveChangesAsync();
return(Success(ConvertToVM(category)));
}
public async Task AddCategoryRequestValidator_FailsIfNameOrStepsIsEmpty(string categoryName)
{
// Arrange
var request = new AddCategoryRequest {
CategoryName = categoryName
};
// Act
var result = await _sut.ValidateAsync(request, default);
// Assert
result.IsValid.Should().BeFalse();
result.Errors.Should().Contain(e => e.PropertyName == nameof(AddCategoryRequest.CategoryName));
result.Errors.Should().Contain(e => e.PropertyName == nameof(AddCategoryRequest.DefaultSteps));
}
public async Task <int> AddCategory(AddCategoryRequest request)
{
var category = new Category
{
CategoryName = request.CategoryName,
Level = request.Level,
ParentId = request.ParentId,
CreateTime = DateTime.Now,
UpdateTime = DateTime.Now
};
await _db.Category.AddAsync(category);
await _db.SaveChangesAsync();
return(category.Id);
}
public async Task <BaseResponse> AddAsync(AddCategoryRequest request, int accountId)
{
var loggedUser = await _authenticationService.GetLoggedUserAsync();
var accountUser = await _accountUserRepository.GetAsync(accountUser => accountUser.UserId == loggedUser.User.Id && accountUser.AccountId == accountId);
var category = _mapper.Map <AddCategoryRequest, Category>(request);
category.AccountId = accountId;
category.CreatedBy = accountUser;
await _categoryRepository.AddAsync(category);
await _unitOfWork.SaveChangesAsync();
return(new BaseResponse());
}
public IActionResult AddCategory([FromBody] AddCategoryRequest request)
{
if (request == null)
{
return(BadRequest(new ErrorViewModel
{
ErrorCode = "400",
ErrorMessage = "Please provide input information correctly."
}));
}
if (request.ParentId <= 0)
{
return(BadRequest(new ErrorViewModel
{
ErrorCode = "400",
ErrorMessage = "Parent category not found"
}));
}
var categoryQuery = _categoryRepository.FindByName(request.CategoryName);
if (categoryQuery != null)
{
return(BadRequest(new ErrorViewModel
{
ErrorCode = "400",
ErrorMessage = "Category have been create"
}));
}
var category = new Category()
{
Name = request.CategoryName,
ParentId = request.ParentId,
Slug = request.Slug
};
var response = _categoryServices.AddCategory(category);
if (response != "OK")
{
return(BadRequest("Can not execute. Plz contact admin"));
}
return(Ok(response));
}
public async Task <IActionResult> CreateACategory([FromBody] AddCategoryRequest request)
{
Category aCategory = new Category()
{
Description = request.Description,
Name = request.Name
};
await _context.Categories.AddAsync(aCategory);
var result = await _context.SaveChangesAsync();
if (result > 0)
{
return(Ok(result));
}
return(NotFound());
}
public async Task <VodCategoryEditDto> CreateVodCategory(VodCategoryEditDto input)
{
await Task.Yield();
var dto = new AddCategoryRequest {
ParentId = input.ParentId, CateName = input.CateName
};
var res = _aliyunVodManager.CreateMediaCategory(dto);
input.CateId = res.Category.CateId;
input.CateName = res.Category.CateName;
input.Level = res.Category.Level;
input.ParentId = res.Category.ParentId;
return(input);
}
/// <summary>
/// AddCategory
/// </summary>
/// <param name="request">AddCategoryRequest</param>
/// <returns>bool</returns>
public async Task <bool> AddCategory(AddCategoryRequest request)
{
bool result = false;
try
{
var param = new AddCategoryParameter()
{
nameCategory = request.nameCategory,
imgCategory = request.imgCategory
};
_dataAccess.AddCategory(param);
result = true;
return(result);
}
catch (Exception)
{
result = false;
}
return(await Task.FromResult(result));
}
public async Task <ActionResult <GetAllCategoriesResponse> > Add([FromBody] AddCategoryRequest request)
{
var newCategory = new Category()
{
Name = request.Name,
Description = request.Description,
Color = request.Color,
ParentId = request.ParentId,
};
newCategory.SchedulerEvents = new List <SchedulerEvent>();
var categoryTags = new List <CategoryTag>();
if (request.tags != null)
{
request.tags.ForEach(tag =>
{
CategoryTag categoryTag = new CategoryTag();
categoryTag.CategoryId = newCategory.Id;
categoryTag.TagId = _context.Tags.First(temp => temp.Name == tag).Id;
categoryTags.Add(categoryTag);
_context.CategoryTags.Add(categoryTag);
});
}
newCategory.CategoryTags = categoryTags;
_context.Categories.Add(newCategory);
await _context.SaveChangesAsync();
var response = new GetAllCategoriesResponse();
response.Id = newCategory.Id;
response.Name = newCategory.Name;
response.ParentId = request.ParentId;
response.SchedulerEvents = newCategory.SchedulerEvents.ToList();
response.Tags = request.tags;
response.Color = newCategory.Color;
response.Description = newCategory.Description;
return(Ok(response));
}
public async Task <BaseApiResponse> Add(AddCategoryRequest request)
{
request.CheckNotNull(nameof(request));
var command = new CreateCategoryCommand(
GuidUtil.NewSequentialId(),
request.ParentId,
request.Name,
request.Url,
request.Thumb,
request.Type,
request.IsShow,
request.Sort);
var result = await ExecuteCommandAsync(command);
if (!result.IsSuccess())
{
return(new BaseApiResponse {
Code = 400, Message = "命令没有执行成功：{0}".FormatWith(result.GetErrorMessage())
});
}
return(new BaseApiResponse());
}
