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); }