public CustomerAddressListModel FindCustomerAddressesListModel(int customerId, int index, int pageNo, int pageSize, string search)
{
var model = new CustomerAddressListModel();
// Do a case-insensitive search
model.GridIndex = index;
var allItems = db.FindCustomerAddresses(customerId)
.Where(ca => string.IsNullOrEmpty(search) ||
(ca.Street != null && ca.Street.ToLower().Contains(search.ToLower())) ||
(ca.City != null && ca.City.ToLower().Contains(search.ToLower())) ||
(ca.State != null && ca.State.ToLower().Contains(search.ToLower())) ||
(ca.Postcode != null && ca.Postcode.ToLower().Contains(search.ToLower())) ||
(ca.StreetLine1 != null && ca.StreetLine1.ToLower().Contains(search.ToLower())) ||
(ca.StreetLine2 != null && ca.StreetLine2.ToLower().Contains(search.ToLower())) ||
(ca.StreetLine3 != null && ca.StreetLine3.ToLower().Contains(search.ToLower())) ||
(ca.StreetLine4 != null && ca.StreetLine4.ToLower().Contains(search.ToLower())))
.OrderByDescending(ca => ca.DateStart)
.ThenByDescending(ca => ca.DateEnd)
.ThenBy(ca => ca.Street);
model.TotalRecords = allItems.Count();
foreach (var item in allItems.Skip((pageNo - 1) * pageSize)
.Take(pageSize))
{
var newItem = MapToModel(item);
newItem.AddressTypeText = (item.LOVItem_AddressType == null ? "" : item.LOVItem_AddressType.ItemText);
model.Items.Add(newItem);
}
return(model);
}
/// <summary>
/// Prepare paged customer address list model
/// </summary>
/// <param name="searchModel">Customer address search model</param>
/// <param name="customer">Customer</param>
/// <returns>Customer address list model</returns>
public virtual CustomerAddressListModel PrepareCustomerAddressListModel(CustomerAddressSearchModel searchModel, Customer customer)
{
if (searchModel == null)
{
throw new ArgumentNullException(nameof(searchModel));
}
if (customer == null)
{
throw new ArgumentNullException(nameof(customer));
}
//get customer addresses
var addresses = customer.Addresses
.OrderByDescending(address => address.CreatedOnUtc).ThenByDescending(address => address.Id).ToList();
//prepare list model
var model = new CustomerAddressListModel
{
Data = addresses.PaginationByRequestModel(searchModel).Select(address =>
{
//fill in model values from the entity
var addressModel = address.ToModel <AddressModel>();
//fill in additional values (not existing in the entity)
PrepareModelAddressHtml(addressModel, address);
return(addressModel);
}),
Total = addresses.Count
};
return(model);
}
public PartialViewResult ContactAddresses(int?languageId)
{
var customer = _workContext.CurrentCustomer;
var model = new CustomerAddressListModel();
foreach (var address in customer.Addresses)
{
if (address.Email == null)
{
_addressService.DeleteAddress(address);
continue;
}
var addressModel = new AddressModel();
addressModel.PrepareModel(address, false, _addressSettings, _localizationService,
_stateProvinceService, () => _countryService.GetAllCountries(), languageId: languageId);
model.Addresses.Add(addressModel);
}
model.MaxContactCount = _addressSettings.MaxContactCount;
model.AvailableCountries = new List <SelectListItem>();
model.AvailableCountries.Add(new SelectListItem()
{
Text = _localizationService.GetResource("Address.SelectCountry"), Value = "0"
});
foreach (var c in _countryService.GetAllCountries())
{
model.AvailableCountries.Add(new SelectListItem()
{
Text = c.GetLocalized(x => x.Name), Value = c.Id.ToString()
});
}
model.LanguageId = languageId.Value;
return(PartialView(model));
}
public virtual async Task <CustomerAddressListModel> PrepareCompanyCustomerAddressListModelAsync(CustomerAddressSearchModel searchModel, Company company)
{
if (searchModel == null)
{
throw new ArgumentNullException(nameof(searchModel));
}
if (company == null)
{
throw new ArgumentNullException(nameof(company));
}
var model = new CustomerAddressListModel();
var getCompanyCustomers = await _companyService.GetCompanyCustomersByCompanyIdAsync(company.Id);
IPagedList <Address> addressesList = new PagedList <Address>(new List <Address>(), 0, 1);
foreach (var getCompanyCustomer in getCompanyCustomers)
{
var customer = await _customerService.GetCustomerByIdAsync(getCompanyCustomer.CustomerId);
//get customer addresses
var addresses = (await _customerService.GetAddressesByCustomerIdAsync(customer.Id))
.OrderByDescending(address => address.CreatedOnUtc).ThenByDescending(address => address.Id).ToList()
.ToPagedList(searchModel);
foreach (var address in addresses)
{
if (!addressesList.Where(x => x.Id == address.Id).Any())
{
addressesList.Add(address);
}
}
searchModel.CustomerId = customer.Id;
}
//prepare list model
model = await new CustomerAddressListModel().PrepareToGridAsync(searchModel, addressesList, () =>
{
return(addressesList.SelectAwait(async address =>
{
//fill in model values from the entity
var addressModel = address.ToModel <AddressModel>();
var customerAddressMapping = await _customerService.GetCustomerAddressesByAddressIdAsync(address.Id);
addressModel.CustomerId = customerAddressMapping.Any() ? customerAddressMapping.FirstOrDefault().CustomerId : 0;
addressModel.CountryName = (await _countryService.GetCountryByAddressAsync(address))?.Name;
addressModel.StateProvinceName = (await _stateProvinceService.GetStateProvinceByAddressAsync(address))?.Name;
//fill in additional values (not existing in the entity)
await PrepareModelAddressHtmlAsync(addressModel, address);
return addressModel;
}));
});
return(model);
}
public CustomerAddressListModel FindCustomerAddressesListModel(int customerId)
{
var model = new CustomerAddressListModel();
foreach (var item in db.FindCustomerAddresses(customerId))
{
model.Items.Add(MapToModel(item));
}
return(model);
}
public ActionResult Delete(int index, int id)
{
var model = new CustomerAddressListModel();
model.GridIndex = index;
try {
CustomerService.DeleteCustomerAddress(id);
} catch (Exception e1) {
model.Error.SetError(e1);
}
return(Json(model, JsonRequestBehavior.AllowGet));
}
public virtual CustomerAddressListModel PrepareCustomerAddressListModel()
{
var addresses = _workContext.CurrentCustomer.Addresses
//enabled for the current store
.Where(a => a.Country == null || _storeMappingService.Authorize(a.Country))
.ToList();
var model = new CustomerAddressListModel();
foreach (var address in addresses)
{
var addressModel = new AddressModel();
_addressModelFactory.PrepareAddressModel(addressModel,
address: address,
excludeProperties: false,
addressSettings: _addressSettings,
loadCountries: () => _countryService.GetAllCountries(_workContext.WorkingLanguage.Id));
model.Addresses.Add(addressModel);
}
return(model);
}
public virtual CustomerAddressListModel PrepareAddressList(Customer customer)
{
var model = new CustomerAddressListModel();
var addresses = customer.Addresses
.Where(a => a.CountryId == "" ||
_storeMappingService.Authorize(_countryService.GetCountryById(a.CountryId))
)
.ToList();
foreach (var address in addresses)
{
var addressModel = new AddressModel();
_addressViewModelService.PrepareModel(model: addressModel,
address: address,
excludeProperties: false,
loadCountries: () => _countryService.GetAllCountries(_workContext.WorkingLanguage.Id));
model.Addresses.Add(addressModel);
}
return(model);
}
public ActionResult CompanyContacts()
{
var customer = _workContext.CurrentMiniSite.Customer;
var model = new CustomerAddressListModel();
foreach (var address in customer.Addresses)
{
if (address.Email == null)
{
_addressService.DeleteAddress(address);
continue;
}
var addressModel = new AddressModel();
addressModel.PrepareModel(address, false, _addressSettings, _localizationService,
_stateProvinceService, () => _countryService.GetAllCountries(), languageId: _workContext.WorkingLanguage.Id);
model.Addresses.Add(addressModel);
}
return(View(model));
}
public ActionResult Addresses()
{
if (!_workContext.CurrentCustomer.IsRegistered())
{
return(new HttpUnauthorizedResult());
}
var customer = _workContext.CurrentCustomer;
var model = new CustomerAddressListModel();
var addresses = customer.Addresses
.ToList();
foreach (var address in addresses)
{
var addressModel = new AddressModel();
PrepareModel(
model: addressModel,
address: address);
model.Addresses.Add(addressModel);
}
return(View(model));
}
public virtual async Task <CustomerAddressListModel> PrepareAddressList(Customer customer)
{
var model = new CustomerAddressListModel();
var addresses = new List <Address>();
foreach (var item in customer.Addresses)
{
if (string.IsNullOrEmpty(item.CountryId))
{
addresses.Add(item);
continue;
}
var country = await _countryService.GetCountryById(item.CountryId);
if (country != null || _storeMappingService.Authorize(country))
{
addresses.Add(item);
continue;
}
}
foreach (var address in addresses)
{
var countries = await _countryService.GetAllCountries(_workContext.WorkingLanguage.Id);
var addressModel = new AddressModel();
await _addressViewModelService.PrepareModel(model : addressModel,
address : address,
excludeProperties : false,
loadCountries : () => countries);
model.Addresses.Add(addressModel);
}
return(model);
}
