public async Task <IActionResult> Update([FromForm] CreateCategoryRequest request)
{
var message = await categoryService.Update(request);
ShowMessage(message);
return(RedirectToAction("Index"));
}
public async Task <IActionResult> Create(CategoryEditViewModel model)
{
try
{
if (!ModelState.IsValid)
{
return(BadRequest("Invalid ModelState"));
}
var request = new CreateCategoryRequest
{
RouteName = model.RouteName,
Note = model.Note,
DisplayName = model.DisplayName
};
await _categoryService.CreateAsync(request);
DeleteOpmlFile();
return(Json(model));
}
catch (Exception e)
{
Logger.LogError(e, "Error Create Category.");
ModelState.AddModelError("", e.Message);
return(ServerError(e.Message));
}
}
public ResponseMessage CreateCategory(CreateCategoryRequest request)
{
ResponseMessage responseMessage = new ResponseMessage();
try
{
if (string.IsNullOrEmpty(request.Name))
{
responseMessage.Errors.Add("Name is empty or null");
}
else
{
_context.Category.Add(new CategoryEntity {
Name = request.Name
});
_context.SaveChanges();
}
if (!responseMessage.IsOk)
{
return(responseMessage);
}
}
catch (Exception msg)
{
responseMessage.Errors.Add(msg.Message);
}
if (!responseMessage.IsOk)
{
return(responseMessage);
}
return(responseMessage);
}
public CreateCategoryResponse CreateCategory(CreateCategoryRequest request)
{
CreateCategoryResponse res = new CreateCategoryResponse();
string strSP = SqlCommandStore.uspCreateCategory;
try
{
using (SqlCommand cmd = new SqlCommand(strSP))
{
cmd.Parameters.Add("CategoryName", SqlDbType.NVarChar, 100).Value = request.CategoryName;
cmd.Parameters.Add("@Return", SqlDbType.Int).Direction = ParameterDirection.ReturnValue;
DataSet ds = DB.ExecuteSPDataSet(cmd);
res.Code = (ReturnCode)Convert.ToInt32(cmd.Parameters["@Return"].Value);
if (res.Code != ReturnCode.Success)
{
DB.RollBackTran();
return(res);
}
return(res);
}
}
catch (Exception ex)
{
LogWriter.WriteLogException(ex);
res.Code = ReturnCode.Fail;
return(res);
}
}
public void Inventory_Category_UpdateCategory_ShouldGetException_WithDuplicateName()
{
try
{
string otherName = "Name" + Guid.NewGuid();
string otherDescription = "Other description";
CreateCategoryRequest createCategoryRequest = new CreateCategoryRequest(otherName, otherDescription);
ICategoryService service = IoC.Container.Resolve <ICategoryService>();
CreateCategoryResponse otherCategory = service.Create(createCategoryRequest);
UpdateCategoryRequest updateCategoryRequest = new UpdateCategoryRequest()
{
Id = otherCategory.Id,
Name = this.category.Name,
Description = "Description of category updated"
};
this.UpdateCategory(updateCategoryRequest);
Assert.IsTrue(false);
}
catch (ValidationException exception)
{
Assert.IsTrue(exception.HasExceptionKey("inventory.addOrUpdateCategory.validation.nameAlreadyExisted"));
}
}
public async Task <ActionResult> Create([FromBody] CreateCategoryRequest request)
{
try
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState.GetErrorResponse()));
}
var response = await _service.CreateAsync(request);
if (!response.Success)
{
return(BadRequest(response.Erros));
}
return(Ok());
}
catch (ArgumentNullException ex)
{
return(NotFound("Category does not exist"));
}
catch (Exception ex)
{
return(BadRequest(ex));
}
}
public void Category_Create_Ok()
{
// arrange
var context = GetContext();
string categoryName = "Test category", description = "Test";
var home = new Home()
{
Name = "new home"
};
context.Homes.Add(home);
context.SaveChanges();
ICategoryService categoryService = new CategoryService(context);
var request = new CreateCategoryRequest()
{
CategoryEntity = new CategoryEntity()
{
Name = categoryName,
Description = description,
ParentCategoryId = null
},
HomeId = home.Id,
RequestUserId = userIds[0]
};
// act
var actual = categoryService.CreateCategory(request);
var expected = context.Categories.First();
// assert
Assert.NotNull(expected);
Assert.True(actual.IsSuccessful);
}
private CreateCategoryResponse CreateCategoryItem(string name, string desc)
{
CreateCategoryRequest request = new CreateCategoryRequest(name, desc);
ICategoryService service = IoC.Container.Resolve <ICategoryService>();
return(service.Create(request));
}
public async Task <CategoryFullResponce> CreateCategoryAsync(CreateCategoryRequest request)
{
if (!m_authService.IsAuthUser())
{
throw new AuthenticationException();
}
if (!m_authService.AuthUserInRole(Roles.AdminRoleName))
{
throw new UserNotAdminException();
}
if (await m_db.Categories.AnyAsync(x => x.Name == request.Name))
{
throw new CategoryNameAlreadyExistException();
}
if (request.IsNode)
{
return(await CreateCategoryNodeAsync(request));
}
else
{
return(await CreateCategoryLeafAsync(request));
}
}
public IActionResult Create(CategoryEditViewModel model)
{
try
{
if (ModelState.IsValid)
{
var request = new CreateCategoryRequest
{
Title = model.Name,
Note = model.Note,
DisplayName = model.DisplayName
};
var response = _categoryService.CreateCategory(request);
if (response.IsSuccess)
{
DeleteOpmlFile();
return(RedirectToAction(nameof(Manage)));
}
Logger.LogError($"Create category failed: {response.Message}");
ModelState.AddModelError("", response.Message);
return(View("CreateOrEdit", model));
}
return(View("CreateOrEdit", model));
}
catch (Exception e)
{
Logger.LogError(e, "Error Create Category.");
ModelState.AddModelError("", e.Message);
return(View("CreateOrEdit", model));
}
}
public Response CreateCategory(CreateCategoryRequest createCategoryRequest)
{
return(TryExecute(() =>
{
var exists = _categoryRepository.Any(c => c.Title == createCategoryRequest.Title);
if (exists)
{
return new Response {
Message = $"CategoryEntity titled {createCategoryRequest.Title} already exists."
};
}
var category = new CategoryEntity
{
Id = Guid.NewGuid(),
Title = createCategoryRequest.Title,
Note = createCategoryRequest.Note,
DisplayName = createCategoryRequest.DisplayName
};
Logger.LogInformation("Adding new categoryEntity to database.");
_categoryRepository.Add(category);
return new SuccessResponse();
}));
}
public async Task <CreateCategoryResponse> CreateCategory(CreateCategoryRequest request, CancellationToken cancellationToken)
{
var userId = await _identityService.GetCurrentIdentityUserId(cancellationToken);
var checkRole = await _identityService.IsInIdentityUserRole(new IsInIdentityUserRoleRequest()
{
Id = userId.Id, Role = RoleConstants.AdminRole
});
if (!checkRole.IsInRole)
{
throw new NoRightsToAddCategoryException("У пользователя нет прав на добавление категории");
}
if (request.ParentCategoryId != null)
{
var parentCategory = await _repository.FindById(request.ParentCategoryId, cancellationToken);
if (parentCategory == null)
{
throw new NotFoundCategoryException(request.ParentCategoryId ?? Guid.Empty);
}
}
var category = _mapper.Map <Domain.Category>(request);
await _repository.Save(category, cancellationToken);
return(_mapper.Map <CreateCategoryResponse>(category));
}
public Task <Response> CreateAsync(CreateCategoryRequest createCategoryRequest)
{
return(TryExecuteAsync(async() =>
{
var exists = _categoryRepository.Any(c => c.RouteName == createCategoryRequest.RouteName);
if (exists)
{
return new Response {
Message = $"CategoryEntity titled '{createCategoryRequest.RouteName}' already exist."
};
}
var category = new CategoryEntity
{
Id = Guid.NewGuid(),
RouteName = createCategoryRequest.RouteName.Trim(),
Note = createCategoryRequest.Note.Trim(),
DisplayName = createCategoryRequest.DisplayName.Trim()
};
await _categoryRepository.AddAsync(category);
await _moongladeAudit.AddAuditEntry(EventType.Content, AuditEventId.CategoryCreated, $"Category '{category.RouteName}' created");
return new SuccessResponse();
}));
}
public ResponseMessage UpdateCategory(UpdateCategoryRequest request)
{
var response = new CreateCategoryRequest();
try
{
var category = _context.Category.FirstOrDefault(x => x.Id == request.Id);
if (category == null)
{
response.Errors.Add("The category is null");
}
else
{
category.Name = request.Name;
_context.SaveChanges();
}
if (!response.IsOk)
{
return(response);
}
}
catch (Exception msg)
{
response.Errors.Add(msg.Message);
}
if (!response.IsOk)
{
return(response);
}
return(response);
}
public async Task <MessageResponse> Update(CreateCategoryRequest request)
{
try
{
using (UnitOfWork uow = new UnitOfWork())
{
Category category = await uow.Categories.GetAsync(request.Id);
category.Name = request.Name;
category.Description = request.Description;
if (request.ThumbnailImage != null)
{
category.ImagePath = await fileService.UploadFileAsync(request.ThumbnailImage);
}
category.Id = request.Id;
uow.Categories.Update(category);
await uow.SaveAsync();
return(new MessageResponse("success", "Cập nhật thành công"));
}
}
catch (Exception e)
{
return(new MessageResponse("error", "Cập nhật thất bại", "Lỗi: " + e.Message));
}
}
public ActionResult Create(CreateCategoryViewModel model)
{
var categoryService = new CategoryService();
if (ModelState.IsValid)
{
var request = new CreateCategoryRequest
{
Title = model.Title,
Summary = model.Summary,
Description = model.Description,
IdUpperCategory = model.IdUpperCategory
};
var result = categoryService.CreateCategory(request);
return(RedirectToAction("Index", "Category"));
}
var categories = categoryService.SearchCategories(new SearchCategoriesRequest()).Categories;
ViewBag.Categories = categories.Select(x => new SelectListItem()
{
Text = x.Title,
Value = x.Id.ToString()
});
return(View(model));
}
public bool Add(CreateCategoryRequest request)
{
var factory = new ConnectionFactory()
{
HostName = "localhost",
UserName = "******",
Password = "******"
};
var connection = factory.CreateConnection();
var channel = connection.CreateModel();
channel.QueueDeclare(
queue: "CategoryQueue",
durable: false,
exclusive: false,
autoDelete: false,
arguments: null
);
var message = JsonConvert.SerializeObject(request);
var body = Encoding.UTF8.GetBytes(message);
channel.BasicPublish(
exchange: "",
routingKey: "CategoryQueue",
basicProperties: null,
body: body
);
return(true);
}
public static Category ToCategoryModel(this CreateCategoryRequest request)
{
return(new Category
{
Name = request.Name
});
}
public async Task <ApiResult <bool> > Create(CreateCategoryRequest request)
{
try
{
if (request.parent_id == null)
{
request.parent_id = 0;
}
else
{
request.parent_id = request.parent_id;
}
var cate = new TechShopSolution.Data.Entities.Category
{
cate_name = request.cate_name,
parent_id = request.parent_id,
meta_descriptions = request.meta_descriptions,
meta_keywords = request.meta_keywords,
meta_title = request.meta_title,
cate_slug = request.cate_slug,
ProductInCategory = new List <Data.Entities.CategoryProduct>(),
isActive = request.isActive,
isDelete = false,
create_at = DateTime.Now
};
_context.Categories.Add(cate);
await _context.SaveChangesAsync();
return(new ApiSuccessResult <bool>());
}
catch
{
return(new ApiErrorResult <bool>("Thêm thất bại"));
}
}
public async Task <IActionResult> Create([FromBody] CreateCategoryRequest CategoryRequst)
{
var category = new Category
{
ArabicName = CategoryRequst.ArabicName,
EnglishName = CategoryRequst.EnglishName,
ImageUrl = CategoryRequst.ImageUrl,
Status = CategoryRequst.Status
};
var status = await _CategoryService.CreateCategoryAsync(category);
if (status == -1)
{
return(Conflict(new ErrorResponse
{
message = "Dublicate Entry",
status = Conflict().StatusCode
}));
}
if (status == 1)
{
var response = new CategoryResponse {
Id = category.Id
};
return(Ok(response));
}
return(NotFound(new ErrorResponse
{
message = "Not Found",
status = NotFound().StatusCode
}));
}
public CreateCategoryResponse CreateCategory(CreateCategoryRequest request)
{
var response = new CreateCategoryResponse();
if (request.HomeId == 0)
{
response.AddError(Language.Resources.Category_HomeIsMandatory);
}
else
{
var existingCategory = context.Categories.Where(category => category.HomeId == request.HomeId && category.Name == request.CategoryEntity.Name && category.ParentCategoryId == request.CategoryEntity.ParentCategoryId);
if (existingCategory != null && existingCategory.Count() > 0)
{
response.AddError(Language.Resources.Category_SameNameExists);
}
}
if (response.IsSuccessful)
{
var category = CreateNewObject();
category.Name = request.CategoryEntity.Name;
category.Description = request.CategoryEntity.Description;
category.ParentCategoryId = request.CategoryEntity.ParentCategoryId;
category.HomeId = request.HomeId;
context.Categories.Add(category);
context.SaveChanges();
}
return(response);
}
public CreateCategoryResponse CreateCategory(CreateCategoryRequest request)
{
CreateCategoryResponse response = new CreateCategoryResponse();
Category category = new Category();
category.CategoryName = request.CategoryName;
category.Description = request.Description;
category.Picture = request.Picture;
category.Products = request.Products.ConvertToProducts();
if (category.GetBrokenRules().Count() > 0)
{
response.Errors = category.GetBrokenRules().ToList();
}
else
{
try {
_categoryRepository.Add(category);
_uow.Commit();
response.Errors = new List <BusinessRule>();
} catch (Exception ex)
{
List <BusinessRule> errors = new List <BusinessRule>();
do
{
errors.Add(new BusinessRule("DAL", "DAL_ERROR: " + ex.Message));
ex = ex.InnerException;
} while (ex != null);
response.Errors = errors;
}
}
return(response);
}
public ApiResponse <CreateCategoryRequest, Categories> Post([FromBody] CreateCategoryRequest request)
{
var validate = _createValidations.Validate(request);
if (!validate.IsValid)
{
Log.Error(validate.ToString(""));
return(new ApiResponse <CreateCategoryRequest, Categories>()
{
status = false,
error_code = "validations_error",
error_message = validate.ToString("~"),
request = request
});
}
var response = _repository.Create(request);
Log.Information("Category added...");
_queueRepository.Add(request);
Log.Information("Category queue added...");
_queueRepository.Read();
return(new ApiResponse <CreateCategoryRequest, Categories>()
{
status = true,
request = request,
response = response
});
}
public async Task <CreateCategoryResult> CreateCategoryFromRequestAsync(
[FromBody] CreateCategoryRequest request,
CancellationToken cancellationToken = default(CancellationToken))
{
AutoResetEvent resetEvent = new AutoResetEvent(false);
CreateCategoryResult result = null;
_domainEvents.Register("CreateCategoryFromRequestAsync", (CreateCategoryEvent e) =>
{
result = new CreateCategoryResult(request.RequestId, e);
if (result.IsSuccessful)
{
resetEvent.Set();
}
});
var command = request.GetCommand();
await _circuitBreaker.ExecuteAsync(async() =>
await _categoryCommandHandler.ExecuteAsync(command, cancellationToken)
, cancellationToken);
resetEvent.WaitOne(10000);
_domainEvents.Unregister("CreateCategoryFromRequestAsync");
return(result);
}
public async Task <IActionResult> Create([FromBody] CreateCategoryRequest model)
{
var createdCategoryUserId = int.Parse(HttpContext.GetUserIdFromRequest());
var categoryEntity = _mapper.Map <Category>(model);
var isCreateCategorySuccess = await _categoryService.CreateAsync(categoryEntity, createdCategoryUserId);
if (!isCreateCategorySuccess)
{
return(BadRequest(
new CreateCategoryFailResponse
{
Errors = new[] { "Tạo loại sản phẩm không thành công" }
}));
}
var categoryLocationUri = _uriService.GetByIdUri(
ApiRoutes.Category.GetById.Replace("{categoryId}", categoryEntity.Id.ToString()));
var categoryResponse = _mapper.Map <CategoryResponse>(categoryEntity);
return(Created(
categoryLocationUri,
new Response <CategoryResponse>(categoryResponse)));
}
public async Task <IActionResult> CreateCategory([FromBody] CreateCategoryRequest request)
{
// validate input
if (!ModelState.IsValid)
{
return(HttpResult.BadRequest(ModelState));
}
// check for existing category
var foundTagCategory = await _bagsContext.TagCategories
.Where(category => category.Name == request.Name)
.SingleOrDefaultAsync();
if (foundTagCategory != null)
{
return(HttpResult.Ok(foundTagCategory.ToBaseWireFormat()));
}
// create a new tag
var newTagCategory = new Models.TagCategory {
Name = request.Name
};
_bagsContext.TagCategories.Add(newTagCategory);
await _bagsContext.SaveChangesAsync();
return(HttpResult.Ok(newTagCategory.ToBaseWireFormat()));
}
public async Task <IActionResult> CreateCategory(CreateCategoryRequest createCategory)
{
var created = await this.categoryService.CreateCategory(createCategory);
var location = created.Id;
return(this.Created(location, created));
}
public Categories Create(CreateCategoryRequest request)
{
var added = request.Adapt <Categories>();
_context.Categories.Add(added);
_context.SaveChanges();
return(added);
}
public IHttpActionResult CreateCategory(CreateCategoryRequest request)
{
var command = _mapper.Map <CreateCategoryCommand>(request);
_commandBus.Send(command);
return(Ok());
}
public static Category ConvertToCategory(this CreateCategoryRequest createRequest)
{
Category category = new Category();
category.Name = createRequest.Name;
return(category);
}
