public async Task <IActionResult> GetAllCustomers()
{
ActionResult result;
var input = new GetCustomersInput();
GetCustomersOutput output;
try
{
output = await this._facadeOrchestratorCustomer.GetCustomersAsync(input);
if (output.Success)
{
result = Ok(output.Customers);
}
else
{
result = BadRequest(output.GetJoinedErrors());
}
}
catch (Exception ex)
{
result = BadRequest(ex);
}
return(result);
}
//public ListResultDto<GetCustomerForSelectDto> GetCustomerByLocation(string location)
//{
// var list = _customnerRepository.GetAll()
// .Where(x => x.Area.Contains(location))
// .ToList();
// return new ListResultDto<GetCustomerForSelectDto>(list.MapTo<List<GetCustomerForSelectDto>>());
//}
public PagedResultDto <CustomerDto> GetCustomers(GetCustomersInput input)
{
var customerQuery = _customnerRepository.GetAll();
var workOrderQuery = _workOrderBillRepository
.GetAll()
.GroupBy(e => e.Customer)
.Select(e => e.OrderByDescending(o => o.CreationTime).FirstOrDefault())
;
DateTime?dt = null;
var query = from customer in customerQuery
join workorder in workOrderQuery on customer.Id equals workorder.CustomerId into temp
from tt in temp.DefaultIfEmpty()
select new CustomerDto()
{
LastServiceTime = tt == null ? dt : tt.ServiceTime,
Id = customer.Id,
Name = customer.Name
};
var list = query.OrderBy("Name")
.PageBy(input)
.ToList();
var recordCount = list.Count;
// var billList = list.MapTo<List<GetNewAccessoryUseDto>>();
return(new PagedResultDto <CustomerDto>(recordCount, list));
}
public async Task <PagedResultDto <CustomerListDto> > GetPagedCustomerAsync(GetCustomersInput input)
{
var query = _customerRepository.GetAll();
var supplierCount = await query.CountAsync();
var suppliers = await query.OrderBy(input.Sorting).PageBy(input).ToListAsync();
var dtos = suppliers.MapTo <List <CustomerListDto> >();
return(new PagedResultDto <CustomerListDto>(supplierCount, dtos));
}
public async Task <PagedResultOutput <CustomerListDto> > GetCustomerToList(GetCustomersInput input)
{
var lst = list.AsQueryable().WhereIf(!input.Filter.IsNullOrWhiteSpace(), x => x.FirstName.Contains(input.Filter)).
OrderBy(input.Sorting).PageBy(input);
var dtos = lst.MapTo <List <CustomerListDto> >();
return(new PagedResultOutput <CustomerListDto>(
list.Count,
dtos
));
}
public GetCustomersOutput GetCustomers(GetCustomersInput input)
{
var query = _customerRepository.GetAll();
/*
* if (input.State.HasFlag(1))
* {
*
* }
*/
return(new GetCustomersOutput
{
Customers = Mapper.Map <List <CustomerDto> >(query.ToList())
});
}
public ListResultOutput <CustomerListDto> GetCustomers(GetCustomersInput input)
{
var customers = this.customerRepository
.GetAll()
.WhereIf(
input.Filter != null,
p => p.FirstName.Contains(input.Filter) ||
p.LastName.Contains(input.Filter) ||
p.EmailAddress.Contains(input.Filter)
)
.OrderBy(p => p.FirstName)
.ThenBy(p => p.LastName)
.ToList();
return(new ListResultOutput <CustomerListDto>(customers.MapTo <List <CustomerListDto> >()));
}
/// <summary>
/// 获取所有客户
/// </summary>
/// <returns></returns>
public async Task <PagedResultDto <CustomerListDto> > GetCustomers(GetCustomersInput input)
{
var query = _customerManager
.Customeres
.WhereIf(!input.Name.IsNullOrWhiteSpace(), r => r.Name.Contains(input.Name))
.WhereIf(!input.PhoneNumber.IsNullOrWhiteSpace(), r => r.PhoneNumber.Contains(input.PhoneNumber))
.WhereIf(input.ConsumesForm > 0, r => r.TotalConsumes > input.ConsumesForm)
.WhereIf(input.ConsumesTo > 0, r => r.TotalConsumes < input.ConsumesTo);
var customerCount = await query.CountAsync();
var customers = await query
.OrderBy(input.Sorting)
.PageBy(input)
.ToListAsync();
var catalogyListDtos = ObjectMapper.Map <List <CustomerListDto> >(customers);
return(new PagedResultDto <CustomerListDto>(
customerCount,
catalogyListDtos));
}
/// <summary>
/// 获取Customer的分页列表信息
/// </summary>
/// <param name="input"></param>
/// <returns></returns>
public async Task <PagedResultDto <CustomerListDto> > GetPagedCustomers(GetCustomersInput input)
{
var query = _customerRepository.GetAll();
query = query.WhereIf(!input.Name.IsNullOrWhiteSpace(), c => c.Name.Contains(input.Name))
.WhereIf(!input.Family.IsNullOrWhiteSpace(), c => c.Family.Contains(input.Family))
.WhereIf(input.Level.HasValue, c => c.FamilyCode.Value == input.Level.Value);
var customerCount = await query.CountAsync();
var customers = await query
.OrderBy(input.Sorting)
.PageBy(input)
.ToListAsync();
//var customerListDtos = ObjectMapper.Map<List <CustomerListDto>>(customers);
var customerListDtos = customers.MapTo <List <CustomerListDto> >();
return(new PagedResultDto <CustomerListDto>(
customerCount,
customerListDtos
));
}
public async Task <PagedResultOutput <CustomerListDto> > GetCustomers(GetCustomersInput input)
{
PagedResultOutput <CustomerListDto> pagedResultOutput;
ParameterExpression parameterExpression;
if (input.Filter.Contains("id:"))
{
string filter = input.Filter;
char[] chrArray = new char[] { ':' };
long theId = long.Parse(filter.Split(chrArray)[1]);
IQueryable <Customer> all = _customerRepository.GetAll();
var customers = all.Where(m => m.Id == theId);
int num = await customers.CountAsync <Customer>();
List <Customer> listAsync = await customers.OrderBy <Customer>(input.Sorting, new object[0]).PageBy <Customer>(input).ToListAsync <Customer>();
pagedResultOutput = new PagedResultOutput <CustomerListDto>(num, listAsync.MapTo <List <CustomerListDto> >());
}
else
{
IQueryable <Address> addresses = this._addressRepository.GetAll();
var addresses1 = addresses.Include(i => i.Country);
var addresses2 = addresses1.Include(i => i.CountryRegion);
var addresses3 = addresses2.Where(m => (int?)m.TenantId == AbpSession.TenantId && m.OwnerType == "Customer");
var addresses4 = addresses3.WhereIf(!input.Filter.IsNullOrEmpty(),
p => p.Type.Contains(input.Filter) ||
p.Type.Contains(input.Filter) ||
p.PrimaryAddress.Contains(input.Filter) ||
p.SecondaryAddress.Contains(input.Filter) ||
p.City.Contains(input.Filter) ||
p.PostalCode.Contains(input.Filter) ||
p.ContactName.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));
var collection = await addresses4.Select(s => new
{
CustomerId = s.OwnerId
}).ToListAsync();
IQueryable <Phone> phones = this._phoneRepository.GetAll();
var phones1 = phones.Where(m => (int?)m.TenantId == AbpSession.TenantId && m.OwnerType == "Customer");
var phones2 = phones.WhereIf(!input.Filter.IsNullOrEmpty(),
p => p.Type.Contains(input.Filter) ||
p.PhoneNumber.Contains(input.Filter));
var listAsync1 = await phones2.Select(p => new
{
CustomerId = p.OwnerId
}).ToListAsync();
IQueryable <Customer> all1 = this._customerRepository.GetAll();
var customers1 = all1.WhereIf(!input.Filter.IsNullOrEmpty(), p =>
p.FirstName.Contains(input.Filter) ||
p.LastName.Contains(input.Filter) ||
p.BusinessName.Contains(input.Filter) ||
p.Email.Contains(input.Filter));
var listAsync2 = await customers1.Select(s => new
{
CustomerId = s.Id
}).ToListAsync();
List <long> list = (
from s in collection
select s.CustomerId).ToList();
IEnumerable <long> nums = list.Union((
from s in listAsync1
select s.CustomerId).ToList());
nums.Union((
from s in listAsync2
select s.CustomerId).ToList());
var all2 = _customerRepository.GetAll();
parameterExpression = Expression.Parameter(typeof(Customer), "m");
var customers2 = all2.Where(m => nums.Contains(m.Id));
int matchCount = await customers2.CountAsync();
List <Customer> listAsync3 = await customers2.OrderBy <Customer>(input.Sorting, new object[0]).PageBy <Customer>(input).ToListAsync <Customer>();
pagedResultOutput = new PagedResultOutput <CustomerListDto>(matchCount, listAsync3.MapTo <List <CustomerListDto> >());
}
return(pagedResultOutput);
}
/// <summary>
/// 根据查询条件获取客户资料管理分页列表
/// </summary>
public async Task <PagedResultDto <CustomersListDto> > GetPagedCustomerssAsync(GetCustomersInput input)
{
var query = _customersRepository.GetAll();
//TODO:根据传入的参数添加过滤条件
var customersCount = await query.CountAsync();
var customerss = await query
.OrderBy(input.Sorting)
.PageBy(input)
.ToListAsync();
var customersListDtos = customerss.MapTo <List <CustomersListDto> >();
return(new PagedResultDto <CustomersListDto>(
customersCount,
customersListDtos
));
}
public ActionResult Index(GetCustomersInput input)
{
return(base.View());
}
public async Task <GetCustomersOutput> GetCustomersAsync(GetCustomersInput input)
{
GetCustomersOutput output = await Orchestrator.Execute <GetCustomers, GetCustomersInput, GetCustomersOutput, GetCustomersValidator>(_customerManager, input);
return(output);
}
public async Task <PartialViewResult> CreateOrUpdateSpecificPriceModal(long productId, long?id = null)
{
int? nullable;
bool flag;
bool flag1;
ISpecificPriceAppService specificPriceAppService = this._specificPriceAppService;
NullableIdInput <long> nullableIdInput = new NullableIdInput <long>()
{
Id = id
};
GetProductSpecificPriceForEditOutput productSpecificPriceForEdit = await specificPriceAppService.GetProductSpecificPriceForEdit(nullableIdInput);
CreateOrUpdateSpecificPriceModalViewModel createOrUpdateSpecificPriceModalViewModel = new CreateOrUpdateSpecificPriceModalViewModel(productSpecificPriceForEdit);
Product product = await this._productAppService.GetProduct(productId);
createOrUpdateSpecificPriceModalViewModel.BaseCost = new decimal?(product.FinalPrice);
createOrUpdateSpecificPriceModalViewModel.QuantitySoldIn = product.QuantitySoldIn;
if (productSpecificPriceForEdit.SpecificPrice.ForCustomerId.HasValue)
{
ICustomerAppService customerAppService = this._customerAppService;
GetCustomersInput getCustomersInput = new GetCustomersInput()
{
MaxResultCount = 1,
Sorting = "FirstName",
SkipCount = 0
};
long value = productSpecificPriceForEdit.SpecificPrice.ForCustomerId.Value;
getCustomersInput.Filter = string.Concat("id:", value.ToString());
PagedResultOutput <CustomerListDto> customers = await customerAppService.GetCustomers(getCustomersInput);
createOrUpdateSpecificPriceModalViewModel.CurrentlySelectedCustomerName = string.Concat(customers.Items[0].FullName, " - ", customers.Items[0].Email);
}
List <SelectListItem> selectListItems = new List <SelectListItem>();
using (HttpClient httpClient = new HttpClient())
{
UrlHelper url = this.Url;
nullable = (createOrUpdateSpecificPriceModalViewModel.SpecificPrice.ForCountryId.HasValue ? createOrUpdateSpecificPriceModalViewModel.SpecificPrice.ForCountryId : new int?(0));
string str = url.RouteUrl("DefaultApiWithAction", new { httproute = "", controller = "Generic", action = "GetCountriesAsSelectListItems", countryId = 0, selectedCountryId = nullable }, this.Request.Url.Scheme);
using (HttpResponseMessage async = await httpClient.GetAsync(str))
{
if (async.IsSuccessStatusCode)
{
string str1 = await async.Content.ReadAsStringAsync();
selectListItems = JsonConvert.DeserializeObject <List <SelectListItem> >(str1);
}
}
}
List <SelectListItem> selectListItems1 = selectListItems;
SelectListItem selectListItem = new SelectListItem()
{
Text = "",
Value = "",
Disabled = false
};
selectListItems1.Insert(0, selectListItem);
this.ViewData["Countries"] = selectListItems.AsEnumerable <SelectListItem>();
List <OrganizationUnitDto> organizationUnitsByProperty = await this._organizationUnitAppService.GetOrganizationUnitsByProperty("SpecificPricesEnabled", "true");
List <SelectListItem> selectListItems2 = new List <SelectListItem>();
foreach (OrganizationUnitDto organizationUnitDto in organizationUnitsByProperty)
{
List <SelectListItem> selectListItems3 = selectListItems2;
SelectListItem selectListItem1 = new SelectListItem();
string displayName = organizationUnitDto.DisplayName;
int memberCount = organizationUnitDto.MemberCount;
selectListItem1.Text = string.Format("{0} ({1} {2})", displayName, memberCount.ToString(), this.L("OUMemberCount"));
selectListItem1.Value = organizationUnitDto.Id.ToString();
selectListItem1.Disabled = false;
selectListItem1.Group = null;
flag = (!createOrUpdateSpecificPriceModalViewModel.SpecificPrice.ForOrganizationalUnitId.HasValue || createOrUpdateSpecificPriceModalViewModel.SpecificPrice.ForOrganizationalUnitId.Value != organizationUnitDto.Id ? false : true);
selectListItem1.Selected = flag;
selectListItems3.Add(selectListItem1);
}
SelectListItem selectListItem2 = new SelectListItem()
{
Text = "",
Value = "",
Disabled = false
};
selectListItems2.Insert(0, selectListItem2);
this.ViewData["OrganizationUnits"] = selectListItems2.AsEnumerable <SelectListItem>();
IRepository <ProductOption, long> repository = this._productOptionRepository;
List <ProductOption> allListAsync = await repository.GetAllListAsync((ProductOption x) => x.ProductId == product.Id && x.IsActive);
List <ProductOption> productOptions = allListAsync;
List <SelectListItem> selectListItems4 = new List <SelectListItem>();
foreach (ProductOption productOption in productOptions)
{
List <SelectListItem> selectListItems5 = selectListItems4;
SelectListItem selectListItem3 = new SelectListItem()
{
Text = productOption.Name,
Value = productOption.Id.ToString(),
Disabled = false,
Group = null
};
flag1 = (!createOrUpdateSpecificPriceModalViewModel.SpecificPrice.ProductOptionId.HasValue || createOrUpdateSpecificPriceModalViewModel.SpecificPrice.ProductOptionId.Value != productOption.Id ? false : true);
selectListItem3.Selected = flag1;
selectListItems5.Add(selectListItem3);
}
SelectListItem selectListItem4 = new SelectListItem()
{
Text = "",
Value = "",
Disabled = false
};
selectListItems4.Insert(0, selectListItem4);
this.ViewData["ProductOptions"] = selectListItems4.AsEnumerable <SelectListItem>();
return(this.PartialView("_CreateOrUpdateSpecificPriceModal", createOrUpdateSpecificPriceModalViewModel));
}
