public async Task <ActionResult> Create(CategoryRequest categoryRequest)
{
if (categoryRequest.Name != null)
{
var Token = HttpContext.Session.GetString("Token");
if (_userClient.CheckToken(Token, User.Identity.Name) == null)
{
return(Redirect("/Administration/Home/Login"));
}
else
{
if (Token == null)
{
Token = await _userClient.CheckToken(Token, User.Identity.Name);
}
}
var result = await _categoryApi.Create(Token, categoryRequest);
if (result > 0)
{
return(Redirect("Index"));
}
}
return(View());
}
public async Task AddCategory_Success_When_Value_Valid()
{
//Arrange
var dbContext = _fixture.Context;
CategoryRequest item = new CategoryRequest {
CategoryName = "Comic", CategoryDescription = "Comic is ..."
};
var categoryService = new CategoryRepo(dbContext);
var categoriesController = new CategoryController(categoryService);
var CountInitial = await categoriesController.Get();
var valueExpect = CountInitial.Count() + 1;
//Act
var result = await categoriesController.Create(item);
//Assert
var okObjectResult = result.Result as OkObjectResult;
var valueAfter = await categoriesController.Get();
var resultValue = Assert.IsType <Category>(okObjectResult.Value);
Assert.Equal(resultValue.CategoryName, item.CategoryName);
Assert.Equal(resultValue.CategoryDescription, item.CategoryDescription);
Assert.Equal(valueExpect, valueAfter.Count());
}
public IHttpActionResult AddCategory()
{
try
{
CategoryRequest categoryRequest = CreateCategoryRequest(MAN_CATEGORY_ID, "Vestimenta Hombre");
categoryService.AddCategory(categoryRequest);
categoryRequest = CreateCategoryRequest(WOMAN_CATEGORY_ID, "Vestimenta Mujer");
categoryService.AddCategory(categoryRequest);
ControllerResponse response = ControllerHelper.CreateSuccessResponse("Categorías agregadas correctamente");
response.Data = categoryService.GetAllActiveCategories();
return(Ok(response));
}
catch (BadRequestException e)
{
return(BadRequest(e.Message));
}
catch (RepositoryException e)
{
return(CreateBadResponse(e.Message));
}
catch (OperationException e)
{
return(InternalServerError(e));
}
catch (Exception)
{
return(CreateBadResponse("Ocurrió un error al realizar operación"));
}
}
public async Task <ActionResult> Edit(CategoryRequest categoryRequest)
{
if (ModelState.IsValid)
{
var Token = HttpContext.Session.GetString("Token");
if (_userClient.CheckToken(Token, User.Identity.Name) == null)
{
return(Redirect("/Administration/Home/Login"));
}
else
{
if (Token == null)
{
Token = await _userClient.CheckToken(Token, User.Identity.Name);
}
}
var result = await _categoryApi.Update(Token, categoryRequest);
if (result > 0)
{
return(Content("Success"));
}
}
return(Redirect("Index"));
}
public object Any(BroadCategoryBookSearchRequest request)
{
var q = AutoQuery.CreateQuery(request, base.Request);
if (q.Params.Count < 1)
{
q.Where(x => 1 == 1);
}
var authorRequest = new AuthorRequestOr();
var authorAuto = AutoQuery.CreateQuery(authorRequest, base.Request)
.Join <BookAuthor>()
.Select <BookAuthor>(x => x.BookId)
.ClearLimits();
var catRequest = new CategoryRequest();
var catAuto = AutoQuery.CreateQuery(catRequest, base.Request)
.Join <BookCategory>()
.Select <BookCategory>(x => x.BookId)
.ClearLimits();
if (authorAuto.Params.Count > 0)
{
q.Or <Book>(x => Sql.In(x.Id, authorAuto));
}
if (catAuto.Params.Count > 0)
{
q.And <Book>(x => Sql.In(x.Id, catAuto));
}
var results = AutoQuery.Execute(request, q);
return(results);
}
public async Task <CategoryResponse> Add(CategoryRequest request)
{
CategoryResponse response = new CategoryResponse();
try
{
Category category = new Category();
if (!(await iCategory.IsDuplicate(request.CategoryName)))
{
category.CategoryName = request.CategoryName;
category.Description = request.Description;
category.Created = DateTime.Now;
category.CreatedBy = request.CurrentLogin;
category.RowStatus = true;
if (await iCategory.Add <Category>(category))
{
return(response);
}
response.Message = "Failed to Add Category";
response.IsSuccess = false;
}
else
{
response.Message = "Category is Duplicated with existing";
response.IsSuccess = false;
}
}
catch (Exception ex)
{
response.IsSuccess = false;
response.Message = "Something Error in Our System : " + ex.Message;
}
return(response);
}
public async Task <GlobalResponse> Add(Guid businessId, CategoryRequest request)
{
var business = await DbContext.Businesses.Include(x => x.Categories).FirstOrDefaultAsync(x => x.Id == businessId);
if (business is null)
{
throw new KeyNotFoundException("Business not found");
}
var check = business.Categories.FirstOrDefault(x => string.Equals(x.Name, request.Name, StringComparison.CurrentCultureIgnoreCase));
if (!(check is null))
{
throw new AppException("Category already exist");
}
var category = new Category()
{
Name = request.Name
};
business.Categories.Add(category);
DbContext.Update(business);
await DbContext.SaveChangesAsync();
return(new GlobalResponse()
{
Message = "Successful", Status = true
});
}
public Category CreateCategory(CategoryRequest request)
{
string loggedUser = _httpContextAccessor.HttpContext.User.FindFirstValue("userId");
List <Category> categories = dbContext
.Categories
.Where(s => s.Name == request.Name && s.PersonId.Equals(loggedUser))
.ToList <Category>();
Category aCategory;
if (categories.Count == 0)
{
aCategory = new Category(
request.Name,
request.Nonedit,
loggedUser,
request.Icon);
dbContext.Add(aCategory);
dbContext.SaveChanges();
}
else
{
aCategory = categories.First <Category>();
}
return(aCategory);
}
public async Task <IActionResult> PutCategory(int id, CategoryRequest category)
{
if (category == null || id != category.Id)
{
return(BadRequest());
}
(int ResultAction, CategoryResponse UpdatedEntity)result = (-1, null);
try
{
result = await _categoryServices.UpdateCategoryAsync(id, category);
}
catch (DbUpdateConcurrencyException)
{
if (!CategoryExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(Ok(result.UpdatedEntity));
//return NoContent();
}
public static Category FromCreateRequest(CategoryRequest request)
{
return(new Category
{
Name = request.Name
});
}
public IHttpActionResult RemoveCategory(CategoryRequest categoryRequest)
{
try
{
ControllerHelper.ValidateUserRole(Request, new string[] { ESportUtils.ADMIN_ROLE });
categoryService.RemoveCategory(categoryRequest);
return(CreateSuccessResponse("La categoría se eliminó satisfactoriamente"));
}
catch (BadRequestException e)
{
return(CreateBadResponse(e.Message));
}
catch (RepositoryException e)
{
return(CreateBadResponse(e.Message));
}
catch (OperationException e)
{
return(CreateBadResponse(e.Message));
}
catch (Exception)
{
return(CreateBadResponse("Ocurrió un error al eliminar la categoría"));
}
}
private async Task FullOutModel <TModel, TPage>(TModel viewModel) where TModel : PageViewModel <TPage> where TPage : PageData
{
viewModel.CartApiUrl = "/cart";
viewModel.CartUrl = "/en/shooping-cart/";
var currentMarket = _currentMarket.GetCurrentMarket();
var markets = _marketService.GetAllMarkets();
var maketsSelector = new List <SelectEntry>();
foreach (var market in markets)
{
foreach (var currencie in market.Currencies)
{
var code = MarketCurrency.Create(market.MarketId.Value, currencie.CurrencyCode);
maketsSelector.Add(new SelectEntry()
{
DisplayName = $"{market.MarketName} - {currencie.CurrencyCode}", Selected = market.MarketId.Value == currentMarket.MarketId.Value, Key = code.ToString()
});
}
}
viewModel.Markets = maketsSelector;
var bugerMenu = await _mediator.Send(CategoryRequest.Create(_menuSettings.MovieFolder));
viewModel.Categories = bugerMenu.CategoryEntries.Select(x => new MenuItem()
{
Link = x.Link, Title = x.Title
});
}
public async Task <CategoriesVM> CreateCategory(CategoryRequest categoryReq)
{
var category = new Category
{
Name = categoryReq.Name
};
await _context.Categories.AddAsync(category);
await _context.SaveChangesAsync();
{
var Name = categoryReq.Name;
var imageUrl = await UploadImage(categoryReq.pathImage);
category.pathImage = await UploadImage(categoryReq.pathImage);
// var newImage = new Image
// {
// Id = category.Id,
// pathImage = imageUrl,
// };
// await _context.Image.AddAsync(newImage);
await _context.SaveChangesAsync();
}
var categoryResponse = _mapper.Map <CategoriesVM>(category);
return(categoryResponse);
}
public async Task <IActionResult> PostCategory([FromBody] CategoryRequest item)
{
var category = item.ToDataModel();
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
_context.Categories.Add(category);
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateException ex)
{
if (CategoryExists(category.Id))
{
return(new StatusCodeResult(StatusCodes.Status409Conflict));
}
else
{
throw;
}
}
return(CreatedAtAction("GetCategory", new { id = category.Id }, category.ToApiModel()));
}
public async Task <object> EditCategory(CategoryRequest request)
{
if (!ModelState.IsValid)
{
return(JsonResults.Error(400, ModelState.Values.FirstOrDefault().Errors.FirstOrDefault().ErrorMessage.ToString()));
}
try
{
var category = await _categoryService.GetCategory(request.Id);
if (category == null)
{
return(JsonResults.Error(404, "It`s category not found"));
}
category.Name = request.Name;
await _categoryService.UpdateCategory(category);
return(JsonResults.Success());
}
catch (Exception ex)
{
return(JsonResults.Error(400, ex.Message));
}
}
public async Task <CategoriesVM> Updatecategory(int Id, CategoryRequest categoryReq)
{
var existCategory = await _context.Categories.FindAsync(Id);
existCategory.Name = categoryReq.Name;
if (categoryReq.pathImage is not null)
{
var imageUrl = await UploadImage(categoryReq.pathImage);
existCategory.pathImage = await UploadImage(categoryReq.pathImage);
// var newImage = new Image
// {
// ProductId = existCategory.Id,
// pathImage = imageUrl,
// };
// await _context.Image.AddAsync(newImage);
}
await _context.SaveChangesAsync();
var productRes = _mapper.Map <CategoriesVM>(existCategory);
return(productRes);
}
public IHttpActionResult AddProductOnCategory(CategoryRequest categoryRequest)
{
try
{
ControllerHelper.ValidateUserRole(Request, new string[] { ESportUtils.ADMIN_ROLE });
categoryService.AddProductOnCategory(categoryRequest);
return(CreateSuccessResponse("El producto se agrego a la categoria satisfactoriamente"));
}
catch (BadRequestException e)
{
return(CreateBadResponse(e.Message));
}
catch (RepositoryException e)
{
return(CreateBadResponse(e.Message));
}
catch (OperationException e)
{
return(CreateBadResponse(e.Message));
}
catch (Exception)
{
return(CreateBadResponse("Ocurrió un error al agregar producto en categoría"));
}
}
public async Task <IActionResult> Create(CategoryRequest resource)
{
var response = new SingleModelResponse <CategoryRequest>();
if (resource == null)
{
response.DidError = true;
response.ErrorMessage = ResponseMessageConstants.NotFound;
return(response.ToHttpResponse());
}
try
{
var entity = new CategoryRequest();
_mapper.Map(resource, entity);
var entityAdded = await _repository.AddAsync(entity);
response.Model = _mapper.Map(entityAdded, resource);
response.Message = ResponseMessageConstants.Success;
}
catch (Exception ex)
{
response.DidError = true;
response.ErrorMessage = ex.ToString();
_logger.LogError(ex.InnerException.ToString());
}
return(response.ToHttpResponse());
}
public HttpResponseMessage GetProductCategoriesByStoreId(CategoryRequest <string> request)
{
List <ProductCategoryAPIViewModel> productCategories = new List <ProductCategoryAPIViewModel>();
HttpResponseMessage httpResponseMessage = new HttpResponseMessage()
{
StatusCode = HttpStatusCode.OK
};
BaseResponse <List <ProductCategoryAPIViewModel> > response = new BaseResponse <List <ProductCategoryAPIViewModel> >();
try
{
ProductCategoryDomain domain = new ProductCategoryDomain();
response = domain.GetProductCategoriesByRequest(request);
}
catch (ApiException e)
{
httpResponseMessage.StatusCode = e.StatusCode;
response = BaseResponse <List <ProductCategoryAPIViewModel> > .Get(e.Success, e.ErrorMessage, null, e.ErrorStatus);
}
catch (Exception ex)
{
httpResponseMessage.StatusCode = HttpStatusCode.InternalServerError;
response = BaseResponse <List <ProductCategoryAPIViewModel> > .Get(false, "ProductCategoryException: " + ex.ToString(), null, ResultEnum.InternalError);
}
httpResponseMessage.Content = new JsonContent(response);
return(httpResponseMessage);
}
public ActionResult <Category> Post(CategoryRequest request)
{
string loggedUser = User.FindFirstValue("userId");
if (loggedUser == null)
{
return(Unauthorized());
}
try
{
Category category = categoriesService.CreateCategory(request);
if (category == null)
{
return(StatusCode(500));
}
return(CreatedAtAction(nameof(Get), null, category));
}
catch (SkrillaApiException e)
{
if ("not_found".Equals(e.Code))
{
return(NotFound());
}
else
{
return(BadRequest(e.Message));
}
}
}
public async Task <ActionResult <bool> > Update(int id, CategoryRequest categoryRequest)
{
var userId = HttpContext.GetUserId();
if (categoryRequest == null)
{
return(BadRequest(false));
}
var category = await _walletContext.Categories.FindAsync(id);
if (category == null)
{
return(NotFound(false));
}
if (category.UserId != userId)
{
return(Forbid());
}
category.Name = categoryRequest.Name;
var response = await _walletContext.SaveChangesAsync();
return(Ok(response > 0 ? true : (ActionResult <bool>)false));
}
public IActionResult CreateUpdate(CategoryRequest request)
{
bool response = false;
if (request.Id > 0)
{
response = _proxy.UpdateCategory(request.Id, request);
if (response)
{
return(Redirect("/category/list"));
}
}
else
{
response = _proxy.CreateCategory(request);
if (response)
{
return(Redirect("/category/list"));
}
}
ViewBag.Message = (!response)?"Bad Request": string.Empty;
return(View(request));
}
public async Task <IActionResult> AddCategory([FromBody] CategoryRequest request)
{
if (request == null)
{
return(UnprocessableEntity(Constants.ErrorMessages.UnprocessableEntity));
}
if (string.IsNullOrWhiteSpace(request.Name))
{
return(BadRequest(Constants.ErrorMessages.EmptyProductTypeName));
}
if (_context.Categories.Any(pt => pt.Name == request.Name))
{
return(BadRequest(Constants.ErrorMessages.ProductTypeAlreadyExists));
}
Category productType = request.MapToEntity();
var entry = _context.Categories.Add(productType);
try { await _context.SaveChangesAsync(); }
catch (Exception) { return(this.InternalServerError()); }
var response = entry.Entity.MapToResponse();
return(Ok(response));
}
public CategoryResponse GetCategoryById([FromBody] CategoryRequest categoryRequest)
{
CategoryResponse response;
try
{
CategoryResponse Authenticated = Authentication.CheckAuthentication(categoryRequest.Authentication.Email, categoryRequest.Authentication.Password);
if (Authenticated != null)
{
return(Authenticated);
}
Category _category = _categoryService.GetById(categoryRequest.Category.Id);
return(CreateResponse.ReturnResponse(_category));
}
catch (Exception exception)
{
return(response = new CategoryResponse()
{
status = new Models.Attribute.Status()
{
Code = (int)Enums.MessageCode.Error,
Message = Enums.MessageCode.Error.ToString() + exception.Message
}
});
}
}
public IHttpActionResult GetProductsByCategoryId(string categoryId)
{
try
{
CategoryRequest request = new CategoryRequest();
request.CategoryId = categoryId;
List <FullProductDTO> result = categoryService.GetProductsByCategoryId(request);
ControllerResponse response = ControllerHelper.CreateSuccessResponse("Productos para categoria");
response.Data = result;
return(Ok(response));
}
catch (BadRequestException e)
{
return(CreateBadResponse(e.Message));
}
catch (RepositoryException e)
{
return(CreateBadResponse(e.Message));
}
catch (OperationException e)
{
return(CreateBadResponse(e.Message));
}
catch (Exception)
{
return(CreateBadResponse("Ocurrió un error al eliminar producto"));
}
}
public Response <Category> Create(CategoryRequest request)
{
try
{
var messages = request.Validate();
if (messages != null && messages.Count > 0)
{
return(ResponseBadRequest(messages.ToList()));
}
_repoCategory.Add(new Category
{
Description = request.Description,
Name = request.Name
});
return(ResponseSuccess(null));
}
catch (Exception ex)
{
_logger.LogError(ex, $"Exception Method {nameof(CategoryBL)}.{nameof(Create)}");
return(ResponseFail());
}
}
public CategoryControllerTest()
{
LoginContext.GetInstance().Reset();
categoryRequest = new CategoryRequest {
CategoryId = "1"
};
}
public async Task <ActionResult <CategoryResponse> > Create([FromBody] CategoryRequest inputModel)
{
if (this.User.IsInRole(GlobalConstants.AdministratorRoleName))
{
//var categorie = this.categoriesService.GetByName<CategoryResponse>(inputModel.Name);
//if (categorie != null)
//{
// return BadRequest(new BadRequest
// {
// Message = "This category allready exist!"
// }); ;
//}
if (!this.ModelState.IsValid)
{
return(BadRequest());
}
var categorieId = await this.categoriesService.CreateAsync(inputModel.Name);
return(new CategoryResponse {
Id = categorieId
});
}
return(Unauthorized());
}
public async Task <ReturnResponse> CreateCategory(CategoryRequest categoryRequest)
{
if (categoryRequest == null)
{
return(new ReturnResponse()
{
StatusCode = Utils.ObjectNull,
StatusMessage = Utils.StatusMessageObjectNull
});
}
if (string.IsNullOrWhiteSpace(categoryRequest.CategoryName))
{
return(new ReturnResponse()
{
StatusCode = Utils.ObjectNull,
StatusMessage = Utils.StatusMessageObjectNull
});
}
var categoryToCreate = _mapper.Map <Category>(categoryRequest);
var creationResult = _globalRepository.Add(categoryToCreate);
if (!creationResult)
{
return(new ReturnResponse()
{
StatusCode = Utils.NotSucceeded,
StatusMessage = Utils.StatusMessageNotSucceeded
});
}
var saveResult = await _globalRepository.SaveAll();
if (!saveResult.HasValue)
{
return(new ReturnResponse()
{
StatusCode = Utils.SaveError,
StatusMessage = Utils.StatusMessageSaveError
});
}
if (!saveResult.Value)
{
return(new ReturnResponse()
{
StatusCode = Utils.SaveNoRowAffected,
StatusMessage = Utils.StatusMessageSaveNoRowAffected
});
}
return(new ReturnResponse()
{
StatusCode = Utils.Success,
StatusMessage = Utils.StatusMessageSuccess,
ObjectValue = categoryToCreate
});
}
public async Task <IReadOnlyList <Category> > GetAllGenresAsync(CategoryRequest request)
{
Requires.ArgumentNotNull(request, nameof(request));
var root = await _halClient.GetRootAsync().ConfigureAwait(_halClient);
return(await _halClient.GetAllPagesAsync <Category>(root.GenresLink, request).ConfigureAwait(_halClient));
}
