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