public async Task <PagedResultDto <ProductListDto> > GetProducts(GetProductsInput input)
{
var query = _productManager
.Products
.Include(p => p.Pictures)
.WhereIf(!input.Name.IsNullOrWhiteSpace(), r => r.Name.Contains(input.Name));
var productCount = await query.CountAsync();
var products = await query
.OrderBy(input.Sorting)
.PageBy(input)
.ToListAsync();
var productListDtos = products.Select(p =>
{
var productDto = ObjectMapper.Map <ProductListDto>(p);
if (p.Pictures != null && p.Pictures.Any())
{
productDto.PictureUrl = _pictureManager.GetPictureUrl(p.Pictures.FirstOrDefault().PictureId);
}
return(productDto);
}).ToList();
return(new PagedResultDto <ProductListDto>(
productCount,
productListDtos));
}
/// <summary>
/// 获取商品列表
/// </summary>
/// <param name="input"></param>
/// <returns></returns>
public async Task <List <ProductListDto> > Products(GetProductsInput input)
{
var ht = await _deviceRepository.GetAllIncluding(c => c.DeviceGoods)
.FirstOrDefaultAsync(c => c.DeviceNum == input.MachineCode);
if (ht == null || ht.DeviceGoods == null || !ht.DeviceGoods.Any())
{
return(new List <ProductListDto>());
}
var temp = await _cacheManager.GetCache(SchoolCache.GoodsCache)
.GetAsync(SchoolCache.GoodsCache, GetGoodsFromCache);
var list = ht.DeviceGoods;
var result = new List <ProductListDto>();
foreach (var g in list)
{
var model = new ProductListDto()
{
price = g.Price,
product_id = g.GoodsId,
product_name = g.GoodsName
};
var mo = temp.Items.FirstOrDefault(c => c.goods_id == g.GoodsId);
if (mo != null)
{
model.img_url = "http://image.ishenran.cn/" + mo.goods_img;
}
result.Add(model);
}
return(result);
}
/// <summary>
/// 获取Excel数据
/// </summary>
/// <param name="input"></param>
/// <returns></returns>
private async Task <List <ProductListDto> > GeProductsNoPage(GetProductsInput input)
{
//var query = _productRepository.GetAll()
// .WhereIf(!string.IsNullOrEmpty(input.Name), p => p.Specification.Contains(input.Name))
// .WhereIf(input.Type.HasValue, p => p.Type == input.Type)
// .WhereIf(input.IsRare.HasValue, p => p.IsRare == input.IsRare);
////TODO:根据传入的参数添加过滤条件
//var productCount = await query.CountAsync();
//var products = await query.ToListAsync();
////var productListDtos = ObjectMapper.Map<List <ProductListDto>>(products);
//var productListDtos = products.MapTo<List<ProductListDto>>();
//return productListDtos;
var query = _productRepository.GetAll()
.WhereIf(!string.IsNullOrEmpty(input.Name), p => p.Specification.Contains(input.Name))
.WhereIf(input.Type.HasValue, p => p.Type == input.Type)
.WhereIf(input.IsRare.HasValue, p => p.IsRare == input.IsRare);
//TODO:根据传入的参数添加过滤条件
//var productCount = await query.CountAsync();
List <Product> products;
List <ProductListDto> productListDtos;
if (input.SortValue == "ascend")
{
products = await query.OrderByDescending(p => p.SearchCount).ThenBy(input.Sorting).ToListAsync();
productListDtos = products.MapTo <List <ProductListDto> >();
return(productListDtos);
}
else if (input.SortValue == "descend")
{
products = await query.OrderBy(p => p.SearchCount).ThenBy(input.Sorting).ToListAsync();
productListDtos = products.MapTo <List <ProductListDto> >();
return(productListDtos);
}
else
{
products = await query.OrderBy(p => p.Specification).ThenBy(input.Sorting).ToListAsync();
productListDtos = products.MapTo <List <ProductListDto> >();
return(productListDtos);
}
}
public async Task <PagedResultDto <ProductOutput> > GetProductListAsync(GetProductsInput input)
{
try
{
var query = _productRepository.GetAll()
.WhereIf(!string.IsNullOrWhiteSpace(input.Name), p => p.Name.Contains(input.Name));
var items = Mapper.Map <List <ProductOutput> >(query);
var count = await query.CountAsync();
return(new PagedResultDto <ProductOutput>(count, items.ToList()));
}
catch (Exception e)
{
throw e;
}
}
public async Task <PagedResultDto <ProductListDto> > GetPaged(GetProductsInput input)
{
var query = _entityRepository.GetAll();
// TODO:根据传入的参数添加过滤条件
var count = await query.CountAsync();
var entityList = await query
.OrderBy(input.Sorting).AsNoTracking()
.PageBy(input)
.ToListAsync();
// var entityListDtos = ObjectMapper.Map<List<ProductListDto>>(entityList);
var entityListDtos = entityList.MapTo <List <ProductListDto> >();
return(new PagedResultDto <ProductListDto>(count, entityListDtos));
}
public async Task <APIResultDto> ExportProductsExcel(GetProductsInput input)
{
try
{
var exportData = await GeProductsNoPage(input);
var result = new APIResultDto();
result.Code = 0;
result.Data = SaveProductsExcel("商品信息.xlsx", exportData);
return(result);
}
catch (Exception ex)
{
Logger.ErrorFormat("ExportProductsExcel errormsg{0} Exception{1}", ex.Message, ex);
return(new APIResultDto()
{
Code = 901, Msg = "网络忙...请待会儿再试！"
});
}
}
/// <summary>
/// 获取Product的分页列表信息
/// </summary>
/// <param name="input"></param>
/// <returns></returns>
public async Task <PagedResultDto <ProductListDto> > GetPagedProducts(GetProductsInput input)
{
var query = _productRepository.GetAll();
query = query.WhereIf(!input.Name.IsNullOrWhiteSpace(), c => c.ProductName.Contains(input.Name))
.WhereIf(input.State.HasValue, c => c.IsActive == input.State.Value)
.WhereIf(input.Start.HasValue, c => c.CreationTime >= input.Start.Value)
.WhereIf(input.End.HasValue, c => c.CreationTime < input.End.Value);
var productCount = await query.CountAsync();
var products = await query
.OrderBy(input.Sorting).AsNoTracking()
.PageBy(input)
.ToListAsync();
//var productListDtos = ObjectMapper.Map<List <ProductListDto>>(products);
var productListDtos = products.MapTo <List <ProductListDto> >();
return(new PagedResultDto <ProductListDto>(
productCount,
productListDtos
));
}
public async Task <PagedResultDto <ProductListDto> > GetPaged(GetProductsInput input)
{
var query = _entityRepository.GetAll()
.WhereIf(!input.FilterText.IsNullOrWhiteSpace(),
o => o.Name.Contains(input.FilterText) ||
o.Code.Contains(input.FilterText) ||
o.Type.Contains(input.FilterText)
);
// TODO:根据传入的参数添加过滤条件
var count = await query.CountAsync();
var entityList = await query
.OrderBy(input.Sorting).AsNoTracking()
.PageBy(input)
.ToListAsync();
var entityListDtos = ObjectMapper.Map <List <ProductListDto> >(entityList);
// var entityListDtos = entityList.MapTo<List<ProductListDto>>();
return(new PagedResultDto <ProductListDto>(count, entityListDtos));
}
/// <summary>
/// 获取Product的分页列表信息
///</summary>
/// <param name="input"></param>
/// <returns></returns>
public async Task <PagedResultDto <ProductListDto> > GetPagedProductListAsync(GetProductsInput input)
{
if (input.NodeKey != "root")
{
var query = _entityRepository.GetAll().Where(v => v.ProductTagId == Convert.ToInt32(input.NodeKey))
.WhereIf(!string.IsNullOrEmpty(input.Filter), r => r.Name.Contains(input.Filter) || r.BarCode.Contains(input.Filter));
var tag = _productTagRepository.GetAll();
var result = from q in query
join t in tag on q.ProductTagId equals t.Id
select new ProductListDto()
{
Id = q.Id,
Name = q.Name,
Unit = q.Unit,
ProductTagId = t.Id,
ProductTagName = t.Name,
BarCode = q.BarCode,
IsEnable = q.IsEnable,
};
var count = await result.CountAsync();
var entityList = await result
.OrderBy(input.Sorting).AsNoTracking()
.PageBy(input)
.ToListAsync();
var entityListDtos = entityList.MapTo <List <ProductListDto> >();
return(new PagedResultDto <ProductListDto>(count, entityListDtos));
}
else
{
var query = _entityRepository.GetAll().WhereIf(!string.IsNullOrEmpty(input.Filter), r => r.Name.Contains(input.Filter) || r.BarCode.Contains(input.Filter));
var tag = _productTagRepository.GetAll();
var result = from q in query
join t in tag on q.ProductTagId equals t.Id
select new ProductListDto()
{
Id = q.Id,
Name = q.Name,
Unit = q.Unit,
ProductTagName = t.Name,
BarCode = q.BarCode,
IsEnable = q.IsEnable,
};
var count = await result.CountAsync();
var entityList = await result
.OrderBy(input.Sorting).AsNoTracking()
.PageBy(input)
.ToListAsync();
var entityListDtos = entityList.MapTo <List <ProductListDto> >();
return(new PagedResultDto <ProductListDto>(count, entityListDtos));
}
}
/// <summary>
/// 获取Product的分页列表信息
/// </summary>
/// <param name="input"></param>
/// <returns></returns>
public async Task <PagedResultDto <ProductListDto> > GetPagedProducts(GetProductsInput input)
{
// if (input.SortValue == "ascend")
// {
// var query = _productRepository.GetAll()
// .WhereIf(!string.IsNullOrEmpty(input.Name), p => p.Specification.Contains(input.Name))
// .WhereIf(input.Type.HasValue, p => p.Type == input.Type)
// .WhereIf(input.IsRare.HasValue, p => p.IsRare == input.IsRare);
// //TODO:根据传入的参数添加过滤条件
// var productCount = await query.CountAsync();
// var products = await query
// .OrderByDescending(p => p.SearchCount)
// .ThenBy(input.Sorting)
// .PageBy(input)
// .ToListAsync();
// //var productListDtos = ObjectMapper.Map<List <ProductListDto>>(products);
// var productListDtos = products.MapTo<List<ProductListDto>>();
// return new PagedResultDto<ProductListDto>(
// productCount,
// productListDtos
// );
// }
// else if (input.SortValue == "descend")
// {
// var query = _productRepository.GetAll()
// .WhereIf(!string.IsNullOrEmpty(input.Name), p => p.Specification.Contains(input.Name))
// .WhereIf(input.Type.HasValue, p => p.Type == input.Type)
// .WhereIf(input.IsRare.HasValue, p => p.IsRare == input.IsRare);
// //TODO:根据传入的参数添加过滤条件
// var productCount = await query.CountAsync();
// var products = await query
// .OrderBy(p => p.SearchCount)
// .ThenBy(input.Sorting)
// .PageBy(input)
// .ToListAsync();
// //var productListDtos = ObjectMapper.Map<List <ProductListDto>>(products);
// var productListDtos = products.MapTo<List<ProductListDto>>();
// return new PagedResultDto<ProductListDto>(
// productCount,
// productListDtos
// );
// }
// else
// {
// var query = _productRepository.GetAll()
//.WhereIf(!string.IsNullOrEmpty(input.Name), p => p.Specification.Contains(input.Name))
//.WhereIf(input.Type.HasValue, p => p.Type == input.Type)
//.WhereIf(input.IsRare.HasValue, p => p.IsRare == input.IsRare);
// //TODO:根据传入的参数添加过滤条件
// var productCount = await query.CountAsync();
// var products = await query
// .OrderBy(p => p.Specification)
// .ThenBy(input.Sorting)
// .PageBy(input)
// .ToListAsync();
// //var productListDtos = ObjectMapper.Map<List <ProductListDto>>(products);
// var productListDtos = products.MapTo<List<ProductListDto>>();
// return new PagedResultDto<ProductListDto>(
// productCount,
// productListDtos
// );
// }
var query = _productRepository.GetAll()
.WhereIf(!string.IsNullOrEmpty(input.Name), p => p.Specification.Contains(input.Name))
.WhereIf(input.Type.HasValue, p => p.Type == input.Type)
.WhereIf(input.IsRare.HasValue, p => p.IsRare == input.IsRare);
//TODO:根据传入的参数添加过滤条件
var productCount = await query.CountAsync();
if (input.SortValue == "ascend")
{
var products = await query
.OrderByDescending(p => p.SearchCount)
.ThenBy(input.Sorting)
.PageBy(input)
.ToListAsync();
var productListDtos = products.MapTo <List <ProductListDto> >();
return(new PagedResultDto <ProductListDto>(
productCount,
productListDtos
));
}
else if (input.SortValue == "descend")
{
var products = await query
.OrderBy(p => p.SearchCount)
.ThenBy(input.Sorting)
.PageBy(input)
.ToListAsync();
//var productListDtos = ObjectMapper.Map<List <ProductListDto>>(products);
var productListDtos = products.MapTo <List <ProductListDto> >();
return(new PagedResultDto <ProductListDto>(
productCount,
productListDtos
));
}
else
{
var products = await query
.OrderBy(p => p.Specification)
.ThenBy(input.Sorting)
.PageBy(input)
.ToListAsync();
//var productListDtos = ObjectMapper.Map<List <ProductListDto>>(products);
var productListDtos = products.MapTo <List <ProductListDto> >();
return(new PagedResultDto <ProductListDto>(
productCount,
productListDtos
));
}
}
public ActionResult Index(GetProductsInput input)
{
return(base.View());
}
public async Task <PagedResultOutput <ProductListDto> > GetProducts(GetProductsInput input)
{
//ProductAppService.<>c__DisplayClass9_0 variable = null;
//ProductAppService.<>c__DisplayClass9_1 variable1 = null;
decimal num;
bool filterIsDecimal = decimal.TryParse(input.Filter, out num);
IQueryable <ProductOption> all = this._productOptionRepository.GetAll();
var productOptions = all.Where(m => m.TenantId == AbpSession.TenantId);
var productOptions1 = productOptions.WhereIf(!input.Filter.IsNullOrEmpty(), p =>
p.Name.Contains(input.Filter) ||
p.Comment.Contains(input.Filter) ||
p.Value.Contains(input.Filter));
var productOptionIds = await productOptions1.Select(s => new { ProductId = s.ProductId }).ToListAsync();
IQueryable <ProductResource> productResources = this._productResourceRepository.GetAll();
var productResources1 = productResources.Where(m => m.TenantId == AbpSession.TenantId);
var productResources2 = productResources1.WhereIf(!input.Filter.IsNullOrEmpty(), p =>
p.Name.Contains(input.Filter) ||
p.Description.Contains(input.Filter) ||
p.Category.Contains(input.Filter) ||
p.FileExtension.Contains(input.Filter) ||
p.FileName.Contains(input.Filter));
var productResourceIds = await productResources2.Select(s => new { ProductId = s.ProductId }).ToListAsync();
IQueryable <Product> products = this._productRepository.GetAll();
var products1 = products.WhereIf(!input.Filter.IsNullOrEmpty(), p =>
p.Name.Contains(input.Filter) ||
p.Reference.Contains(input.Filter) ||
p.Sku.Contains(input.Filter) ||
p.Description.Contains(input.Filter) ||
p.QuantitySoldIn.Contains(input.Filter));
var productIds = await products1.Select(s => new { ProductId = s.Id }).ToListAsync();
List <long> list = (
from s in productOptionIds
select s.ProductId).ToList();
IEnumerable <long> nums = list.Union((
from s in productResourceIds
select s.ProductId).ToList());
IEnumerable <long> foundProductIdsFromInputFilter = nums.Union((
from s in productIds
select s.ProductId).ToList());
IQueryable <ProductSupplier> productSuppliers = _productSupplierRepository.GetAll();
var productSuppliers1 = productSuppliers.Where(m => m.TenantId == AbpSession.TenantId);
List <long> distinctSuppliersWithProducts = await productSuppliers1.Select(s => s.SupplierId).ToListAsync();
if (distinctSuppliersWithProducts.Any())
{
IQueryable <Supplier> suppliers = _supplierRepository.GetAll();
IQueryable <Supplier> tenantSuppliers = suppliers.Where(m => m.TenantId == AbpSession.TenantId);
var suppliers2 = tenantSuppliers.WhereIf(!input.Filter.IsNullOrEmpty(), p =>
distinctSuppliersWithProducts.Contains(p.Id) && (
p.Name.Contains(input.Filter) ||
p.Description.Contains(input.Filter) ||
p.PhoneNumber.Contains(input.Filter) ||
p.MobilePhoneNumber.Contains(input.Filter) ||
p.Address.Contains(input.Filter) ||
p.SecondaryAddress.Contains(input.Filter) ||
p.City.Contains(input.Filter) ||
p.Country.Code.Contains(input.Filter) ||
p.Country.Name.Contains(input.Filter) ||
p.CountryRegion.Code.Contains(input.Filter) ||
p.CountryRegion.Name.Contains(input.Filter) ||
p.PostalCode.Contains(input.Filter) ||
p.ContactName.Contains(input.Filter) ||
p.ContactEmail.Contains(input.Filter)
));
List <long> productSuppliersThatMatchSearch = await suppliers2.Select(s => s.Id).ToListAsync();
if (productSuppliersThatMatchSearch.Any())
{
IQueryable <ProductSupplier> all1 = this._productSupplierRepository.GetAll();
var productSuppliers2 = all1.Where(m => m.TenantId == AbpSession.TenantId && productSuppliersThatMatchSearch.Contains(m.SupplierId));
var listAsync4 = await productSuppliers2.Select(s => new { ProductId = s.ProductId }).ToListAsync();
foundProductIdsFromInputFilter = foundProductIdsFromInputFilter.Union((
from s in listAsync4
select s.ProductId).ToList());
}
}
if (filterIsDecimal)
{
IQueryable <ProductPrice> productPrices = _productPriceRepository.GetAll();
var productPrices1 = productPrices.Where(m => m.TenantId == AbpSession.TenantId);
var productPrices2 = productPrices1.WhereIf(!input.Filter.IsNullOrEmpty(), p =>
p.Cost == num ||
p.UnitPrice == num ||
p.SpecialDeliveryFee == num);
var listAsync5 = await productPrices2.Select(s => new { ProductId = s.ProductId }).ToListAsync();
IQueryable <Product> all2 = this._productRepository.GetAll();
var products2 = all2.WhereIf(!input.Filter.IsNullOrEmpty(), p =>
p.BasePrice == num ||
p.FinalPrice == num ||
p.Surcharge == num);
var listAsync6 = await products2.Select(s => new { ProductId = s.Id }).ToListAsync();
foundProductIdsFromInputFilter = foundProductIdsFromInputFilter.Union((
from s in listAsync5
select s.ProductId).ToList());
foundProductIdsFromInputFilter = foundProductIdsFromInputFilter.Union((
from s in listAsync6
select s.ProductId).ToList());
}
IQueryable <Product> all3 = this._productRepository.GetAll();
var products3 = all3.Where(m => foundProductIdsFromInputFilter.Contains(m.Id));
int num1 = await products3.CountAsync();
List <Product> products4 = await products3.OrderBy(input.Sorting, new object[0]).PageBy(input).ToListAsync();
return(new PagedResultOutput <ProductListDto>(num1, products4.MapTo <List <ProductListDto> >()));
}
