public ActionResult Edit(CategoryCreateDTO req) { Response res = new Response(); if (ModelState.IsValid) { try { if (req.Id > 0) { res.Data = _categoryRepository.Update(req); } else { var currentUser = OperatorProvider.Provider.GetCurrent(); req.R_Company_Id = currentUser.CompanyId.ToInt(); res.Data = _categoryRepository.Create(req); } } catch (Exception ex) { res.Message = ex.Message; } } else { res.Data = false; res.Message = string.Join(",", ModelState .SelectMany(ms => ms.Value.Errors) .Select(e => e.ErrorMessage)); } return(Json(res, JsonRequestBehavior.AllowGet)); }
public async Task <IActionResult> Create([FromBody] CategoryCreateDTO categoryDTO) { var location = GetControllerActionName(); try { logger.LogInfo($"{location}: Create Category"); if (categoryDTO == null) { logger.LogWarn($"{location}: Category object is empty"); return(BadRequest(ModelState)); } if (!ModelState.IsValid) { logger.LogWarn($"{location}: Category object is incomplete"); return(BadRequest(ModelState)); } var category = mapper.Map <Category>(categoryDTO); var isSuccess = await categoryRepository.Create(category); if (!isSuccess) { InternalError($"{location}: Create Category failed"); } logger.LogInfo($"{location}: Create Category successful"); return(Created("Create", new { category })); } catch (Exception e) { return(InternalError($"{location}: {e.Message} - {e.InnerException}")); } }
public async Task <IActionResult> Post([FromBody] CategoryCreateDTO category) { if ((await _unitOfWork.CategoryRepository.Get(x => x.Name == category.Name)) != null) { return(BadRequest("Category with this name already exists!")); } var categoryEntity = _mapper.Map <Category>(category); _unitOfWork.CategoryRepository.Add(categoryEntity); try { if (await _unitOfWork.SaveAll()) { if (await AddManagersToCategory(categoryEntity.Id)) { return(CreatedAtRoute("GetCategory", new { id = categoryEntity.Id }, _mapper.Map <CategorySimpleVM>(categoryEntity))); } else { return(StatusCode(500)); } } } catch (Exception ex) { return(StatusCode(500)); } return(BadRequest("Could not add category")); }
public async Task <IActionResult> Create([FromBody] CategoryCreateDTO categoryDTO) { try { _logger.LogInfo($"Category submission attempted."); if (categoryDTO == null) { _logger.LogWarn($"Empty Request was submitted."); return(BadRequest(ModelState)); } if (!ModelState.IsValid) { _logger.LogWarn($"Category Data was Invalid."); return(BadRequest(ModelState)); } var category = _mapper.Map <Category>(categoryDTO); var isSuccess = await _categoryRepository.Create(category); if (!isSuccess) { return(InternalError($"Category creation failed.")); } _logger.LogInfo("Category created"); return(Created("Create", new { category })); } catch (Exception e) { return(InternalError($"{e.Message} - {e.InnerException}")); } }
public ActionResult Edit(CategoryCreateDTO req) { Response res = new Response(); if (ModelState.IsValid) { try { if (req.Id > 0) { res.Data = CategoryRepository.Update(req); } else { res.Data = CategoryRepository.Create(req); } } catch (Exception ex) { res.Message = ex.InnerException.Message; } } else { res.Data = false; res.Message = string.Join(",", ModelState.SelectMany(ms => ms.Value.Errors).Select(e => e.ErrorMessage)); } return(Json(res, JsonRequestBehavior.AllowGet)); }
public ActionResult <CategoryReadDTO> CreateCategory([FromForm] CategoryCreateDTO categoryCreateDTO) { // SUBE UNA SOLA IMAGEN A UN CAMPO DE TIPO Byte[] en una tabla if (categoryCreateDTO.Files.FileName != null) { using (MemoryStream ms = new MemoryStream()) { categoryCreateDTO.Files.OpenReadStream().CopyTo(ms); // return arreglo de bytes categoryCreateDTO.Picture = ms.ToArray(); } } var categoryModel = _mapper.Map <Categories>(categoryCreateDTO); _repo.CreateCategory(categoryModel); _repo.SaveChanges(); var categoryReadDTO = _mapper.Map <CategoryReadDTO>(categoryModel); // Decodificar base64 online // https://base64.guru/converter/decode/image // https://codebeautify.org/base64-to-image-converter return(CreatedAtRoute(nameof(GetCategoryById), new { id = categoryReadDTO.CategoryId }, categoryReadDTO)); //return Ok(categoryReadDTO); }
public async Task <IActionResult> Update(int id, CategoryCreateDTO categoryCreateDTO) { if (id != categoryCreateDTO.Id) { return(BadRequest("Category to update doesn't exist in database")); } await categoryService.Update(mapper.Map <Category>(categoryCreateDTO)); return(NoContent()); }
public ActionResult CreateCategory(CategoryCreateDTO model) { unitOfWork.CategoryRepository.Create(new Category { Name = model.Name }); unitOfWork.Save(); return(RedirectToAction("Index", "Home")); }
public void CreateCategory(CategoryCreateDTO categoryDto) { if (categoryDto == null) { throw new FileNotFoundException(); } var category = _mapper.Map <Category>(categoryDto); _categoryRepository.CreateCategory(category); }
public async Task <IActionResult> CreateCategory(CategoryCreateDTO categoryCreateDTO) { if (ModelState.IsValid) { var category = _mapper.Map <Category>(categoryCreateDTO); await _categoryService.CreateAsync(category); return(RedirectToAction("Index", "Home")); } return(View(categoryCreateDTO)); }
public async Task <ActionResult> UpdateCategory(int id, CategoryCreateDTO categoryUpdateDTO) { var category = await _categoryRepository.GetByIdAsync(id); if (category == null) { return(NotFound(new ApiResponse(404))); } _mapper.Map(categoryUpdateDTO, category); await _categoryRepository.Update(category); return(NoContent()); }
public async void FindAsync_Trueifcaseincorrect() { var cat = new CategoryCreateDTO { Name = "Programming" }; using (var repository = new CategoryRepository(context)) { var id = await repository.CreateAsync(cat); Assert.NotNull(await repository.FindAsync("programming")); } }
public async void DeleteAsync_FalseIfNotExists() { var cat = new CategoryCreateDTO { Name = "Programming" }; using (var repository = new CategoryRepository(context)) { var id = await repository.CreateAsync(cat); Assert.False(await repository.DeleteAsync(id + 1)); } }
public async void CreateAsync_CheckIfCategoryExists() { var cat = new CategoryCreateDTO { Name = "Programming" }; using (var repository = new CategoryRepository(context)) { var id = await repository.CreateAsync(cat); Assert.NotNull(await context.Categories.FindAsync(id)); } }
public async Task <ActionResult <CategoryDTO> > CreateCategory([FromBody] CategoryCreateDTO categoryCreateDTO) { if (categoryCreateDTO == null) { return(BadRequest(new ApiResponse(400))); } var category = _mapper.Map <Category>(categoryCreateDTO); await _categoryRepository.Create(category); var categoryDTO = _mapper.Map <CategoryDTO>(category); return(CreatedAtRoute(nameof(GetCategoryById), new { Id = categoryDTO.Id }, categoryDTO)); }
public async void DeleteAsync_TrueifExists_ActuallyDeletes() { var cat = new CategoryCreateDTO { Name = "Programming" }; using (var repository = new CategoryRepository(context)) { var id = await repository.CreateAsync(cat); Assert.True(await repository.DeleteAsync(id)); Assert.Equal(0, await context.Categories.CountAsync()); } }
public async Task CreateCategory_WhenInputIsNull_ReturnsBadRequest() { // Arrange var mapper = BuildMap(); var mockRepo = new Mock <ICategoryRepository>(); var controller = new CategoriesController(mockRepo.Object, mapper); CategoryCreateDTO catDTO = null; // Act var response = await controller.CreateCategory(catDTO); // Assert Assert.IsType <BadRequestObjectResult>(response.Result); }
public async Task <int> CreateAsync(CategoryCreateDTO category) { var categoryToCreate = new Category { Name = category.Name }; _context.Categories.Add(categoryToCreate); if (await saveContextChanges() > 0) { return(categoryToCreate.Id); } else { throw new DbUpdateException("Error creating category", (Exception)null); } }
public async Task UpdateCategory_Id_NonExistent_ReturnsNotFound() { // Arrange var mapper = BuildMap(); var mockRepo = new Mock <ICategoryRepository>(); var controller = new CategoriesController(mockRepo.Object, mapper); var catDTO = new CategoryCreateDTO { Name = "Category 1" }; // Act var response = await controller.UpdateCategory(9999, catDTO); // Assert Assert.IsType <NotFoundObjectResult>(response); }
public ActionResult Create(CategoryCreateViewModel model) { if (ModelState.IsValid) { CategoryCreateDTO categoryDTO = Mapper.Map <CategoryCreateViewModel, CategoryCreateDTO>(model); ServiceMessage serviceMessage = service.Create(categoryDTO); if (serviceMessage.Succeeded) { return(RedirectToAction("List")); } else { AddModelErrors(serviceMessage.Errors); } } return(View(model)); }
public async Task CreateCategory_WhenCalled_ReturnsActionResultOfCategoryDTO() { // Arrange var mapper = BuildMap(); var mockRepo = new Mock <ICategoryRepository>(); var controller = new CategoriesController(mockRepo.Object, mapper); var catDTO = new CategoryCreateDTO { Name = "Category 1" }; // Act var response = await controller.CreateCategory(catDTO); // Assert Assert.IsType <ActionResult <CategoryDTO> >(response); }
public async Task UpdateCategory_ReturnsActionResult() { // Arrange var mapper = BuildMap(); var mockRepo = new Mock <ICategoryRepository>(); var controller = new CategoriesController(mockRepo.Object, mapper); var catDTO = new CategoryCreateDTO { Name = "Category 1" }; // Act var response = await controller.UpdateCategory(1, catDTO); // Assert Assert.IsAssignableFrom <ActionResult>(response); }
public async void CreateAsync_GivenNothingCreated_ReturnsERROR_CREATING() { var categoryToCreate = new CategoryCreateDTO { Name = "New Category" }; categoryRepositoryMock.Setup(c => c.FindAsync(categoryToCreate.Name)).ReturnsAsync(default(CategoryDTO)); categoryRepositoryMock.Setup(c => c.CreateAsync(categoryToCreate)).ReturnsAsync(0); using (var logic = new CategoryLogic(categoryRepositoryMock.Object, projectRepositoryMock.Object)) { var response = await logic.CreateAsync(categoryToCreate); Assert.Equal(ResponseLogic.ERROR_CREATING, response); categoryRepositoryMock.Verify(c => c.FindAsync(categoryToCreate.Name)); categoryRepositoryMock.Verify(c => c.CreateAsync(categoryToCreate)); } }
public async void CreateAsync_GivenValidCategory_ReturnsSUCCESS() { var categoryToCreate = new CategoryCreateDTO { Name = "New Category" }; categoryRepositoryMock.Setup(c => c.FindAsync(categoryToCreate.Name)).ReturnsAsync(default(CategoryDTO)); categoryRepositoryMock.Setup(c => c.CreateAsync(categoryToCreate)).ReturnsAsync(1); using (var logic = new CategoryLogic(categoryRepositoryMock.Object, projectRepositoryMock.Object)) { var response = await logic.CreateAsync(categoryToCreate); Assert.Equal(ResponseLogic.SUCCESS, response); categoryRepositoryMock.Verify(c => c.FindAsync(categoryToCreate.Name)); categoryRepositoryMock.Verify(c => c.CreateAsync(categoryToCreate)); } }
public async Task <ResponseLogic> CreateAsync(CategoryCreateDTO category) { var currentCategory = await _repository.FindAsync(category.Name); if (currentCategory != null) { return(ResponseLogic.SUCCESS); } var createdId = await _repository.CreateAsync(category); if (createdId > 0) { return(ResponseLogic.SUCCESS); } else { return(ResponseLogic.ERROR_CREATING); } }
public bool Update(CategoryCreateDTO req) { using (var db = new SqlSugarClient(Connection)) { bool result = true; R_Category model = new R_Category() { Id = req.Id, Name = req.Name, Description = req.Description, DiscountRate = req.DiscountRate, PId = req.Pid, IsDiscount = req.IsDiscount, Sorted = req.Sorted }; result = db.Update(model); return(result); } }
public async void UpdateAsync_GivenCorrectId_ReturnsFalse() { var cat = new CategoryCreateDTO { Name = "Programming" }; var catup = new CategoryDTO { Id = 2, Name = "Sports" }; using (var repository = new CategoryRepository(context)) { var id = await repository.CreateAsync(cat); Assert.False(await repository.UpdateAsync(catup)); } }
public ServiceMessage Create(CategoryCreateDTO categoryDTO) { List <string> errors = new List <string>(); bool succeeded = Validate(categoryDTO.Name, errors); if (succeeded) { try { bool exists = unitOfWork.Categories.Exists(categoryDTO.Name); if (!exists) { CategoryEntity categoryEntity = new CategoryEntity { Name = categoryDTO.Name, IsEnabled = true }; unitOfWork.Categories.Add(categoryEntity); unitOfWork.Commit(); } else { succeeded = false; errors.Add("Category with such name already exists"); } } catch (Exception ex) { ExceptionMessageBuilder.FillErrors(ex, errors); succeeded = false; } } return(new ServiceMessage { Errors = errors, Succeeded = succeeded }); }
public async void CreateAsync_GivenCategoryExists_ReturnsSUCCESS() { var categoryToCreate = new CategoryCreateDTO { Name = "New Category" }; var existingCategory = new CategoryDTO { Id = 1, Name = "New Category" }; categoryRepositoryMock.Setup(c => c.FindAsync(categoryToCreate.Name)).ReturnsAsync(existingCategory); using (var logic = new CategoryLogic(categoryRepositoryMock.Object, projectRepositoryMock.Object)) { var response = await logic.CreateAsync(categoryToCreate); Assert.Equal(ResponseLogic.SUCCESS, response); categoryRepositoryMock.Verify(c => c.FindAsync(categoryToCreate.Name)); categoryRepositoryMock.Verify(c => c.CreateAsync(It.IsAny <CategoryCreateDTO>()), Times.Never()); } }
public CategoryCreateDTO GetModel(int id) { using (var db = new SqlSugarClient(Connection)) { CategoryCreateDTO result = null; var model = db.Queryable <R_Category>().InSingle(id); if (model != null) { result = new CategoryCreateDTO() { Id = model.Id, Name = model.Name, Description = model.Description, DiscountRate = model.DiscountRate, Pid = model.PId, IsDiscount = model.IsDiscount, Sorted = model.Sorted }; } return(result); } }