public async Task <HttpResponseMessage> GetDataList(int goodsCategoryTypeId, bool?isActive = null, int?iGoalTypeId = null)
{
GoalGoodsCategoryTypeEnum catTypeId = default(GoalGoodsCategoryTypeEnum);
GoalTypeEnum goalTypeId = default(GoalTypeEnum);
if (goodsCategoryTypeId != 0)
{
catTypeId = Utilities.ToEnum <GoalGoodsCategoryTypeEnum>(goodsCategoryTypeId).Value;
}
if (iGoalTypeId.HasValue)
{
goalTypeId = Utilities.ToEnum <GoalTypeEnum>(iGoalTypeId).Value;
}
IBusinessResultValue <List <GoalGoodsCategory> > entities = await businessService.LoadVisibleGoalGoodsCategoryListAsync(
where : x => (x.GoalGoodsCategoryTypeId == catTypeId || goodsCategoryTypeId == 0) &&
(x.GoalTypeId == goalTypeId || iGoalTypeId.HasValue == false) &&
(x.IsActive == isActive || isActive.HasValue == false));
if (entities.ReturnStatus == false)
{
CreateErrorResponse(entities);
}
var mapper = GetMapper();
var dataSource = mapper.Map <List <GoalGoodsCategoryViewModel> >(entities.ResultValue);
return(CreateSuccessedListResponse(dataSource));
}
public async Task<HttpResponseMessage> GetQuantityConditionTypeAsync(int goalId)
{
IBusinessResultValue<QuantityConditionTypeEnum?> loadResultValue = await quantityConditionBusiness.LoadQuantityConditionTypeAsync(goalId);
if (!loadResultValue.ReturnStatus)
{
return CreateErrorResponse(loadResultValue);
}
return Request.CreateResponse(HttpStatusCode.OK, loadResultValue.ResultValue);
}
public async Task <HttpResponseMessage> GetValuesAsync()
{
IBusinessResultValue <List <RewardType> > entities = await businessService.LoadListAsync();
if (entities.ReturnStatus == false)
{
return(Request.CreateResponse(HttpStatusCode.BadRequest, entities.ReturnMessage));
}
var mapper = GetMapper();
var result = mapper.Map <List <RewardType>, List <TypeEntityViewModel> >(entities.ResultValue);
return(Request.CreateResponse(HttpStatusCode.OK, result));
}
public async Task <HttpResponseMessage> GetValuesAsync()
{
IBusinessResultValue <List <CondemnationType> > entities = await businessService.LoadListAsync();
if (entities.ReturnStatus == false)
{
return(CreateErrorResponse(entities));
}
var mapper = GetMapper();
var result = mapper.Map <List <CondemnationType>, List <TypeEntityViewModel> >(entities.ResultValue);
return(CreateSuccessedListResponse <TypeEntityViewModel>(result));
}
public async Task <HttpResponseMessage> GetFulfillmentList(int year, int month)
{
IBusinessResultValue <List <FulfillmentPercent> > lstGoalFullfillments = await businessService.LoadFulfillmentListAsync(year, month);
if (!lstGoalFullfillments.ReturnStatus)
{
return(CreateErrorResponse(lstGoalFullfillments));
}
var mapper = GetMapper();
List <FulfillmentPercentViewModel> result = mapper.Map <List <FulfillmentPercentViewModel> >(lstGoalFullfillments.ResultValue);
return(CreateSuccessedListResponse(result));
}
public async Task <HttpResponseMessage> GetBranchPromotionsForCEOReviewAsync()
{
IBusinessResultValue <List <BranchPromotion> > result_bizloading = await businessService.LoadBranchPromotions(PromotionReviewStatusEnum.ReleasedStep1ByBranchManager);
if (result_bizloading.ReturnStatus == false)
{
return(CreateErrorResponse(result_bizloading));
}
var mapper = GetMapper();
var result = mapper.Map <List <BranchPromotion>, List <BranchPromotionViewModel> >(result_bizloading.ResultValue);
return(CreateSuccessedListResponse(result));
}
public async Task<HttpResponseMessage> GetQuantityConditionAsync(int goalId)
{
IBusinessResultValue<QuantityCondition> loadResultValue = await quantityConditionBusiness.LoadQuantityConditionAsync(goalId);
if (!loadResultValue.ReturnStatus)
{
return CreateErrorResponse(loadResultValue);
}
QuantityConditionViewModel result = new QuantityConditionViewModel();
var mapper = GetMapper();
result = mapper.Map<QuantityConditionViewModel>(loadResultValue.ResultValue);
return CreateViewModelResponse(result, loadResultValue);
}
public virtual async Task <HttpResponseMessage> Add(GoalGoodsCategoryViewModel postedViewModel)
{
var mapper = GetMapper();
GoalGoodsCategory entityCreating = mapper.Map <GoalGoodsCategory>(postedViewModel);
IBusinessResultValue <GoalGoodsCategory> entityCreated = await businessService.CreateGoalGoodsCategoryAsync(entityCreating, postedViewModel.GoalCategorySimilarId);
if (entityCreated.ReturnStatus == false)
{
return(CreateErrorResponse(entityCreated));
}
postedViewModel = mapper.Map <GoalGoodsCategoryViewModel>(entityCreated.ResultValue);
return(CreateViewModelResponse(postedViewModel, entityCreated));
}
public async Task <HttpResponseMessage> GetGoalByGoodsCategoryId(int goodsCategoryId)
{
IBusinessResultValue <Goal> goalEntity = await businessService
.EntityLoader
.LoadAsync(where : x => x.GoalGoodsCategoryId == goodsCategoryId && x.IsUsed == false
, includes : x => new { x.GoalSteps });
if (goalEntity.ReturnStatus == false)
{
return(CreateErrorResponse(goalEntity));
}
var mapper = GetMapper();
var result = mapper.Map <Goal, GoalViewModel>(goalEntity.ResultValue);
return(CreateViewModelResponse(result, goalEntity));
}
public async Task <HttpResponseMessage> GetAppMenuAsync()
{
IBusinessResultValue <List <AppMenu> > entities = await appMenuLoader.LoadListAsync(
orderBy : Utilities.GetOrderBy <AppMenu>("OrderId", "asc")
, includes : x => new { x.ChildItems }
, where : x => x.ParentId == null);
if (entities.ReturnStatus == false)
{
return(Request.CreateResponse(HttpStatusCode.BadRequest));
}
var mapper = GetMapper();
DataList <ApplicationMenuViewModel> dataSource = mapper.Map <List <AppMenu>, DataList <ApplicationMenuViewModel> >(entities.ResultValue);
return(Request.CreateResponse(HttpStatusCode.OK, dataSource));
}
public HttpResponseMessage GetCompanies(string faName = null)
{
IBusinessResultValue <List <Company> > entities = businessService.LoadList(
where : co => co.FaName.StartsWith(faName) ||
co.Code.StartsWith(faName) ||
co.NationalCode.StartsWith(faName) ||
faName == null || faName == ""
, orderBy: Utilities.GetOrderBy <Company>("FaName", "asc"));
if (entities.ReturnStatus == false)
{
return(Request.CreateResponse(HttpStatusCode.BadRequest, entities.ReturnMessage));
}
var mapper = GetMapper();
var result = mapper.Map <List <Company>, List <CompanyViewModel> >(entities.ResultValue);
return(Request.CreateResponse(HttpStatusCode.OK, result));
}
public async Task <HttpResponseMessage> GetListforReport(int goodsCategoryTypeId, int iGoalTypeId
, string startDate
, string endDate)
{
GoalGoodsCategoryTypeEnum catTypeId = Utilities.ToEnum <GoalGoodsCategoryTypeEnum>(goodsCategoryTypeId).Value;
GoalTypeEnum goalTypeId = Utilities.ToEnum <GoalTypeEnum>(iGoalTypeId).Value;
IBusinessResultValue <List <GoalGoodsCategory> > entities = await businessService.LoadGoalGoodsCategoryForReportAsync(catTypeId
, goalTypeId
, Utilities.ToDateTime(startDate).Value
, Utilities.ToDateTime(endDate).Value
);
if (entities.ReturnStatus == false)
{
CreateErrorResponse(entities);
}
var mapper = GetMapper();
var dataSource = mapper.Map <List <GoalGoodsCategoryViewModel> >(entities.ResultValue);
return(CreateSuccessedListResponse(dataSource));
}
public async Task <HttpResponseMessage> GetBranchPromotionReleasedByCEO()
{
int branchId = IdentityConfig.GetBranchId(User);
IBusinessResultValue <BranchPromotion> result_bizloading = await businessService.LoadBranchPromotionAsync(branchId, PromotionReviewStatusEnum.ReleasedByCEO);
if (result_bizloading.ReturnStatus == false)
{
return(CreateErrorResponse(result_bizloading));
}
var mapper = GetMapper();
var result = new BranchPromotionViewModel();
if (result_bizloading.ResultValue != null)
{
result = mapper.Map <BranchPromotion, BranchPromotionViewModel>(result_bizloading.ResultValue);
}
else
{
result.PromotionReviewStatusId = 0;
}
return(CreateViewModelResponse(result, result_bizloading));
}
public async Task <HttpResponseMessage> GetCompanyGoods(int companyId, string enName = null, string faName = null, string goodsCode = null)
{
List <GoodsViewModel> result = new List <GoodsViewModel>();
IBusinessResultValue <List <Goods> > entities = await lstLoaderBs.LoadListAsync(where : gd => gd.CompanyId == companyId &&
(gd.EnName.StartsWith(enName) || enName == null ||
gd.FaName.StartsWith(faName) || faName == null ||
gd.GoodsCode.StartsWith(goodsCode) || goodsCode == null)
, includes : x => new { x.Company }
, orderBy : Utilities.GetOrderBy <Goods>("FaName", "asc"));
if (entities.ReturnStatus == false)
{
return(CreateErrorResponse(entities));
}
var mapper = GetMapper();
result = mapper.Map <List <Goods>, List <GoodsViewModel> >(entities.ResultValue);
return(CreateSuccessedListResponse <GoodsViewModel>(result));
}
