Пример #1
0
        public QueryResult<Distributor> Query(QueryStandard query)
        {
            IQueryable<tblCostCentre> distributorquery;
            if (query.ShowInactive)
                distributorquery = _ctx.tblCostCentre.Where(p => p.IM_Status != (int)EntityStatus.Deleted && p.CostCentreType==(int)CostCentreType.Distributor).AsQueryable();
            else
                distributorquery = _ctx.tblCostCentre.Where(p => p.IM_Status == (int)EntityStatus.Active && p.CostCentreType == (int)CostCentreType.Distributor).AsQueryable();

            var queryResult = new QueryResult<Distributor>();
            if (!string.IsNullOrEmpty(query.Name))
            {
                distributorquery = distributorquery.Where(p => p.Name.ToLower().Contains(query.Name.ToLower())
                                                         || p.Distributor_Owner.ToLower().Contains(query.Name.ToLower())
                                                         || p.tblRegion.Name.ToLower().Contains(query.Name.ToLower()));

            }

            queryResult.Count = distributorquery.Select(Map).OfType<Distributor>().ToList().Count();

            distributorquery = distributorquery.OrderBy(p => p.Name).ThenBy(p => p.Cost_Centre_Code);
            
            if (query.Skip.HasValue && query.Take.HasValue)
                distributorquery = distributorquery.Skip(query.Skip.Value).Take(query.Take.Value);
            
            queryResult.Data = distributorquery.Select(Map).OfType<Distributor>().ToList();
           

            return queryResult;
        }
        public new QueryResult<CommoditySupplier> Query(QueryBase query)
        {
            var  q= query as QueryCommoditySupplier;

            IQueryable<tblCostCentre> locationQuery;
            if(q.ShowInactive)
               locationQuery = _ctx.tblCostCentre.Where(s=>s.CostCentreType==(int)CostCentreType.CommoditySupplier && (s.IM_Status == (int)EntityStatus.Active || s.IM_Status==(int)EntityStatus.Inactive)).AsQueryable();
            else
                locationQuery = _ctx.tblCostCentre.Where(s => s.CostCentreType == (int)CostCentreType.CommoditySupplier && s.IM_Status == (int)EntityStatus.Active).AsQueryable();

            var queryResult = new QueryResult<CommoditySupplier>();
            if (!string.IsNullOrWhiteSpace(q.Name))
            {
                locationQuery = locationQuery
                    .Where(s => s.Name.ToLower().Contains(q.Name.ToLower()) || s.Cost_Centre_Code.ToLower().Contains(q.Name.ToLower()));
            }
            
            queryResult.Count = locationQuery.Count();
            locationQuery = locationQuery.OrderBy(s => s.Name).ThenBy(s=>s.Cost_Centre_Code);
            if (q.Skip.HasValue && q.Take.HasValue)
                locationQuery = locationQuery.Skip(q.Skip.Value).Take(q.Take.Value);
            var result = locationQuery.ToList();
            queryResult.Data = result.Select(Map).OfType<CommoditySupplier>().ToList();
            q.ShowInactive = false;
            return queryResult;
        }
 public QueryResult<ProductPricingTierViewModel> Query(QueryStandard query)
 {
     var queryResult = _productPricingTierRepository.Query(query);
     var result = new QueryResult<ProductPricingTierViewModel>();
     result.Count = queryResult.Count;
     result.Data = queryResult.Data.Select(Map).ToList();
     return result;
 }
 public QueryResult<AdminProductPackagingTypeViewModel> Query(QueryStandard query)
 {
     var queryResult = _productPackagingTypeRepository.Query(query);
     var result = new QueryResult<AdminProductPackagingTypeViewModel>();
     result.Count = queryResult.Count;
     result.Data = queryResult.Data.Select(Map).ToList();
     return result;
 }
        public QueryResult<CommodityTypeViewModel> Query(QueryStandard query)
        {
            var queryResult = _commodityTypeRepository.Query(query);
            var results = new QueryResult<CommodityTypeViewModel>();
            results.Count = queryResult.Count;
            results.Data = queryResult.Data.Select(Map).ToList();

            return results;

        }
         public QueryResult<CommoditySupplierListingViewModel> Query(QueryCommoditySupplier query)
         {
             var queryResult = _commoditySupplierRepository.Query(query);

             var result = new QueryResult<CommoditySupplierListingViewModel>();

             result.Data = queryResult.Data.Select(Map).ToList();
             result.Count = queryResult.Count;

             return result;
         }
        public QueryResult<AssetTypeViewModel> Query(QueryStandard query)
        {
            var result = _assetTypeRepository.Query(query);
            
            var queryResult = new QueryResult<AssetTypeViewModel>();

            queryResult.Data = result.Data.Select(Map).ToList();
            queryResult.Count = result.Count;

            return queryResult;
        }
       public QueryResult<MarketAuditViewModel> Query(QueryStandard q)
       {
           var queryResult = _marketAuditRepository.Query(q);

           var result = new QueryResult<MarketAuditViewModel>();

           result.Data = queryResult.Data.Select(Map).ToList();
           result.Count = queryResult.Count;

           return result;
       }
Пример #9
0
        public QueryResult<TargetViewModel> Query(QueryStandard query)
        {
            var queryResult = _targeteRepository.Query(query);

            var result = new QueryResult<TargetViewModel>();

            result.Data = queryResult.Data.Select(Map).ToList();
            result.Count = queryResult.Count;

            return result;
        }
Пример #10
0
        public QueryResult<Hub> Query(QueryStandard query)
        {

            IQueryable<tblCostCentre> costCentreQuery;

            //retreave inactive costCentres 
            if (query.ShowInactive)
                costCentreQuery = _ctx.tblCostCentre.Where(
                    p => p.IM_Status != (int)EntityStatus.Deleted && p.CostCentreType==(int)CostCentreType.Hub).AsQueryable();
            else
                //retreave active costCentres 
                costCentreQuery = _ctx.tblCostCentre.Where(
                    p => p.IM_Status == (int)EntityStatus.Active && p.CostCentreType == (int)CostCentreType.Hub).AsQueryable();


            var queryResult = new QueryResult<Hub>();

            //excecute search filter
            if (!string.IsNullOrEmpty(query.Name))
            {
                costCentreQuery = costCentreQuery.Where(p => p.Name.ToLower()
                                                                 .Contains(query.Name.ToLower()) ||
                                                             p.Cost_Centre_Code.ToLower()
                                                                 .Contains(query.Name.ToLower()) ||
                                                             p.tblRegion.Name.ToLower()
                                                                 .Contains(query.Name.ToLower()));
            }
          

            //order costCentreQuery
            costCentreQuery = costCentreQuery.OrderBy(p => p.Name).
                ThenBy(p => p.Cost_Centre_Code).
                ThenBy(p => p.tblRegion.Name);


            

            //paging
            if (query.Skip.HasValue && query.Take.HasValue)
            
                costCentreQuery = costCentreQuery.Skip(query.Skip.Value).Take(query.Take.Value);

            queryResult.Count = costCentreQuery.Count();
            queryResult.Data = costCentreQuery.Select(Map).OfType<Hub>().ToList();

            return queryResult;
        }
        public QueryResult<CommodityWarehouseStorageNote> Query(QueryDocument query)//List<SourcingDocument> Query(QueryDocument query)
        {
            var commodityWarehouseStorageQuery = documents.AsQueryable();

            var queryResult = new QueryResult<CommodityWarehouseStorageNote>();

            commodityWarehouseStorageQuery=commodityWarehouseStorageQuery.Where(n => n.DocumentStatusId == (int)query.DocumentSourcingStatusId);

            queryResult.Count = commodityWarehouseStorageQuery.Count();
            commodityWarehouseStorageQuery = commodityWarehouseStorageQuery.OrderByDescending(n => n.DocumentDate);
            if (query.Skip.HasValue && query.Take.HasValue)
                commodityWarehouseStorageQuery = commodityWarehouseStorageQuery.Skip(query.Skip.Value).Take(query.Take.Value);

            var result = commodityWarehouseStorageQuery.ToList();
            queryResult.Data = result.Select(Map).OfType<CommodityWarehouseStorageNote>().ToList();

            return queryResult;

            //return documents.Where(n => n.DocumentStatusId == (int)query.DocumentSourcingStatusId).OrderByDescending(n => n.DocumentDate).ToList().Select(Map).ToList();
        }
       public QueryResult<PromotionDiscountViewModel> Query(QueryStandard q)
       {
           var queryResult = _promotionDiscountRepository.Query(q);

           var result = new QueryResult<PromotionDiscountViewModel>();

           result.Count = queryResult.Count;
           result.Data = queryResult.Data.OfType<PromotionDiscount>().Select(Map).ToList();

           return result;
       }
Пример #13
0
 public IList<HubViewModel> Querylist(QueryResult result)
 {
     return result.Data.OfType<Hub>().ToList().Select(Map).ToList();
 }
 public QueryResult<ListVatClassViewModel> Query(QueryBase query)
 {
     var queryResult = _vatClassRepository.Query(query);
     var result = new QueryResult<ListVatClassViewModel>();
     result.Count = queryResult.Count;
     result.Data = queryResult.Data.Select(Map).ToList();
     return result;
 }
        public QueryResult<UserGroupVeiwModel> Query(QueryStandard q)
        {
            var queryResult = _userGroupRepository.Query(q);

            var result = new QueryResult<UserGroupVeiwModel>();

            result.Data = queryResult.Data.Select(Map).ToList();
            result.Count = queryResult.Count;

            return result;
        }
Пример #16
0
        public QueryResult<AgriUserViewModel> Query(QueryUsers query)
        {
            var queryResult = _userRepository.Query(query);

            var result = new QueryResult<AgriUserViewModel>();

            result.Data = queryResult.Data.OfType<User>().ToList().Select(Map).ToList();
            result.Count = queryResult.Count;

            return result;
        }
Пример #17
0
        public QueryResult<Order> Query(QueryOrders query)
        {
            IEnumerable<tblDocument> tblDocument;
            tblDocument = _GetAll(DocumentType.Order).AsQueryable();
            tblDocument = tblDocument.Where(k => k.DocumentStatusId == (int)query.DocumentStatus);

            tblDocument = tblDocument.Where(k => k.DocumentDateIssued >= query.StartDate && k.DocumentDateIssued <= query.EndDate);
            tblDocument = tblDocument.Where(k => k.OrderOrderTypeId == (int)query.OrderType);

            var queryResult = new QueryResult<Order>();
           
            if (query.Distributr != null && query.Distributr != Guid.Empty)
            {
                tblDocument = tblDocument.Where(k => k.DocumentIssuerCostCentreId == query.Distributr);
            }
            queryResult.Count = tblDocument.Count();

            tblDocument = tblDocument.OrderBy(l => l.DocumentDateIssued);


            if (!string.IsNullOrWhiteSpace(query.Name))
            {
                var outletIds =
                    _ctx.tblCostCentre.Where(s => s.CostCentreType == 5 && s.Name.Contains(query.Name))
                        .Select(s => s.Id);
                tblDocument = tblDocument.Where(l =>l.OrderIssuedOnBehalfOfCC != null && outletIds.Contains( l.OrderIssuedOnBehalfOfCC.Value));
            }

            if (query.Skip.HasValue && query.Take.HasValue)
            {

                tblDocument = tblDocument.Skip(query.Skip.Value)
                    .Take(query.Take.Value);
            }
            var entities = tblDocument.ToList().Select(Map);
               
            queryResult.Data = entities.ToList();
            
            return queryResult;
        }
        public QueryResult<CommodityOwnerViewModel> Query(QueryCommodityOwner q)
        {
            var queryResult = _commodityOwnerRepository.Query(q);

            var results = new QueryResult<CommodityOwnerViewModel>();

            results.Data = queryResult.Data.Select(Map).ToList();
            results.Count = queryResult.Count;

            return results;
        }
 public IList<CommodityTypeViewModel> QueryList(QueryResult result)
 {
     //var result= _commodityTypeRepository.Query(query);
     return result.Data.OfType<CommodityType>().ToList().Select(Map).ToList();
 }
Пример #20
0
 QueryResult<CentreViewModel> ICentreViewModelBuilder.Query(QueryStandard query)
 {
     var queryResult = _centreRepository.Query(query);
     var result = new QueryResult<CentreViewModel>();
     result.Data = queryResult.Data.OfType<Centre>().Select(Map).ToList();
     result.Count = queryResult.Count;
     return result;
 }
       public QueryResult<ReOrderLevelViewModel> Query(QueryStandard query)
       {
           var queryResult = _reOrderLevelRepository.Query(query);
           var result = new QueryResult<ReOrderLevelViewModel>();
           result.Count = queryResult.Count;
           result.Data = queryResult.Data.Select(Map).ToList();
           return result;



       }
Пример #22
0
 public IList<AgriUserViewModel> QueryList(QueryResult result)
 {
     return result.Data.OfType<User>().ToList().Select(Map).ToList();
 }
        public QueryResult<WeighScaleViewModel> Query(QueryEquipment query)
        {
            var queryResults = _equipmentRepository.Query(query);

            var results = new QueryResult<WeighScaleViewModel>();
            results.Data = queryResults.Data.OfType<WeighScale>().Select(Map).ToList();
            results.Count = queryResults.Count;

            return results;
        }
Пример #24
0
 public QueryResult<RegionViewModel> Query(QueryStandard query)
 {
     var queryResults = _regionRepository.Query(query);
     var results = new QueryResult<RegionViewModel>();
     results.Data = queryResults.Data.Select(Map).ToList();
     results.Count = queryResults.Count;
     return results;
 }
        public QueryResult<OutletCategoryViewModel> Query(QueryStandard q)
        {
            var queryResult = _outletCategoryRepository.Query(q);

            var result = new QueryResult<OutletCategoryViewModel>();
            result.Count = queryResult.Count;
            result.Data = queryResult.Data.Select(Map).ToList();

            return result;
        }
Пример #26
0
 public IList<RegionViewModel> QueryList(QueryResult result)
 {
     return result.Data.OfType<Region>().ToList().Select(Map).ToList();
 }
Пример #27
0
        public QueryResult<VehicleViewModel> Query(QueryEquipment query)
        {
            var queryResult = _vehicleRepository.Query(query);

            var result = new QueryResult<VehicleViewModel>();

            result.Data = queryResult.Data.Select(Map).ToList();
            result.Count = queryResult.Count;

            return result;
        }
       public QueryResult<FreeOfChargeDiscountViewModel> QueryResult(QueryFOCDiscount query)
       {
           var result = _freeOfChargeDiscountRepository.QueryResult(query);

           var data = new QueryResult<FreeOfChargeDiscountViewModel>();

           data.Count = result.Count;
           data.Data = result.Data.Select(Map).ToList();

           return data;
       }
Пример #29
0
        public QueryResult<MainOrderSummary> Query(QueryStandard query, DateTime startdate, DateTime endDate, DocumentStatus? documentStatus, Guid? distributrId = null)
        {
            IQueryable<tblDocument> orders;
            orders = _GetAll(DocumentType.Order, startdate, endDate).Where(s => s.OrderParentId == s.Id);
            orders = orders.Where(s => s.OrderOrderTypeId == (int)OrderType.DistributorToProducer);
            

            if (distributrId.HasValue && distributrId != Guid.Empty)
            {
                orders =
                    orders.Where(
                        s =>
                        s.DocumentRecipientCostCentre == distributrId.Value ||
                        s.DocumentIssuerCostCentreId == distributrId.Value);
            }
            if (documentStatus.HasValue && documentStatus != 0)
            {
                orders = orders.Where(s => s.DocumentStatusId == (int)documentStatus);
            }

            var queryResult = new QueryResult<MainOrderSummary>();

            if (!string.IsNullOrWhiteSpace(query.Name))
                orders = orders.Where(p => p.DocumentReference.ToLower().Contains(query.Name.ToLower()));

            queryResult.Count = orders.Count();

            orders = orders.OrderBy(k => k.Id);

            if (query.Skip.HasValue && query.Take.HasValue)
                orders = orders.Skip(query.Skip.Value).Take(query.Take.Value);

            var result = orders.ToList();

            queryResult.Data = result.Select(k=>MapSummary(k)).ToList();
            query.ShowInactive = false;
            return queryResult;
        }
 public QueryResult<OutletVisitReasonsTypeViewModel> Query(QueryStandard query)
 {
     var queryResult = _outletVisitReasonsTypeRepository.Query(query);
     var results = new QueryResult<OutletVisitReasonsTypeViewModel>();
     results.Count = queryResult.Count;
     results.Data = queryResult.Data.Select(Map).ToList();
     return results;
 }