private async Task <bool> CategoryExists(int Id, CancellationToken cancellationToken)
{
var getCategory = new GetCategoryRequest(Id);
var category = await _categoryService.GetCategoryAsync(getCategory);
return(category != null);
}
public ActionResult <GetCategoryResponse> GetCategory(long id)
{
var getCategoryRequest = new GetCategoryRequest();
getCategoryRequest.Id = id;
return(categoryService.GetCategory(getCategoryRequest));
}
public JsonResult Update(ProductDetailView vm)
{
GetProductRequest request = new GetProductRequest();
request.ProductID = vm.ProductID;
ModifyProductRequest updateRequest = _productService.GetProduct(request).Product.ConvertToModifyProductRequest();
updateRequest.ProductID = vm.ProductID;
updateRequest.ProductName = vm.ProductName;
GetSupplierRequest supplierRequest = new GetSupplierRequest();
supplierRequest.SupplierID = vm.SupplierSupplierID;
updateRequest.Supplier = _supplierService.GetSupplier(supplierRequest).Supplier;
GetCategoryRequest categoryRequest = new GetCategoryRequest();
categoryRequest.CategoryID = vm.CategoryCategoryID;
updateRequest.Category = _categoryService.GetCategory(categoryRequest).Category;
updateRequest.QuantityPerUnit = vm.QuantityPerUnit;
updateRequest.UnitPrice = vm.UnitPrice;
updateRequest.UnitsInStock = vm.UnitsInStock;
updateRequest.UnitsOnOrder = vm.UnitsOnOrder;
updateRequest.ReorderLevel = vm.ReorderLevel;
updateRequest.Discontinued = vm.Discontinued;
ModifyProductResponse response = _productService.ModifyProduct(updateRequest);
return(Json(response));
}
public async Task <List <Categories> > GetCategories(GetCategoryRequest filter)
{
var query = GetCategoryQuery(filter);
var result = await query.ToListAsync();
return(result);
}
public GetCategoryResponse Get(GetCategoryRequest request)
{
var query = repository.AsQueryable<Module.Root.Models.Category>();
if (request.CategoryId.HasValue)
{
query = query.Where(category => category.Id == request.CategoryId);
}
else
{
query = query.Where(category => category.Name == request.CategoryName);
}
var model = query
.Select(category => new CategoryModel
{
Id = category.Id,
Version = category.Version,
CreatedBy = category.CreatedByUser,
CreatedOn = category.CreatedOn,
LastModifiedBy = category.ModifiedByUser,
LastModifiedOn = category.ModifiedOn,
Name = category.Name
})
.FirstOne();
return new GetCategoryResponse
{
Data = model
};
}
public async Task <List <MenuResponse> > GetAll()
{
var filter = new GetCategoryRequest {
IsActive = true
};
var menu = await _categoryRepository.GetCategories(filter);
var result = menu.Where(x => string.IsNullOrEmpty(x.ParentId)).OrderBy(x => x.OrderIndex).Select(x => new MenuResponse
{
Id = x.Id,
ParentId = x.ParentId,
Name = x.Name,
OrderIndex = x.OrderIndex,
Picture = x.Picture,
Url = x.Url,
Childrens = menu.Where(c => c.ParentId == x.Id).OrderBy(c => c.OrderIndex).Select(c => new MenuResponse
{
Id = c.Id,
ParentId = c.ParentId,
Name = c.Name,
OrderIndex = c.OrderIndex,
Picture = c.Picture,
Url = c.Url
}).ToList()
}).ToList();
return(result);
}
/// <summary>
/// Return Category Information
/// </summary>
/// <param name="request">Category ID</param>
/// <returns>Category Information</returns>
public static GetCategoryResponse GetCategory(GetCategoryRequest request)
{
GetCategoryResponse response = new GetCategoryResponse();
response.Error = new Handler.ErrorObject();
response.Category = new Category();
try
{
var GetCategory = CategoryData.Select.GetCategory(request.CategoryID);
if (!GetCategory.Item1.Error)
{
response.Category = new Category()
{
id = GetCategory.Item2.id,
name = GetCategory.Item2.name,
detail = GetCategory.Item2.detail,
CategoryID = ((String.IsNullOrEmpty(GetCategory.Item2.idCategory.ToString()) ? (0) : ((int)GetCategory.Item2.idCategory))),
createDate = GetCategory.Item2.createDate,
upDateDate = GetCategory.Item2.upDateDate,
deleteDate = GetCategory.Item2.deleteDate,
state = GetCategory.Item2.state
};
}
else
{
response.Error.InfoError(GetCategory.Item1);
}
}
catch (Exception ex)
{
response.Error.InfoError(ex);
}
return(response);
}
private async Task <IEnumerable <CategoryResponse> > GetCategories(GetCategoryRequest filter)
{
var categories = await _categoryRepository.GetCategories(filter);
var result = categories.Map <Categories, CategoryResponse>();
return(result);
}
public override async Task <GetCategoryResponse> GetCategory(GetCategoryRequest request, ServerCallContext context)
{
var category = await this.categoryService.GetCategoryAsync(request.Id, (IncludeLevel)request.IncludeLevel).ConfigureAwait(false);
return(new GetCategoryResponse()
{
Category = category.ToGRPCModel()
});
}
public ActionResult <GetCategoryResponse> GetCategory(long id)
{
var request = new GetCategoryRequest {
Id = id
};
var response = _service.GetCategory(request);
return(response);
}
public GetCategoryResponse GetCategory(GetCategoryRequest getCategoryRequest)
{
var category = categoryRepository.FindCategoryById(getCategoryRequest.Id);
var categoryDTO = messageMapper.MapToCategoryDto(category);
return(new GetCategoryResponse {
Category = categoryDTO
});
}
public async Task <CategoryResponse> GetById(string id)
{
var filter = new GetCategoryRequest {
Id = id
};
var result = (await GetCategories(filter)).SingleOrDefault();
return(result);
}
public async Task <IActionResult> GetNewsById(GetCategoryRequest request)
{
var result = await _categoryService.GetNewsByCategoryIdAsync(request);
if (!result.Any())
{
NotFound();
}
return(Ok(result));
}
public async Task <IActionResult> GetById(GetCategoryRequest request)
{
var result = await _categoryService.GetCategoryAsync(request);
if (result == null)
{
return(NotFound());
}
return(Ok(result));
}
public override async Task <RaceCategory> get(GetCategoryRequest request, ServerCallContext context)
{
var RaceCategory = await dbContext.RaceCategories.FindAsync(request.RaceCategoryId);
if (RaceCategory == null)
{
throw new ArgumentException($"RaceCategory not found by Id: '{request.RaceCategoryId}'");
}
return(ToProtoRaceCategory(RaceCategory));
}
public async Task <AllegroResult <CategoryResponse> > GetCategoryAsync(string categoryId)
{
var token = _redis.StringGet("AllegroAppToken");
GetCategoryRequest request = new GetCategoryRequest(new GetCategoryRequestParameter {
categoryId = categoryId
}, token);
return(await _client.GetAsync(request));
}
public void CategoryUseCaseEqualTest()
{
GetCategoryRequest getCategoryRequest = new GetCategoryRequest();
IRepositoryFactory repositoryFactory = new RepositoryFactory(new DBContext());
IActivityFactory activityFactory = new ActivityFactory(repositoryFactory, new ValidationRuleFactory());
IUseCaseFactory useCaseFactory = new UseCaseFactory(activityFactory);
GetCategoryResponse getCategoryResponse = useCaseFactory.Create <IUseCase <GetCategoryRequest, GetCategoryResponse> >().Execute(getCategoryRequest);
Assert.IsTrue(getCategoryResponse.Categories.Count > 0);
}
public JsonResult GetCategory(System.Int32 id)
{
DataTableViewModel data1;
GetCategoryRequest request = new GetCategoryRequest();
request.CategoryID = id;
DetailCategory_CategoryDetailView data = _categoryService.GetCategory(request).Category.ConvertToDetailCategory_CategoryDetailView();
return(Json(data, JsonRequestBehavior.AllowGet));
}
public async Task <IActionResult> GetCategories([FromBody] GetCategoryRequest categoryRequest)
{
var categories = await _shopService.GetCategoriesAsync(categoryRequest);
if (!categories.Success)
{
return(BadRequest(categories.Errors));
}
return(Ok(categories.Response));
}
/// <summary>
/// Creates a waiter using the provided configuration.
/// </summary>
/// <param name="request">Request to send.</param>
/// <param name="config">Wait Configuration</param>
/// <param name="targetStates">Desired resource states. If multiple states are provided then the waiter will return once the resource reaches any of the provided states</param>
/// <returns>a new Oci.common.Waiter instance</returns>
public Waiter <GetCategoryRequest, GetCategoryResponse> ForCategory(GetCategoryRequest request, WaiterConfiguration config, params LifecycleState[] targetStates)
{
var agent = new WaiterAgent <GetCategoryRequest, GetCategoryResponse>(
request,
request => client.GetCategory(request),
response => targetStates.Contains(response.Category.LifecycleState.Value),
targetStates.Contains(LifecycleState.Deleted)
);
return(new Waiter <GetCategoryRequest, GetCategoryResponse>(config, agent));
}
public GetCategoryResponse GetAllCategories(GetCategoryRequest request)
{
GetCategoryResponse response = new GetCategoryResponse();
Query categoryQuery = new Query();
categoryQuery.Add(Criterion.Create <CategoryAccess>(r => r.RetailerId, request.RetailerId, CriteriaOperator.Equal));
IEnumerable <CategoryAccess> categories = _categoryAccessRepository.FindBy(categoryQuery);
response.Categories = categories.convertToCategoryViews();
return(response);
}
public ListResponse <Category> GetCategory(GetCategoryRequest request)
{
var Categorys = _filterQuery(request);
var displayData = Categorys.Skip((request.Page - 1) * request.PageSize).Take(request.PageSize).ToList();
return(new ListResponse <Category>()
{
TotalItems = displayData.Count,
Data = displayData
});
}
public async Task <IEnumerable <NewsResponse> > GetNewsByCategoryIdAsync(GetCategoryRequest request)
{
if (request == null)
{
throw new ArgumentNullException();
}
var news = await _newsRepository.GetNewsByCategoryIdAsync(request.Id);
var response = _mapper.Map <IEnumerable <NewsResponse> >(news);
return(response);
}
public async Task <CategoryResponse> GetCategoryAsync(GetCategoryRequest request)
{
if (request == null)
{
throw new ArgumentNullException();
}
var category = await _categoryRepository.GetAsync(request.Id);
var response = _mapper.Map <CategoryResponse>(category);
return(response);
}
private IQueryable <Category> _filterQuery(GetCategoryRequest request)
{
var query = _context.Category.Where(w => w._DeletedFlag != true);
if (!string.IsNullOrEmpty(request.CategoryName))
{
query = _context.Category.Where(p => p.CategoryName != null &&
p.CategoryName.ToLower().Contains(request.CategoryName.ToLower()));
}
query = query.OrderBy(o => o.CategoryName);
return(query);
}
public Task <HttpResponseMessage> Get(int id)
{
var request = new GetCategoryRequest {
CategoryId = id
};
return(_CategoryService.GetCategoryAsync(request).ContinueWith(resp =>
{
var message = resp.Result;
var viewModel = _Mapper.Map <CategoryViewModel>(message.Category);
return _ResponseMapper.ForGet(Request, viewModel, message.Result);
}));
}
public async Task <IActionResult> GetAll(GetCategoryRequest request)
{
try
{
var category = await CategoryService.GetAll(request);
return(Ok(category));
}
catch (Exception ex)
{
Logger.LogException(ex, "Fox.Category.Api");
return(BadRequest(ex));
}
}
public async Task <IActionResult> GetAsDictionary(GetCategoryRequest filter)
{
try
{
var categories = await CategoryService.GetAsDictionary(filter);
return(Ok(categories));
}
catch (Exception ex)
{
Logger.LogException(ex, "Fox.Category.Api");
return(BadRequest(ex));
}
}
public JsonResult GetDetail(System.Int32 id)
{
CategoryDetailView vm = new CategoryDetailView();
GetCategoryRequest request = new GetCategoryRequest();
request.CategoryID = id;
GetCategoryResponse response = _categoryService.GetCategory(request);
if (response.CategoryFound)
{
vm = response.Category.ConvertToCategoryDetailView();
}
return(Json(vm, JsonRequestBehavior.AllowGet));
}
public GetCategoryResponse GetCategory(GetCategoryRequest getCategoryRequest)
{
GetCategoryResponse getCategoryResponse = null;
if (getCategoryRequest.Id > 0)
{
var category = _categoryRepository.FindCategoryById(getCategoryRequest.Id);
var categoryDto = _messageMapper.MapToCategoryDto(category);
getCategoryResponse = new GetCategoryResponse
{
Category = categoryDto
};
}
return(getCategoryResponse);
}
public GetCategoryResponse GetCategory(GetCategoryRequest request)
{
var response = new GetCategoryResponse();
WithErrorHandling(() =>
{
var category = _categoryRepository.FindCategoryById(request.Id);
var categoryDto = category.MapToCategoryDto();
response.Category = categoryDto;
response.Messages.Add("Successfully get the category");
response.StatusCode = HttpStatusCode.OK;
}, response);
return(response);
}
private string GetCategoryList()
{
JavaScriptSerializer jss = new JavaScriptSerializer();
GetCategoryRequest registerReq = new GetCategoryRequest();
ServiceRequest request = new ServiceRequest(registerReq);
ServiceResponse response = new ServiceResponse();
IService service = ServiceFactory.getInstance().getService(service_type.GET_DISPLAY_CATEGORY);
service.process(request, response);
GetCategoryResponse responseU = (GetCategoryResponse)response.responseObj;
return jss.Serialize(responseU.categories);
}
