/// <summary>
/// Get pickup points for the address
/// </summary>
/// <param name="address">Address</param>
/// <returns>Represents a response of getting pickup points</returns>
public GetPickupPointsResponse GetPickupPoints(Address address)
{
var result = new GetPickupPointsResponse();
foreach (var point in _storePickupPointService.GetAllStorePickupPoints(_storeContext.CurrentStore.Id))
{
var pointAddress = _addressService.GetAddressById(point.AddressId);
if (pointAddress != null)
result.PickupPoints.Add(new PickupPoint
{
Id = point.Id.ToString(),
Name = point.Name,
Description = point.Description,
Address = pointAddress.Address1,
City = pointAddress.City,
CountryCode = pointAddress.Country != null ? pointAddress.Country.TwoLetterIsoCode : string.Empty,
ZipPostalCode = pointAddress.ZipPostalCode,
OpeningHours = point.OpeningHours,
PickupFee = point.PickupFee,
ProviderSystemName = PluginDescriptor.SystemName
});
}
if (result.PickupPoints.Count == 0)
result.AddError(_localizationService.GetResource("Plugins.Pickup.PickupInStore.NoPickupPoints"));
return result;
}
public void Can_save_and_load_address_with_stateProvince()
{
var address = new Address
{
FirstName = "FirstName 1",
LastName = "LastName 1",
Email = "Email 1",
Company = "Company 1",
City = "City 1",
Address1 = "Address1",
Address2 = "Address2",
ZipPostalCode = "ZipPostalCode 1",
PhoneNumber = "PhoneNumber 1",
FaxNumber = "FaxNumber 1",
CreatedOnUtc = new DateTime(2010, 01, 01),
Country = GetTestCountry(),
StateProvince = GetTestStateProvince(),
};
var fromDb = SaveAndLoadEntity(address);
fromDb.ShouldNotBeNull();
fromDb.StateProvince.ShouldNotBeNull();
fromDb.StateProvince.Name.ShouldEqual("California");
}
public static Address ToEntity(this AddressModel model)
{
if (model == null)
return null;
var entity = new Address();
return ToEntity(model, entity);
}
public void Can_add_address()
{
var customer = new Customer();
var address = new Address { Id = 1 };
customer.Addresses.Add(address);
customer.Addresses.Count.ShouldEqual(1);
customer.Addresses.First().Id.ShouldEqual(1);
}
/// <summary>
/// Deletes an address
/// </summary>
/// <param name="address">Address</param>
public virtual void DeleteAddress(Address address)
{
if (address == null)
throw new ArgumentNullException("address");
_addressRepository.Delete(address);
//event notification
_eventPublisher.EntityDeleted(address);
}
/// <summary>
/// Deletes an address
/// </summary>
/// <param name="address">Address</param>
public virtual void DeleteAddress(Address address)
{
if (address == null)
throw new ArgumentNullException("address");
_addressRepository.Delete(address);
//cache
_cacheManager.RemoveByPattern(ADDRESSES_PATTERN_KEY);
//event notification
_eventPublisher.EntityDeleted(address);
}
public void Can_remove_address_assigned_as_billing_address()
{
var customer = new Customer();
var address = new Address { Id = 1 };
customer.Addresses.Add(address);
customer.BillingAddress = address;
customer.BillingAddress.ShouldBeTheSameAs(customer.Addresses.First());
customer.RemoveAddress(address);
customer.Addresses.Count.ShouldEqual(0);
customer.BillingAddress.ShouldBeNull();
}
public void Can_not_add_duplicate_addresses()
{
var customer = new Customer();
var address = new Address { Id = 1 };
var address2 = new Address { Id = 2 };
customer.AddAddress(address);
customer.AddAddress(address); // should not add
customer.AddAddress(address2);
customer.Addresses.Count.ShouldEqual(2);
var addresses = customer.Addresses.ToList();
addresses[0].Id.ShouldEqual(1);
addresses[1].Id.ShouldEqual(2);
}
/// <summary>
/// Create shipment package from shopping cart
/// </summary>
/// <param name="cart">Shopping cart</param>
/// <param name="shippingAddress">Shipping address</param>
/// <returns>Shipment package</returns>
public virtual GetShippingOptionRequest CreateShippingOptionRequest(IList<ShoppingCartItem> cart,
Address shippingAddress)
{
var request = new GetShippingOptionRequest();
request.Customer = cart.GetCustomer();
request.Items = new List<ShoppingCartItem>();
foreach (var sc in cart)
if (sc.IsShipEnabled)
request.Items.Add(sc);
request.ShippingAddress = shippingAddress;
//TODO set values from warehouses or shipping origin
request.CountryFrom = null;
request.StateProvinceFrom = null;
request.ZipPostalCodeFrom = string.Empty;
return request;
}
public void Can_clone_address()
{
var address = new Address
{
Id = 1,
FirstName = "FirstName 1",
LastName = "LastName 1",
Email = "Email 1",
Company = "Company 1",
CountryId = 3,
Country = new Country() { Id = 3, Name = "United States" },
StateProvinceId = 4,
StateProvince = new StateProvince() { Id = 4, Name = "LA" },
City = "City 1",
Address1 = "Address1",
Address2 = "Address2",
ZipPostalCode = "ZipPostalCode 1",
PhoneNumber = "PhoneNumber 1",
FaxNumber = "FaxNumber 1",
CreatedOnUtc = new DateTime(2010, 01, 01),
};
var newAddress = address.Clone() as Address;
newAddress.ShouldNotBeNull();
newAddress.Id.ShouldEqual(0);
newAddress.FirstName.ShouldEqual("FirstName 1");
newAddress.LastName.ShouldEqual("LastName 1");
newAddress.Email.ShouldEqual("Email 1");
newAddress.Company.ShouldEqual("Company 1");
newAddress.City.ShouldEqual("City 1");
newAddress.Address1.ShouldEqual("Address1");
newAddress.Address2.ShouldEqual("Address2");
newAddress.ZipPostalCode.ShouldEqual("ZipPostalCode 1");
newAddress.PhoneNumber.ShouldEqual("PhoneNumber 1");
newAddress.FaxNumber.ShouldEqual("FaxNumber 1");
newAddress.CreatedOnUtc.ShouldEqual(new DateTime(2010, 01, 01));
newAddress.Country.ShouldNotBeNull();
newAddress.CountryId.ShouldEqual(3);
newAddress.Country.Name.ShouldEqual("United States");
newAddress.StateProvince.ShouldNotBeNull();
newAddress.StateProvinceId.ShouldEqual(4);
newAddress.StateProvince.Name.ShouldEqual("LA");
}
public void Can_save_and_load_customer_with_address()
{
var customer = GetTestCustomer();
var address = new Address
{
FirstName = "Test",
Country = GetTestCountry(),
CreatedOnUtc = new DateTime(2010, 01, 01),
};
customer.AddAddress(address);
var fromDb = SaveAndLoadEntity(customer);
fromDb.ShouldNotBeNull();
fromDb.Addresses.Count.ShouldEqual(1);
fromDb.Addresses.First().FirstName.ShouldEqual("Test");
}
public void Can_remove_a_customer_address()
{
var customer = GetTestCustomer();
var address = new Address { FirstName = "Test", Country = GetTestCountry(), CreatedOnUtc = new DateTime(2010, 01, 01) };
customer.AddAddress(address);
customer.SetBillingAddress(address);
var fromDb = SaveAndLoadEntity(customer);
fromDb.ShouldNotBeNull();
fromDb.Addresses.Count.ShouldEqual(1);
fromDb.BillingAddress.ShouldNotBeNull();
fromDb.RemoveAddress(address);
context.SaveChanges();
fromDb.Addresses.Count.ShouldEqual(0);
fromDb.BillingAddress.ShouldBeNull();
}
public static Address ToEntity(this AddressModel model, Address destination)
{
if (model == null)
return destination;
destination.Id = model.Id;
destination.FirstName = model.FirstName;
destination.LastName = model.LastName;
destination.Email = model.Email;
destination.Company = model.Company;
destination.CountryId = model.CountryId;
destination.StateProvinceId = model.StateProvinceId;
destination.City = model.City;
destination.Address1 = model.Address1;
destination.Address2 = model.Address2;
destination.ZipPostalCode = model.ZipPostalCode;
destination.PhoneNumber = model.PhoneNumber;
destination.FaxNumber = model.FaxNumber;
return destination;
}
public void Can_save_and_load_address()
{
var address = new Address
{
FirstName = "FirstName 1",
LastName = "LastName 1",
Email = "Email 1",
Company = "Company 1",
City = "City 1",
Address1 = "Address1",
Address2 = "Address2",
ZipPostalCode = "ZipPostalCode 1",
PhoneNumber = "PhoneNumber 1",
FaxNumber = "FaxNumber 1",
CustomAttributes = "CustomAttributes 1",
CreatedOnUtc = new DateTime(2010, 01, 01),
Country = GetTestCountry()
};
var fromDb = SaveAndLoadEntity(address);
fromDb.ShouldNotBeNull();
fromDb.FirstName.ShouldEqual("FirstName 1");
fromDb.LastName.ShouldEqual("LastName 1");
fromDb.Email.ShouldEqual("Email 1");
fromDb.Company.ShouldEqual("Company 1");
fromDb.City.ShouldEqual("City 1");
fromDb.Address1.ShouldEqual("Address1");
fromDb.Address2.ShouldEqual("Address2");
fromDb.ZipPostalCode.ShouldEqual("ZipPostalCode 1");
fromDb.PhoneNumber.ShouldEqual("PhoneNumber 1");
fromDb.FaxNumber.ShouldEqual("FaxNumber 1");
fromDb.CustomAttributes.ShouldEqual("CustomAttributes 1");
fromDb.CreatedOnUtc.ShouldEqual(new DateTime(2010, 01, 01));
fromDb.Country.ShouldNotBeNull();
fromDb.Country.Name.ShouldEqual("United States");
}
public ActionResult GetEstimateShipping(EstimateShippingModel shippingModel, FormCollection form)
{
var cart = _workContext.CurrentCustomer.ShoppingCartItems
.Where(sci => sci.ShoppingCartType == ShoppingCartType.ShoppingCart)
.LimitPerStore(_storeContext.CurrentStore.Id)
.ToList();
//parse and save checkout attributes
ParseAndSaveCheckoutAttributes(cart, form);
var model = new ShoppingCartModel();
model.EstimateShipping.CountryId = shippingModel.CountryId;
model.EstimateShipping.StateProvinceId = shippingModel.StateProvinceId;
model.EstimateShipping.ZipPostalCode = shippingModel.ZipPostalCode;
PrepareShoppingCartModel(model, cart,setEstimateShippingDefaultAddress: false);
if (cart.RequiresShipping())
{
var address = new Address()
{
CountryId = shippingModel.CountryId,
Country = shippingModel.CountryId.HasValue ? _countryService.GetCountryById(shippingModel.CountryId.Value) : null,
StateProvinceId = shippingModel.StateProvinceId,
StateProvince = shippingModel.StateProvinceId.HasValue ? _stateProvinceService.GetStateProvinceById(shippingModel.StateProvinceId.Value) : null,
ZipPostalCode = shippingModel.ZipPostalCode,
};
GetShippingOptionResponse getShippingOptionResponse = _shippingService
.GetShippingOptions(cart, address, "", _storeContext.CurrentStore.Id);
if (!getShippingOptionResponse.Success)
{
foreach (var error in getShippingOptionResponse.Errors)
model.EstimateShipping.Warnings.Add(error);
}
else
{
if (getShippingOptionResponse.ShippingOptions.Count > 0)
{
foreach (var shippingOption in getShippingOptionResponse.ShippingOptions)
{
var soModel = new EstimateShippingModel.ShippingOptionModel()
{
Name = shippingOption.Name,
Description = shippingOption.Description,
};
//calculate discounted and taxed rate
Discount appliedDiscount = null;
decimal shippingTotal = _orderTotalCalculationService.AdjustShippingRate(shippingOption.Rate,
cart, out appliedDiscount);
decimal rateBase = _taxService.GetShippingPrice(shippingTotal, _workContext.CurrentCustomer);
decimal rate = _currencyService.ConvertFromPrimaryStoreCurrency(rateBase, _workContext.WorkingCurrency);
soModel.Price = _priceFormatter.FormatShippingPrice(rate, true);
model.EstimateShipping.ShippingOptions.Add(soModel);
}
//pickup in store?
if (_shippingSettings.AllowPickUpInStore)
{
var soModel = new EstimateShippingModel.ShippingOptionModel()
{
Name = _localizationService.GetResource("Checkout.PickUpInStore"),
Description = _localizationService.GetResource("Checkout.PickUpInStore.Description"),
Price = _priceFormatter.FormatShippingPrice(decimal.Zero, true)
};
model.EstimateShipping.ShippingOptions.Add(soModel);
}
}
else
{
model.EstimateShipping.Warnings.Add(_localizationService.GetResource("Checkout.ShippingIsNotAllowed"));
}
}
}
return View(model);
}
/// <summary>
/// Updates the address
/// </summary>
/// <param name="address">Address</param>
public virtual void UpdateAddress(Address address)
{
if (address == null)
throw new ArgumentNullException("address");
//some validation
if (address.CountryId == 0)
address.CountryId = null;
if (address.StateProvinceId == 0)
address.StateProvinceId = null;
_addressRepository.Update(address);
//event notification
_eventPublisher.EntityUpdated(address);
}
/// <summary>
/// Gets a value indicating whether EU VAT exempt (the European Union Value Added Tax)
/// </summary>
/// <param name="address">Address</param>
/// <param name="customer">Customer</param>
/// <returns>Result</returns>
public virtual bool IsVatExempt(Address address, Customer customer)
{
if (!_taxSettings.EuVatEnabled)
return false;
if (address == null || address.Country == null || customer == null)
return false;
if (!address.Country.SubjectToVat)
// VAT not chargeable if shipping outside VAT zone
return true;
// VAT not chargeable if address, customer and config meet our VAT exemption requirements:
// returns true if this customer is VAT exempt because they are shipping within the EU but outside our shop country, they have supplied a validated VAT number, and the shop is configured to allow VAT exemption
var customerVatStatus = (VatNumberStatus) customer.GetAttribute<int>(SystemCustomerAttributeNames.VatNumberStatusId);
return address.CountryId != _taxSettings.EuVatShopCountryId &&
customerVatStatus == VatNumberStatus.Valid &&
_taxSettings.EuVatAllowVatExemption;
}
public virtual void RemoveAddress(Address address)
{
if (this.Addresses.Contains(address))
{
if (this.BillingAddress == address) this.BillingAddress = null;
if (this.ShippingAddress == address) this.ShippingAddress = null;
this.Addresses.Remove(address);
}
}
public void Can_set_default_billing_and_shipping_address()
{
var customer = GetTestCustomer();
var address = new Address { FirstName = "Billing", Country = GetTestCountry(), CreatedOnUtc = new DateTime(2010, 01, 01) };
var address2 = new Address { FirstName = "Shipping", Country = GetTestCountry(), CreatedOnUtc = new DateTime(2010, 01, 01) };
customer.AddAddress(address);
customer.AddAddress(address2);
customer.SetBillingAddress(address);
customer.SetShippingAddress(address2);
var fromDb = SaveAndLoadEntity(customer);
fromDb.ShouldNotBeNull();
fromDb.Addresses.Count.ShouldEqual(2);
fromDb.BillingAddress.FirstName.ShouldEqual("Billing");
fromDb.ShippingAddress.FirstName.ShouldEqual("Shipping");
var addresses = fromDb.Addresses.ToList();
fromDb.BillingAddress.ShouldBeTheSameAs(addresses[0]);
fromDb.ShippingAddress.ShouldBeTheSameAs(addresses[1]);
}
/// <summary>
/// Get the nearest warehouse for the specified address
/// </summary>
/// <param name="address">Address</param>
/// <param name="warehouses">List of warehouses, if null all warehouses are used.</param>
/// <returns></returns>
public virtual Warehouse GetNearestWarehouse(Address address, IList<Warehouse> warehouses = null)
{
warehouses = warehouses ?? GetAllWarehouses();
//no address specified. return any
if (address == null)
return warehouses.FirstOrDefault();
//of course, we should use some better logic to find nearest warehouse
//but we don't have a built-in geographic database which supports "distance" functionality
//that's why we simply look for exact matches
//find by country
var matchedByCountry = new List<Warehouse>();
foreach (var warehouse in warehouses)
{
var warehouseAddress = _addressService.GetAddressById(warehouse.AddressId);
if (warehouseAddress != null)
if (warehouseAddress.CountryId == address.CountryId)
matchedByCountry.Add(warehouse);
}
//no country matches. return any
if (!matchedByCountry.Any())
return warehouses.FirstOrDefault();
//find by state
var matchedByState = new List<Warehouse>();
foreach (var warehouse in matchedByCountry)
{
var warehouseAddress = _addressService.GetAddressById(warehouse.AddressId);
if (warehouseAddress != null)
if (warehouseAddress.StateProvinceId == address.StateProvinceId)
matchedByState.Add(warehouse);
}
if (matchedByState.Any())
return matchedByState.FirstOrDefault();
//no state matches. return any
return matchedByCountry.FirstOrDefault();
}
public virtual void AddAddress(Address address)
{
if (!this.Addresses.Contains(address))
this.Addresses.Add(address);
}
/// <summary>
/// Create shipment packages (requests) from shopping cart
/// </summary>
/// <param name="cart">Shopping cart</param>
/// <param name="shippingAddress">Shipping address</param>
/// <param name="storeId">Load records allowed only in a specified store; pass 0 to load all records</param>
/// <param name="shippingFromMultipleLocations">Value indicating whether shipping is done from multiple locations (warehouses)</param>
/// <returns>Shipment packages (requests)</returns>
public virtual IList<GetShippingOptionRequest> CreateShippingOptionRequests(IList<ShoppingCartItem> cart,
Address shippingAddress, int storeId, out bool shippingFromMultipleLocations)
{
//if we always ship from the default shipping origin, then there's only one request
//if we ship from warehouses ("ShippingSettings.UseWarehouseLocation" enabled),
//then there could be several requests
//key - warehouse identifier (0 - default shipping origin)
//value - request
var requests = new Dictionary<int, GetShippingOptionRequest>();
//a list of requests with products which should be shipped separately
var separateRequests = new List<GetShippingOptionRequest>();
foreach (var sci in cart)
{
if (!sci.IsShipEnabled)
continue;
var product = sci.Product;
//warehouses
Warehouse warehouse = null;
if (_shippingSettings.UseWarehouseLocation)
{
if (product.ManageInventoryMethod == ManageInventoryMethod.ManageStock &&
product.UseMultipleWarehouses)
{
var allWarehouses = new List<Warehouse>();
//multiple warehouses supported
foreach (var pwi in product.ProductWarehouseInventory)
{
//TODO validate stock quantity when backorder is not allowed?
var tmpWarehouse = GetWarehouseById(pwi.WarehouseId);
if (tmpWarehouse != null)
allWarehouses.Add(tmpWarehouse);
}
warehouse = GetNearestWarehouse(shippingAddress, allWarehouses);
}
else
{
//multiple warehouses are not supported
warehouse = GetWarehouseById(product.WarehouseId);
}
}
int warehouseId = warehouse != null ? warehouse.Id : 0;
if (requests.ContainsKey(warehouseId) && !product.ShipSeparately)
{
//add item to existing request
requests[warehouseId].Items.Add(new GetShippingOptionRequest.PackageItem(sci));
}
else
{
//create a new request
var request = new GetShippingOptionRequest();
//store
request.StoreId = storeId;
//add item
request.Items.Add(new GetShippingOptionRequest.PackageItem(sci));
//customer
request.Customer = cart.GetCustomer();
//ship to
request.ShippingAddress = shippingAddress;
//ship from
Address originAddress = null;
if (warehouse != null)
{
//warehouse address
originAddress = _addressService.GetAddressById(warehouse.AddressId);
request.WarehouseFrom = warehouse;
}
if (originAddress == null)
{
//no warehouse address. in this case use the default shipping origin
originAddress = _addressService.GetAddressById(_shippingSettings.ShippingOriginAddressId);
}
if (originAddress != null)
{
request.CountryFrom = originAddress.Country;
request.StateProvinceFrom = originAddress.StateProvince;
request.ZipPostalCodeFrom = originAddress.ZipPostalCode;
request.CityFrom = originAddress.City;
request.AddressFrom = originAddress.Address1;
}
if (product.ShipSeparately)
{
//ship separately
separateRequests.Add(request);
}
else
{
//usual request
requests.Add(warehouseId, request);
}
}
}
//multiple locations?
//currently we just compare warehouses
//but we should also consider cases when several warehouses are located in the same address
shippingFromMultipleLocations = requests.Select(x => x.Key).Distinct().Count() > 1;
var result = requests.Values.ToList();
result.AddRange(separateRequests);
return result;
}
public virtual void SetShippingAddress(Address address)
{
if (address != null)
{
if (this.Addresses.Contains(address))
this.ShippingAddress = address;
}
else
{
this.ShippingAddress = address;
}
}
/// <summary>
/// Gets available shipping options
/// </summary>
/// <param name="cart">Shopping cart</param>
/// <param name="shippingAddress">Shipping address</param>
/// <param name="allowedShippingRateComputationMethodSystemName">Filter by shipping rate computation method identifier; null to load shipping options of all shipping rate computation methods</param>
/// <param name="storeId">Load records allowed only in a specified store; pass 0 to load all records</param>
/// <returns>Shipping options</returns>
public virtual GetShippingOptionResponse GetShippingOptions(IList<ShoppingCartItem> cart,
Address shippingAddress, string allowedShippingRateComputationMethodSystemName = "",
int storeId = 0)
{
if (cart == null)
throw new ArgumentNullException("cart");
var result = new GetShippingOptionResponse();
//create a package
bool shippingFromMultipleLocations;
var shippingOptionRequests = CreateShippingOptionRequests(cart, shippingAddress, storeId, out shippingFromMultipleLocations);
result.ShippingFromMultipleLocations = shippingFromMultipleLocations;
var shippingRateComputationMethods = LoadActiveShippingRateComputationMethods(storeId);
//filter by system name
if (!String.IsNullOrWhiteSpace(allowedShippingRateComputationMethodSystemName))
{
shippingRateComputationMethods = shippingRateComputationMethods
.Where(srcm => allowedShippingRateComputationMethodSystemName.Equals(srcm.PluginDescriptor.SystemName, StringComparison.InvariantCultureIgnoreCase))
.ToList();
}
if (!shippingRateComputationMethods.Any())
//throw new NopException("Shipping rate computation method could not be loaded");
return result;
//request shipping options from each shipping rate computation methods
foreach (var srcm in shippingRateComputationMethods)
{
//request shipping options (separately for each package-request)
IList<ShippingOption> srcmShippingOptions = null;
foreach (var shippingOptionRequest in shippingOptionRequests)
{
var getShippingOptionResponse = srcm.GetShippingOptions(shippingOptionRequest);
if (getShippingOptionResponse.Success)
{
//success
if (srcmShippingOptions == null)
{
//first shipping option request
srcmShippingOptions = getShippingOptionResponse.ShippingOptions;
}
else
{
//get shipping options which already exist for prior requested packages for this scrm (i.e. common options)
srcmShippingOptions = srcmShippingOptions
.Where(existingso => getShippingOptionResponse.ShippingOptions.Any(newso => newso.Name == existingso.Name))
.ToList();
//and sum the rates
foreach (var existingso in srcmShippingOptions)
{
existingso.Rate += getShippingOptionResponse
.ShippingOptions
.First(newso => newso.Name == existingso.Name)
.Rate;
}
}
}
else
{
//errors
foreach (string error in getShippingOptionResponse.Errors)
{
result.AddError(error);
_logger.Warning(string.Format("Shipping ({0}). {1}", srcm.PluginDescriptor.FriendlyName, error));
}
//clear the shipping options in this case
srcmShippingOptions = new List<ShippingOption>();
break;
}
}
//add this scrm's options to the result
if (srcmShippingOptions != null)
{
foreach (var so in srcmShippingOptions)
{
//set system name if not set yet
if (String.IsNullOrEmpty(so.ShippingRateComputationMethodSystemName))
so.ShippingRateComputationMethodSystemName = srcm.PluginDescriptor.SystemName;
if (_shoppingCartSettings.RoundPricesDuringCalculation)
so.Rate = RoundingHelper.RoundPrice(so.Rate);
result.ShippingOptions.Add(so);
}
}
}
if (_shippingSettings.ReturnValidOptionsIfThereAreAny)
{
//return valid options if there are any (no matter of the errors returned by other shipping rate compuation methods).
if (result.ShippingOptions.Any() && result.Errors.Any())
result.Errors.Clear();
}
//no shipping options loaded
if (!result.ShippingOptions.Any() && !result.Errors.Any())
result.Errors.Add(_localizationService.GetResource("Checkout.ShippingOptionCouldNotBeLoaded"));
return result;
}
/// <summary>
/// Inserts an address
/// </summary>
/// <param name="address">Address</param>
public virtual void InsertAddress(Address address)
{
if (address == null)
throw new ArgumentNullException("address");
address.CreatedOnUtc = DateTime.UtcNow;
//some validation
if (address.CountryId == 0)
address.CountryId = null;
if (address.StateProvinceId == 0)
address.StateProvinceId = null;
_addressRepository.Insert(address);
//event notification
_eventPublisher.EntityInserted(address);
}
/// <summary>
/// Gets available pickup points
/// </summary>
/// <param name="address">Address</param>
/// <param name="providerSystemName">Filter by provider identifier; null to load pickup points of all providers</param>
/// <param name="storeId">Load records allowed only in a specified store; pass 0 to load all records</param>
/// <returns>Pickup points</returns>
public virtual GetPickupPointsResponse GetPickupPoints(Address address, string providerSystemName = null, int storeId = 0)
{
var result = new GetPickupPointsResponse();
var pickupPointsProviders = LoadActivePickupPointProviders(storeId);
if (!string.IsNullOrEmpty(providerSystemName))
pickupPointsProviders = pickupPointsProviders
.Where(x => x.PluginDescriptor.SystemName.Equals(providerSystemName, StringComparison.InvariantCultureIgnoreCase)).ToList();
if (pickupPointsProviders.Count == 0)
return result;
var allPickupPoints = new List<PickupPoint>();
foreach (var provider in pickupPointsProviders)
{
var pickPointsResponse = provider.GetPickupPoints(address);
if (pickPointsResponse.Success)
allPickupPoints.AddRange(pickPointsResponse.PickupPoints);
else
{
foreach (string error in pickPointsResponse.Errors)
{
result.AddError(error);
_logger.Warning(string.Format("PickupPoints ({0}). {1}", provider.PluginDescriptor.FriendlyName, error));
}
}
}
//any pickup points is enough
if (allPickupPoints.Count > 0)
{
result.Errors.Clear();
result.PickupPoints = allPickupPoints;
}
return result;
}
/// <summary>
/// Gets a value indicating whether address is valid (can be saved)
/// </summary>
/// <param name="address">Address to validate</param>
/// <returns>Result</returns>
public virtual bool IsAddressValid(Address address)
{
if (address == null)
throw new ArgumentNullException("address");
if (String.IsNullOrWhiteSpace(address.FirstName))
return false;
if (String.IsNullOrWhiteSpace(address.LastName))
return false;
if (String.IsNullOrWhiteSpace(address.PhoneNumber))
return false;
if (String.IsNullOrWhiteSpace(address.Email))
return false;
if (String.IsNullOrWhiteSpace(address.Address1))
return false;
if (String.IsNullOrWhiteSpace(address.City))
return false;
if (String.IsNullOrWhiteSpace(address.ZipPostalCode))
return false;
if (address.CountryId == null || address.CountryId.Value == 0)
return false;
var country = _countryService.GetCountryById(address.CountryId.Value);
if (country == null)
return false;
var states = _stateProvinceService.GetStateProvincesByCountryId(country.Id);
if (states.Count > 0)
{
if (address.StateProvinceId == null || address.StateProvinceId.Value == 0)
return false;
var state = _stateProvinceService.GetStateProvinceById(address.StateProvinceId.Value);
if (state == null)
return false;
}
return true;
}
public ActionResult Register(RegisterModel model, string returnUrl, bool captchaValid, FormCollection form)
{
//check whether registration is allowed
if (_customerSettings.UserRegistrationType == UserRegistrationType.Disabled)
return RedirectToRoute("RegisterResult", new { resultId = (int)UserRegistrationType.Disabled });
if (_workContext.CurrentCustomer.IsRegistered())
{
//Already registered customer.
_authenticationService.SignOut();
//Save a new record
_workContext.CurrentCustomer = _customerService.InsertGuestCustomer();
}
var customer = _workContext.CurrentCustomer;
//custom customer attributes
var customerAttributesXml = ParseCustomCustomerAttributes(form);
var customerAttributeWarnings = _customerAttributeParser.GetAttributeWarnings(customerAttributesXml);
foreach (var error in customerAttributeWarnings)
{
ModelState.AddModelError("", error);
}
//validate CAPTCHA
if (_captchaSettings.Enabled && _captchaSettings.ShowOnRegistrationPage && !captchaValid)
{
ModelState.AddModelError("", _localizationService.GetResource("Common.WrongCaptcha"));
}
if (ModelState.IsValid)
{
if (_customerSettings.UsernamesEnabled && model.Username != null)
{
model.Username = model.Username.Trim();
}
bool isApproved = _customerSettings.UserRegistrationType == UserRegistrationType.Standard;
var registrationRequest = new CustomerRegistrationRequest(customer,
model.Email,
_customerSettings.UsernamesEnabled ? model.Username : model.Email,
model.Password,
_customerSettings.DefaultPasswordFormat,
_storeContext.CurrentStore.Id,
isApproved);
var registrationResult = _customerRegistrationService.RegisterCustomer(registrationRequest);
if (registrationResult.Success)
{
//properties
if (_dateTimeSettings.AllowCustomersToSetTimeZone)
{
_genericAttributeService.SaveAttribute(customer, SystemCustomerAttributeNames.TimeZoneId, model.TimeZoneId);
}
//VAT number
if (_taxSettings.EuVatEnabled)
{
_genericAttributeService.SaveAttribute(customer, SystemCustomerAttributeNames.VatNumber, model.VatNumber);
string vatName;
string vatAddress;
var vatNumberStatus = _taxService.GetVatNumberStatus(model.VatNumber, out vatName, out vatAddress);
_genericAttributeService.SaveAttribute(customer,
SystemCustomerAttributeNames.VatNumberStatusId,
(int)vatNumberStatus);
//send VAT number admin notification
if (!String.IsNullOrEmpty(model.VatNumber) && _taxSettings.EuVatEmailAdminWhenNewVatSubmitted)
_workflowMessageService.SendNewVatSubmittedStoreOwnerNotification(customer, model.VatNumber, vatAddress, _localizationSettings.DefaultAdminLanguageId);
}
//form fields
if (_customerSettings.GenderEnabled)
_genericAttributeService.SaveAttribute(customer, SystemCustomerAttributeNames.Gender, model.Gender);
_genericAttributeService.SaveAttribute(customer, SystemCustomerAttributeNames.FirstName, model.FirstName);
_genericAttributeService.SaveAttribute(customer, SystemCustomerAttributeNames.LastName, model.LastName);
if (_customerSettings.DateOfBirthEnabled)
{
DateTime? dateOfBirth = model.ParseDateOfBirth();
_genericAttributeService.SaveAttribute(customer, SystemCustomerAttributeNames.DateOfBirth, dateOfBirth);
}
if (_customerSettings.CompanyEnabled)
_genericAttributeService.SaveAttribute(customer, SystemCustomerAttributeNames.Company, model.Company);
if (_customerSettings.StreetAddressEnabled)
_genericAttributeService.SaveAttribute(customer, SystemCustomerAttributeNames.StreetAddress, model.StreetAddress);
if (_customerSettings.StreetAddress2Enabled)
_genericAttributeService.SaveAttribute(customer, SystemCustomerAttributeNames.StreetAddress2, model.StreetAddress2);
if (_customerSettings.ZipPostalCodeEnabled)
_genericAttributeService.SaveAttribute(customer, SystemCustomerAttributeNames.ZipPostalCode, model.ZipPostalCode);
if (_customerSettings.CityEnabled)
_genericAttributeService.SaveAttribute(customer, SystemCustomerAttributeNames.City, model.City);
if (_customerSettings.CountryEnabled)
_genericAttributeService.SaveAttribute(customer, SystemCustomerAttributeNames.CountryId, model.CountryId);
if (_customerSettings.CountryEnabled && _customerSettings.StateProvinceEnabled)
_genericAttributeService.SaveAttribute(customer, SystemCustomerAttributeNames.StateProvinceId, model.StateProvinceId);
if (_customerSettings.PhoneEnabled)
_genericAttributeService.SaveAttribute(customer, SystemCustomerAttributeNames.Phone, model.Phone);
if (_customerSettings.FaxEnabled)
_genericAttributeService.SaveAttribute(customer, SystemCustomerAttributeNames.Fax, model.Fax);
//newsletter
if (_customerSettings.NewsletterEnabled)
{
//save newsletter value
var newsletter = _newsLetterSubscriptionService.GetNewsLetterSubscriptionByEmailAndStoreId(model.Email, _storeContext.CurrentStore.Id);
if (newsletter != null)
{
if (model.Newsletter)
{
newsletter.Active = true;
_newsLetterSubscriptionService.UpdateNewsLetterSubscription(newsletter);
}
//else
//{
//When registering, not checking the newsletter check box should not take an existing email address off of the subscription list.
//_newsLetterSubscriptionService.DeleteNewsLetterSubscription(newsletter);
//}
}
else
{
if (model.Newsletter)
{
_newsLetterSubscriptionService.InsertNewsLetterSubscription(new NewsLetterSubscription
{
NewsLetterSubscriptionGuid = Guid.NewGuid(),
Email = model.Email,
Active = true,
StoreId = _storeContext.CurrentStore.Id,
CreatedOnUtc = DateTime.UtcNow
});
}
}
}
//save customer attributes
_genericAttributeService.SaveAttribute(customer, SystemCustomerAttributeNames.CustomCustomerAttributes, customerAttributesXml);
//login customer now
if (isApproved)
_authenticationService.SignIn(customer, true);
//associated with external account (if possible)
TryAssociateAccountWithExternalAccount(customer);
//insert default address (if possible)
var defaultAddress = new Address
{
FirstName = customer.GetAttribute<string>(SystemCustomerAttributeNames.FirstName),
LastName = customer.GetAttribute<string>(SystemCustomerAttributeNames.LastName),
Email = customer.Email,
Company = customer.GetAttribute<string>(SystemCustomerAttributeNames.Company),
CountryId = customer.GetAttribute<int>(SystemCustomerAttributeNames.CountryId) > 0 ?
(int?)customer.GetAttribute<int>(SystemCustomerAttributeNames.CountryId) : null,
StateProvinceId = customer.GetAttribute<int>(SystemCustomerAttributeNames.StateProvinceId) > 0 ?
(int?)customer.GetAttribute<int>(SystemCustomerAttributeNames.StateProvinceId) : null,
City = customer.GetAttribute<string>(SystemCustomerAttributeNames.City),
Address1 = customer.GetAttribute<string>(SystemCustomerAttributeNames.StreetAddress),
Address2 = customer.GetAttribute<string>(SystemCustomerAttributeNames.StreetAddress2),
ZipPostalCode = customer.GetAttribute<string>(SystemCustomerAttributeNames.ZipPostalCode),
PhoneNumber = customer.GetAttribute<string>(SystemCustomerAttributeNames.Phone),
FaxNumber = customer.GetAttribute<string>(SystemCustomerAttributeNames.Fax),
CreatedOnUtc = customer.CreatedOnUtc
};
if (this._addressService.IsAddressValid(defaultAddress))
{
//some validation
if (defaultAddress.CountryId == 0)
defaultAddress.CountryId = null;
if (defaultAddress.StateProvinceId == 0)
defaultAddress.StateProvinceId = null;
//set default address
customer.Addresses.Add(defaultAddress);
customer.BillingAddress = defaultAddress;
customer.ShippingAddress = defaultAddress;
_customerService.UpdateCustomer(customer);
}
//notifications
if (_customerSettings.NotifyNewCustomerRegistration)
_workflowMessageService.SendCustomerRegisteredNotificationMessage(customer, _localizationSettings.DefaultAdminLanguageId);
//raise event
_eventPublisher.Publish(new CustomerRegisteredEvent(customer));
switch (_customerSettings.UserRegistrationType)
{
case UserRegistrationType.EmailValidation:
{
//email validation message
_genericAttributeService.SaveAttribute(customer, SystemCustomerAttributeNames.AccountActivationToken, Guid.NewGuid().ToString());
_workflowMessageService.SendCustomerEmailValidationMessage(customer, _workContext.WorkingLanguage.Id);
//result
return RedirectToRoute("RegisterResult", new { resultId = (int)UserRegistrationType.EmailValidation });
}
case UserRegistrationType.AdminApproval:
{
return RedirectToRoute("RegisterResult", new { resultId = (int)UserRegistrationType.AdminApproval });
}
case UserRegistrationType.Standard:
{
//send customer welcome message
_workflowMessageService.SendCustomerWelcomeMessage(customer, _workContext.WorkingLanguage.Id);
var redirectUrl = Url.RouteUrl("RegisterResult", new { resultId = (int)UserRegistrationType.Standard });
if (!String.IsNullOrEmpty(returnUrl) && Url.IsLocalUrl(returnUrl))
redirectUrl = _webHelper.ModifyQueryString(redirectUrl, "returnurl=" + HttpUtility.UrlEncode(returnUrl), null);
return Redirect(redirectUrl);
}
default:
{
return RedirectToRoute("HomePage");
}
}
}
//errors
foreach (var error in registrationResult.Errors)
ModelState.AddModelError("", error);
}
//If we got this far, something failed, redisplay form
PrepareCustomerRegisterModel(model, true, customerAttributesXml);
return View(model);
}
public object Clone()
{
var addr = new Address
{
FirstName = this.FirstName,
LastName = this.LastName,
Email = this.Email,
Company = this.Company,
Country = this.Country,
CountryId = this.CountryId,
StateProvince = this.StateProvince,
StateProvinceId = this.StateProvinceId,
City = this.City,
Address1 = this.Address1,
Address2 = this.Address2,
ZipPostalCode = this.ZipPostalCode,
PhoneNumber = this.PhoneNumber,
FaxNumber = this.FaxNumber,
CustomAttributes = this.CustomAttributes,
CreatedOnUtc = this.CreatedOnUtc,
};
return addr;
}
/// <summary>
/// Install the plugin
/// </summary>
public override void Install()
{
//database objects
_objectContext.Install();
//sample pickup point
var country = _countryService.GetCountryByThreeLetterIsoCode("USA");
var address = new Address
{
Address1 = "21 West 52nd Street",
City = "New York",
CountryId = country != null ? (int?)country.Id : null,
ZipPostalCode = "10021",
CreatedOnUtc = DateTime.UtcNow
};
_addressService.InsertAddress(address);
var pickupPoint = new StorePickupPoint
{
Name = "New York store",
AddressId = address.Id,
OpeningHours = "10.00 - 19.00",
PickupFee = 1.99m
};
_storePickupPointService.InsertStorePickupPoint(pickupPoint);
//locales
this.AddOrUpdatePluginLocaleResource("Plugins.Pickup.PickupInStore.AddNew", "Add a new pickup point");
this.AddOrUpdatePluginLocaleResource("Plugins.Pickup.PickupInStore.Fields.Description", "Description");
this.AddOrUpdatePluginLocaleResource("Plugins.Pickup.PickupInStore.Fields.Description.Hint", "Specify a description of the pickup point.");
this.AddOrUpdatePluginLocaleResource("Plugins.Pickup.PickupInStore.Fields.Name", "Name");
this.AddOrUpdatePluginLocaleResource("Plugins.Pickup.PickupInStore.Fields.Name.Hint", "Specify a name of the pickup point.");
this.AddOrUpdatePluginLocaleResource("Plugins.Pickup.PickupInStore.Fields.OpeningHours", "Opening hours");
this.AddOrUpdatePluginLocaleResource("Plugins.Pickup.PickupInStore.Fields.OpeningHours.Hint", "Specify an openning hours of the pickup point (Monday - Friday: 09:00 - 19:00 for example).");
this.AddOrUpdatePluginLocaleResource("Plugins.Pickup.PickupInStore.Fields.PickupFee", "Pickup fee");
this.AddOrUpdatePluginLocaleResource("Plugins.Pickup.PickupInStore.Fields.PickupFee.Hint", "Specify a fee for the shipping to the pickup point.");
this.AddOrUpdatePluginLocaleResource("Plugins.Pickup.PickupInStore.Fields.Store", "Store");
this.AddOrUpdatePluginLocaleResource("Plugins.Pickup.PickupInStore.Fields.Store.Hint", "A store name for which this pickup point will be available.");
this.AddOrUpdatePluginLocaleResource("Plugins.Pickup.PickupInStore.NoPickupPoints", "No pickup points are available");
base.Install();
}