public async Task <bool> Add(CategoryCreateRequest request)
{
_client.BaseAddress = new Uri(_config[Constants.AppSettings.BaseAddress]);
var requestContent = new MultipartFormDataContent();
requestContent.Add(new StringContent(request.Name.ToString()), "name");
requestContent.Add(new StringContent(request.Description.ToString()), "description");
var response = await _client.PostAsync("/api/categories/", requestContent);
return(response.IsSuccessStatusCode);
}
public async Task <int> Create(CategoryCreateRequest request)
{
var category = new Category()
{
Name = request.Name,
SortOrder = request.SortOrder,
ParentId = request.ParentId
};
_context.Categories.Add(category);
await _context.SaveChangesAsync();
return(category.Id);
}
public async Task <int> Create(CategoryCreateRequest request)
{
var category = new Category()
{
generalityName = request.generalityName,
name = request.name,
status = request.status
};
_context.categories.Add(category);
await _context.SaveChangesAsync();
return(category.id);
}
public async Task <IActionResult> Create([FromForm] CategoryCreateRequest request)
{
if (ModelState.IsValid == false)
{
return(BadRequest(ModelState));
}
var result = await _CategoryService.Create(request);
if (result.IsSuccessed == false)
{
return(BadRequest(result));
}
return(Ok(result));
}
public async Task <IActionResult> PutCategory(int id, CategoryCreateRequest categoryCreateRequest)
{
var category = await _context.Categories.FindAsync(id);
if (category == null)
{
return(NotFound());
}
category.Name = categoryCreateRequest.Name;
await _context.SaveChangesAsync();
return(NoContent());
}
public CategoryEntity toEntity(CategoryCreateRequest request)
{
CategoryEntity entity = new CategoryEntity();
var item = request.Item;
entity.Name = item.Name;
entity.Description = item.Description;
entity.DataStatus = 1;
entity.CreateTime = TimeConvertor.FromMilliTicks(TimeConvertor.ToMilliTicks(DateTime.Now));
entity.LastUpdateTime = TimeConvertor.FromMilliTicks(TimeConvertor.ToMilliTicks(DateTime.Now));
return(entity);
}
public async Task <ActionResult <CategoryVm> > PostCategory(CategoryCreateRequest categoryCreateRequest)
{
var category = new Category
{
Name = categoryCreateRequest.Name
};
_context.Categories.Add(category);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetCategory", new { id = category.Id }, new CategoryVm {
Id = category.Id, Name = category.Name
}));
}
public async Task PostCategory_Success()
{
var category = new CategoryCreateRequest {
Name = "Test category"
};
var controller = new CategoriesController(_dbContext);
var result = await controller.PostCategory(category);
var createdAtActionResult = Assert.IsType <CreatedAtActionResult>(result.Result);
var returnValue = Assert.IsType <CategoryVm>(createdAtActionResult.Value);
Assert.Equal("Test category", returnValue.Name);
}
public async Task Insert(CategoryCreateRequest dto)
{
var entity = new Category()
{
Name = dto.Name,
Description = dto.Description,
CreatedAt = DateTime.Now,
CreatedBy = "tinlvv"
};
var entity2 = dto.Adapt <Category>();
await this._categoryRepo.InsertAsync(entity);
}
public async Task <string> Create(CategoryCreateRequest request)
{
var category = new productCategories()
{
idCategory = request.idCategory,
categoryName = request.categoryName
};
//Save image
_context.productCategories.Add(category);
await _context.SaveChangesAsync();
return(category.idCategory);
}
public async Task <IActionResult> CreateCategory([FromBody] CategoryCreateRequest request)
{
if (await _context.Categories.CountAsync(x => x.Name.Equals(request.name)) != 0)
{
return(BadRequest("Category name already exist"));
}
var res = await _context.Categories.AddAsync(_mapper.Map <Category>(request));
await _context.SaveChangesAsync();
return(CreatedAtAction(nameof(CreateCategory),
await _context.Categories.ProjectTo <CategoryGetAllResponse>(_mapper.ConfigurationProvider)
.FirstOrDefaultAsync(x => x.Id == res.Entity.Id)));
}
public async Task <IActionResult> Create([FromBody] CategoryCreateRequest request)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var category = await _categoryService.Create(request);
if (!category.IsSuccessed)
{
return(BadRequest(category));
}
return(Ok(category));
}
public async Task <IActionResult> Create([FromForm] CategoryCreateRequest request)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var categoryId = await _categoryService.Create(request);
if (categoryId == 0)
{
return(BadRequest());
}
var category = await _categoryService.GetById(categoryId, request.LanguageId);
return(CreatedAtAction(nameof(GetById), new { id = categoryId }, category));
}
public async Task <IActionResult> Create([FromBody] CategoryCreateRequest request)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState.GetErrorMessages()));
}
try
{
var response = await _categoryService.Add(request);
return(Ok(response));
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
}
public async Task <IActionResult> Create([FromBody] CategoryCreateRequest request)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var categoryId = await _categoriesService.Create(request);
if (categoryId == 0)
{
return(BadRequest());
}
var product = await _categoriesService.GetById(categoryId);
return(Created(nameof(GetById), product));
}
public async Task ValidatePostCategory()
{
var category = new CategoryCreateRequest()
{
CategoryName = "Stadia",
Description = "..."
};
var controller = new CategoriesController(_dbContext);
var result = await controller.PostCategory(category);
var createdAtActionResult = Assert.IsType <CreatedAtActionResult>(result.Result);
var returnValue = Assert.IsType <CategoryVm>(createdAtActionResult.Value);
Assert.Equal("Stadia", returnValue.CategoryName);
Assert.Equal("...", returnValue.Description);
}
public async Task <IActionResult> CreateProduct([FromBody] CategoryCreateRequest category)
{
_logger.LogDebug("START CreateNode");
var categoryResult = await CommandAsync(new CreateCategoryCommand
{
Category = _mapper.Map <CategoryDto>(category)
});
if (!categoryResult.HaveError)
{
return(Created($"categories/{categoryResult.CategoryId.Value}", categoryResult.CategoryId.Value));
}
else
{
return(UnprocessableEntity(categoryResult.Errors));
}
}
public async Task <IActionResult> Create(CategoryCreateRequest request)
{
if (!ModelState.IsValid)
{
return(View(request));
}
request.LanguageId = GetLanguageId();
var result = await _categoryApiCilent.Create(request);
if (result.IsSuccessed)
{
TempData["Result"] = "Tạo mới thành công";
return(RedirectToAction("Index", "Category"));
}
ModelState.AddModelError("", result.Message);
return(View(request));
}
public CategoryCreateResponse Create([FromBody] CategoryCreateRequest request)
{
CategoryCreateResponse response;
if (ModelState.IsValid)
{
response = _categoryService.Add(request);
}
else
{
response = new CategoryCreateResponse()
{
ErrorMessage = "Model state not valid"
};
}
return(response);
}
public async Task <IActionResult> Create([FromForm] CategoryCreateRequest request)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var idCategory = await _categoryService.Create(request);
if (idCategory == null)
{
return(BadRequest());
}
var product = await _categoryService.GetById(idCategory);
return(CreatedAtAction(nameof(GetById), new { id = idCategory }, product));
}
public async Task <CategoryVm> PostCategory(CategoryCreateRequest request)
{
var category = new EcommerceShop.Application.Models.Category
{
Name = request.Name
};
_context.Categories.Add(category);
await _context.SaveChangesAsync();
var categoryVm = new CategoryVm
{
CategoryId = category.CategoryId,
Name = category.Name
};
return(categoryVm);
}
public async Task <IActionResult> Create(CategoryCreateRequest request)
{
if (!ModelState.IsValid)
{
return(View());
}
var result = await _categoryApiClient.Create(request);
if (result == 1)
{
TempData["result"] = "Thêm mới danh mục thành công";
return(RedirectToAction("Index"));
}
ModelState.AddModelError("", "Thêm danh mục thất bại");
return(View(request));
}
public async Task <IActionResult> Create([FromForm] CategoryCreateRequest request)
{
if (!ModelState.IsValid)
{
return(View(request));
}
var result = await _categoryApiClient.CreateProduct(request);
if (result)
{
TempData["result"] = "Thêm mới sản phẩm thành công";
return(RedirectToAction("Index"));
}
ModelState.AddModelError("", "Thêm sản phẩm thất bại");
return(View(request));
}
public async Task <ApiResult <bool> > Create(CategoryCreateRequest request)
{
var query = _mockProjectDbContext.Categories.Any(x => x.Name == request.CategoryName);
if (query)
{
//throw new MockProjectException("Danh mục này đã tồn tại");
return(new ApiErrorResult <bool>());
}
Category category = new Category
{
Name = request.CategoryName
};
_mockProjectDbContext.Add(category);
await _mockProjectDbContext.SaveChangesAsync();
return(new ApiSuccessResult <bool>());
}
public async Task <ApiResult <bool> > Create(CategoryCreateRequest request)
{
var client = _httpClientFactory.CreateClient();
client.BaseAddress = new Uri(_configuration["BaseAddress"]);
var json = JsonConvert.SerializeObject(request);
var httpContent = new StringContent(json, Encoding.UTF8, "application/json");
var response = await client.PostAsync($"/api/category", httpContent);
var result = await response.Content.ReadAsStringAsync();
if (response.IsSuccessStatusCode)
{
return(JsonConvert.DeserializeObject <ApiSuccessResult <bool> >(result));
}
return(JsonConvert.DeserializeObject <ApiErrorResult <bool> >(result));
}
public async Task <IActionResult> PutCategory(int id, [FromBody] CategoryCreateRequest request)
{
var category = await _context.Products.FindAsync(id);
if (category == null)
{
return(NotFound(new ApiNotFoundResponse(_returnString.ReturnString(_localizer["Cannot found Category with ID"], id.ToString()))));
}
var categoryUpdate = _mapper.Map(request, category);
_context.Products.Update(categoryUpdate);
var result = await _context.SaveChangesAsync();
if (result > 0)
{
return(NoContent());
}
return(BadRequest(new ApiBadRequestResponse(_localizer["Create Category is failed"])));
}
public async Task <ApiResult <bool> > Create(CategoryCreateRequest request)
{
var query = from c in _context.Categories
join ct in _context.CategoryTranslations on c.Id equals ct.CategoryId
where ct.LanguageId == request.LanguageId && ct.Name == request.Name
select new { c, ct };
if (query.Count() != 0)
{
return(new ApiErrorResult <bool>("Tên danh mục bị trùng "));
}
Category category = new Category()
{
SortOrder = request.SortOrder,
IsShowOnHome = request.IsShowOnHome,
ParentId = request.ParentId,
Status = request.Status,
CategoryTranslations = new List <CategoryTranslation>()
{
new CategoryTranslation()
{
LanguageId = request.LanguageId,
Name = request.Name,
SeoAlias = request.SeoAlias,
SeoDescription = request.SeoDescription,
SeoTitle = request.SeoTitle
}
},
};
_context.Categories.Add(category);
if (await _context.SaveChangesAsync() == 0)
{
return(new ApiErrorResult <bool>());
}
else
{
return(new ApiSuccessResult <bool>());
}
}
public async Task CategoriesController_Get_Success()
{
var category = new CategoryCreateRequest {
Name = "Test category3"
};
var controller = new CategoriesController(_fixture.CategoryService);
var createResult = await controller.Post(category);
var createResponse = GetResponse <CategoryCreateResponse>(createResult);
Assert.Equal(category.Name, createResponse.Name);
var getResult = await controller.Get(createResponse.Id);
var getResponse = GetResponse <CategoryVm>(getResult);
Assert.Equal(createResponse.Id, getResponse.Id);
Assert.Equal(createResponse.Name, getResponse.Name);
}
public async Task <int> Create(CategoryCreateRequest request)
{
var client = _httpClientFactory.CreateClient();
client.BaseAddress = new Uri(_configuration["BaseAddress"]);
var sessions = _httpContextAccessor.HttpContext.Session.GetString("Token");
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", sessions);
var json = JsonConvert.SerializeObject(request);
var httpContent = new StringContent(json, Encoding.UTF8, "application/json");
var response = await client.PostAsync($"/api/categories", httpContent);
if (response.IsSuccessStatusCode)
{
return(1);
}
return(0);
}
public override async Task <CategoryCreateResponse> CreateCategory(CategoryCreateRequest request, ServerCallContext context)
{
var category = new Category
{
Name = request.Name,
Color = ColorTranslator.FromHtml(request.Color),
CategoryId = request.ParentId
};
if (await _db.InsertAsync(category) == false)
{
throw new Exception("Couldn't insert category");
}
var rowId = _db.LastInsertRowId();
return(new CategoryCreateResponse
{
Category = (await _db.GetAsync <Category>(rowId)).ToRpc()
});
}
