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 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);
}
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_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.Addresses.Add(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.Addresses.Add(address);
customer.BillingAddress = 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();
}
/// <summary>
/// Checks whether the postal data of two addresses are equal.
/// </summary>
public static bool IsPostalDataEqual(this Address address, Address other)
{
if (address != null && other != null)
{
if (address.FirstName.IsCaseInsensitiveEqual(other.FirstName) &&
address.LastName.IsCaseInsensitiveEqual(other.LastName) &&
address.Company.IsCaseInsensitiveEqual(other.Company) &&
address.Address1.IsCaseInsensitiveEqual(other.Address1) &&
address.Address2.IsCaseInsensitiveEqual(other.Address2) &&
address.ZipPostalCode.IsCaseInsensitiveEqual(other.ZipPostalCode) &&
address.City.IsCaseInsensitiveEqual(other.City) &&
address.StateProvinceId == other.StateProvinceId &&
address.CountryId == other.CountryId)
{
return true;
}
}
return false;
}
public static Address FindAddress(this List<Address> addresses, Address address, bool uncompleteToo)
{
var match = addresses.FindAddress(address.FirstName, address.LastName,
address.PhoneNumber, address.Email, address.FaxNumber, address.Company,
address.Address1, address.Address2,
address.City, address.StateProvinceId, address.ZipPostalCode, address.CountryId);
if (match == null && uncompleteToo)
{
// compare with AmazonPayApiExtensions.ToAddress
match = addresses.FirstOrDefault(x =>
x.FirstName == null && x.LastName == null &&
x.Address1 == null && x.Address2 == null &&
x.City == address.City && x.ZipPostalCode == address.ZipPostalCode &&
x.PhoneNumber == null &&
x.CountryId == address.CountryId && x.StateProvinceId == address.StateProvinceId
);
}
return match;
}
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",
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.CreatedOnUtc.ShouldEqual(new DateTime(2010, 01, 01));
fromDb.Country.ShouldNotBeNull();
fromDb.Country.Name.ShouldEqual("United States");
}
public static Address ToEntity(this AddressModel model, Address destination)
{
return Mapper.Map(model, destination);
}
/// <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 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.Email))
return false;
if (_addressSettings.CompanyEnabled &&
_addressSettings.CompanyRequired &&
String.IsNullOrWhiteSpace(address.Company))
return false;
if (_addressSettings.StreetAddressEnabled &&
_addressSettings.StreetAddressRequired &&
String.IsNullOrWhiteSpace(address.Address1))
return false;
if (_addressSettings.StreetAddress2Enabled &&
_addressSettings.StreetAddress2Required &&
String.IsNullOrWhiteSpace(address.Address2))
return false;
if (_addressSettings.ZipPostalCodeEnabled &&
_addressSettings.ZipPostalCodeRequired &&
String.IsNullOrWhiteSpace(address.ZipPostalCode))
return false;
if (_addressSettings.CountryEnabled)
{
if (address.CountryId == null || address.CountryId.Value == 0)
return false;
var country = _countryService.GetCountryById(address.CountryId.Value);
if (country == null)
return false;
if (_addressSettings.StateProvinceEnabled)
{
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;
}
}
}
if (_addressSettings.CityEnabled &&
_addressSettings.CityRequired &&
String.IsNullOrWhiteSpace(address.City))
return false;
if (_addressSettings.PhoneEnabled &&
_addressSettings.PhoneRequired &&
String.IsNullOrWhiteSpace(address.PhoneNumber))
return false;
if (_addressSettings.FaxEnabled &&
_addressSettings.FaxRequired &&
String.IsNullOrWhiteSpace(address.FaxNumber))
return false;
return true;
}
/// <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);
}
public ActionResult Register(RegisterModel model, string returnUrl, bool captchaValid)
{
//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;
// 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, 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 = null;
try
{
dateOfBirth = new DateTime(model.DateOfBirthYear.Value, model.DateOfBirthMonth.Value, model.DateOfBirthDay.Value);
}
catch { }
_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);
if (_customerSettings.CustomerNumberMethod == CustomerNumberMethod.AutomaticallySet && String.IsNullOrEmpty(customer.GetAttribute<string>(SystemCustomerAttributeNames.CustomerNumber)))
_genericAttributeService.SaveAttribute(customer, SystemCustomerAttributeNames.CustomerNumber, customer.Id);
// newsletter
if (_customerSettings.NewsletterEnabled)
{
// save newsletter value
var newsletter = _newsLetterSubscriptionService.GetNewsLetterSubscriptionByEmail(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,
CreatedOnUtc = DateTime.UtcNow,
StoreId = _storeContext.CurrentStore.Id
});
}
}
}
//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);
switch (_customerSettings.UserRegistrationType)
{
case UserRegistrationType.EmailValidation:
{
// email validation message
_genericAttributeService.SaveAttribute(customer, SystemCustomerAttributeNames.AccountActivationToken, Guid.NewGuid().ToString());
_workflowMessageService.SendCustomerEmailValidationMessage(customer, _workContext.WorkingLanguage.Id);
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))
redirectUrl = _webHelper.ModifyQueryString(redirectUrl, "returnurl=" + HttpUtility.UrlEncode(returnUrl), null);
return Redirect(redirectUrl);
}
default:
{
return RedirectToRoute("HomePage");
}
}
}
else
{
foreach (var error in registrationResult.Errors)
ModelState.AddModelError("", error);
}
}
//If we got this far, something failed, redisplay form
model.AllowCustomersToSetTimeZone = _dateTimeSettings.AllowCustomersToSetTimeZone;
foreach (var tzi in _dateTimeHelper.GetSystemTimeZones())
model.AvailableTimeZones.Add(new SelectListItem() { Text = tzi.DisplayName, Value = tzi.Id, Selected = (tzi.Id == _dateTimeHelper.DefaultStoreTimeZone.Id) });
model.DisplayVatNumber = _taxSettings.EuVatEnabled;
model.VatRequired = _taxSettings.VatRequired;
//form fields
model.GenderEnabled = _customerSettings.GenderEnabled;
model.DateOfBirthEnabled = _customerSettings.DateOfBirthEnabled;
model.CompanyEnabled = _customerSettings.CompanyEnabled;
model.CompanyRequired = _customerSettings.CompanyRequired;
model.StreetAddressEnabled = _customerSettings.StreetAddressEnabled;
model.StreetAddressRequired = _customerSettings.StreetAddressRequired;
model.StreetAddress2Enabled = _customerSettings.StreetAddress2Enabled;
model.StreetAddress2Required = _customerSettings.StreetAddress2Required;
model.ZipPostalCodeEnabled = _customerSettings.ZipPostalCodeEnabled;
model.ZipPostalCodeRequired = _customerSettings.ZipPostalCodeRequired;
model.CityEnabled = _customerSettings.CityEnabled;
model.CityRequired = _customerSettings.CityRequired;
model.CountryEnabled = _customerSettings.CountryEnabled;
model.StateProvinceEnabled = _customerSettings.StateProvinceEnabled;
model.PhoneEnabled = _customerSettings.PhoneEnabled;
model.PhoneRequired = _customerSettings.PhoneRequired;
model.FaxEnabled = _customerSettings.FaxEnabled;
model.FaxRequired = _customerSettings.FaxRequired;
model.NewsletterEnabled = _customerSettings.NewsletterEnabled;
model.UsernamesEnabled = _customerSettings.UsernamesEnabled;
model.CheckUsernameAvailabilityEnabled = _customerSettings.CheckUsernameAvailabilityEnabled;
model.DisplayCaptcha = _captchaSettings.Enabled && _captchaSettings.ShowOnRegistrationPage;
if (_customerSettings.CountryEnabled)
{
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(), Selected = (c.Id == model.CountryId) });
}
if (_customerSettings.StateProvinceEnabled)
{
//states
var states = _stateProvinceService.GetStateProvincesByCountryId(model.CountryId).ToList();
if (states.Count > 0)
{
foreach (var s in states)
model.AvailableStates.Add(new SelectListItem() { Text = s.GetLocalized(x => x.Name), Value = s.Id.ToString(), Selected = (s.Id == model.StateProvinceId) });
}
else
model.AvailableStates.Add(new SelectListItem() { Text = _localizationService.GetResource("Address.OtherNonUS"), Value = "0" });
}
}
return View(model);
}
public Address AdminAddress()
{
var cCountry = _ctx.Set<Country>()
.Where(x => x.ThreeLetterIsoCode == "USA")
.FirstOrDefault();
var entity = new Address()
{
FirstName = "John",
LastName = "Smith",
PhoneNumber = "12345678",
Email = "*****@*****.**",
FaxNumber = "",
Company = "John Smith LLC",
Address1 = "1234 Main Road",
Address2 = "",
City = "New York",
StateProvince = cCountry.StateProvinces.FirstOrDefault(),
Country = cCountry,
ZipPostalCode = "12212",
CreatedOnUtc = DateTime.UtcNow,
};
this.Alter(entity);
return entity;
}
private void PrepareOrderAddressModel(OrderAddressModel model, Address address)
{
model.Address = address.ToModel();
model.Address.FirstNameEnabled = true;
model.Address.FirstNameRequired = true;
model.Address.LastNameEnabled = true;
model.Address.LastNameRequired = true;
model.Address.EmailEnabled = true;
model.Address.EmailRequired = true;
model.Address.CompanyEnabled = _addressSettings.CompanyEnabled;
model.Address.CompanyRequired = _addressSettings.CompanyRequired;
model.Address.CountryEnabled = _addressSettings.CountryEnabled;
model.Address.StateProvinceEnabled = _addressSettings.StateProvinceEnabled;
model.Address.CityEnabled = _addressSettings.CityEnabled;
model.Address.CityRequired = _addressSettings.CityRequired;
model.Address.StreetAddressEnabled = _addressSettings.StreetAddressEnabled;
model.Address.StreetAddressRequired = _addressSettings.StreetAddressRequired;
model.Address.StreetAddress2Enabled = _addressSettings.StreetAddress2Enabled;
model.Address.StreetAddress2Required = _addressSettings.StreetAddress2Required;
model.Address.ZipPostalCodeEnabled = _addressSettings.ZipPostalCodeEnabled;
model.Address.ZipPostalCodeRequired = _addressSettings.ZipPostalCodeRequired;
model.Address.PhoneEnabled = _addressSettings.PhoneEnabled;
model.Address.PhoneRequired = _addressSettings.PhoneRequired;
model.Address.FaxEnabled = _addressSettings.FaxEnabled;
model.Address.FaxRequired = _addressSettings.FaxRequired;
//countries
foreach (var c in _countryService.GetAllCountries(true))
{
model.Address.AvailableCountries.Add(new SelectListItem() { Text = c.Name, Value = c.Id.ToString(), Selected = (c.Id == address.CountryId) });
}
//states
var states = address.Country != null ? _stateProvinceService.GetStateProvincesByCountryId(address.Country.Id, true).ToList() : new List<StateProvince>();
if (states.Count > 0)
{
foreach (var s in states)
{
model.Address.AvailableStates.Add(new SelectListItem() { Text = s.Name, Value = s.Id.ToString(), Selected = (s.Id == address.StateProvinceId) });
}
}
else
{
model.Address.AvailableStates.Add(new SelectListItem() { Text = _localizationService.GetResource("Admin.Address.OtherNonUS"), Value = "0" });
}
}
private Dictionary<string, object> CreateAddress(Address addr, bool addRecipientName)
{
var dic = new Dictionary<string, object>();
dic.Add("line1", addr.Address1.Truncate(100));
if (addr.Address2.HasValue())
{
dic.Add("line2", addr.Address2.Truncate(100));
}
dic.Add("city", addr.City.Truncate(50));
if (addr.CountryId != 0 && addr.Country != null)
{
dic.Add("country_code", addr.Country.TwoLetterIsoCode);
}
dic.Add("postal_code", addr.ZipPostalCode.Truncate(20));
if (addr.StateProvinceId != 0 && addr.StateProvince != null)
{
dic.Add("state", addr.StateProvince.Abbreviation.Truncate(100));
}
if (addRecipientName)
{
dic.Add("recipient_name", addr.GetFullName().Truncate(50));
}
return dic;
}
protected override void Alter(Address entity)
{
base.Alter(entity);
string addressThreeLetterIsoCode = "DEU";
var cCountry = base.DbContext.Set<Country>().Where(x => x.ThreeLetterIsoCode == addressThreeLetterIsoCode);
entity.FirstName = "Max";
entity.LastName ="Mustermann";
entity.Email ="*****@*****.**";
entity.Company ="Max Mustermann";
entity.Address1 = "Musterweg 1";
entity.City = "Musterstadt";
entity.StateProvince = cCountry.FirstOrDefault().StateProvinces.FirstOrDefault();
entity.Country = cCountry.FirstOrDefault();
entity.ZipPostalCode = "12345";
}
public Address AdminAddress()
{
string addressThreeLetterIsoCode = "USA";
var cCountry = this.Countries().Where(x => x.ThreeLetterIsoCode == addressThreeLetterIsoCode);
var entity = new Address()
{
FirstName = "John",
LastName = "Smith",
PhoneNumber = "12345678",
Email = "*****@*****.**",
FaxNumber = "",
Company = "John Smith LLC",
Address1 = "1234 Main Road",
Address2 = "",
City = "New York",
StateProvince = cCountry.FirstOrDefault().StateProvinces.FirstOrDefault(),
//StateProvince = _stateProvinceRepository.Table.Where(sp => sp.Name == "New York").FirstOrDefault(),
Country = cCountry.FirstOrDefault(),
ZipPostalCode = "12212",
CreatedOnUtc = DateTime.UtcNow,
};
this.Alter(entity);
return entity;
}
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 ActionResult GetEstimateShipping(EstimateShippingModel shippingModel, FormCollection form)
{
var cart = _workContext.CurrentCustomer.GetCartItems(ShoppingCartType.ShoppingCart, _storeContext.CurrentStore.Id);
//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)
{
var shippingMethods = _shippingService.GetAllShippingMethods();
foreach (var shippingOption in getShippingOptionResponse.ShippingOptions)
{
var soModel = new EstimateShippingModel.ShippingOptionModel()
{
ShippingMethodId = shippingOption.ShippingMethodId,
Name = shippingOption.Name,
Description = shippingOption.Description,
};
//calculate discounted and taxed rate
Discount appliedDiscount = null;
decimal shippingTotal = _orderTotalCalculationService.AdjustShippingRate(
shippingOption.Rate, cart, shippingOption.Name, shippingMethods, out appliedDiscount);
decimal rateBase = _taxService.GetShippingPrice(shippingTotal, _workContext.CurrentCustomer);
decimal rate = _currencyService.ConvertFromPrimaryStoreCurrency(rateBase, _workContext.WorkingCurrency);
soModel.Price = _priceFormatter.FormatShippingPrice(rate, false /*true*/);
model.EstimateShipping.ShippingOptions.Add(soModel);
}
}
else
{
model.EstimateShipping.Warnings.Add(_localizationService.GetResource("Checkout.ShippingIsNotAllowed"));
}
}
}
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,
CreatedOnUtc = this.CreatedOnUtc,
};
return addr;
}
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.Addresses.Add(address);
customer.Addresses.Add(address2);
customer.BillingAddress = address;
customer.ShippingAddress = 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]);
}
public static Address ToEntity(this AddressModel model)
{
if (model == null)
return null;
var entity = new Address();
return ToEntity(model, entity);
}
/// <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<OrganizedShoppingCartItem> cart,
Address shippingAddress)
{
var request = new GetShippingOptionRequest();
request.Customer = cart.GetCustomer();
request.Items = new List<OrganizedShoppingCartItem>();
foreach (var sc in cart)
if (sc.Item.IsShipEnabled)
request.Items.Add(sc);
request.ShippingAddress = shippingAddress;
request.CountryFrom = null;
request.StateProvinceFrom = null;
request.ZipPostalCodeFrom = string.Empty;
return request;
}
/// <summary>
/// Prepare address model
/// </summary>
/// <param name="model">Model</param>
/// <param name="address">Address</param>
/// <param name="excludeProperties">A value indicating whether to exclude properties</param>
/// <param name="addressSettings">Address settings</param>
/// <param name="localizationService">Localization service (used to prepare a select list)</param>
/// <param name="stateProvinceService">State service (used to prepare a select list). null to don't prepare the list.</param>
/// <param name="loadCountries">A function to load countries (used to prepare a select list). null to don't prepare the list.</param>
public static void PrepareModel(this AddressModel model,
Address address, bool excludeProperties,
AddressSettings addressSettings,
ILocalizationService localizationService = null,
IStateProvinceService stateProvinceService = null,
Func<IList<Country>> loadCountries = null)
{
if (model == null)
throw new ArgumentNullException("model");
if (addressSettings == null)
throw new ArgumentNullException("addressSettings");
if (!excludeProperties && address != null)
{
model.Id = address.Id;
model.FirstName = address.FirstName;
model.LastName = address.LastName;
model.Email = address.Email;
model.Company = address.Company;
model.CountryId = address.CountryId;
model.CountryName = address.Country != null
? address.Country.GetLocalized(x => x.Name)
: null;
model.StateProvinceId = address.StateProvinceId;
model.StateProvinceName = address.StateProvince != null
? address.StateProvince.GetLocalized(x => x.Name)
: null;
model.City = address.City;
model.Address1 = address.Address1;
model.Address2 = address.Address2;
model.ZipPostalCode = address.ZipPostalCode;
model.PhoneNumber = address.PhoneNumber;
model.FaxNumber = address.FaxNumber;
}
//countries and states
if (addressSettings.CountryEnabled && loadCountries != null)
{
if (localizationService == null)
throw new ArgumentNullException("localizationService");
model.AvailableCountries.Add(new SelectListItem() { Text = localizationService.GetResource("Address.SelectCountry"), Value = "0" });
foreach (var c in loadCountries())
{
model.AvailableCountries.Add(new SelectListItem()
{
Text = c.GetLocalized(x => x.Name),
Value = c.Id.ToString(),
Selected = c.Id == model.CountryId
});
}
if (addressSettings.StateProvinceEnabled)
{
//states
if (stateProvinceService == null)
throw new ArgumentNullException("stateProvinceService");
var states = stateProvinceService
.GetStateProvincesByCountryId(model.CountryId.HasValue ? model.CountryId.Value : 0)
.ToList();
if (states.Count > 0)
{
foreach (var s in states)
{
model.AvailableStates.Add(new SelectListItem()
{
Text = s.GetLocalized(x => x.Name),
Value = s.Id.ToString(),
Selected = (s.Id == model.StateProvinceId)
});
}
}
else
{
model.AvailableStates.Add(new SelectListItem()
{
Text = localizationService.GetResource("Address.OtherNonUS"),
Value = "0"
});
}
}
}
//form fields
model.CompanyEnabled = addressSettings.CompanyEnabled;
model.CompanyRequired = addressSettings.CompanyRequired;
model.StreetAddressEnabled = addressSettings.StreetAddressEnabled;
model.StreetAddressRequired = addressSettings.StreetAddressRequired;
model.StreetAddress2Enabled = addressSettings.StreetAddress2Enabled;
model.StreetAddress2Required = addressSettings.StreetAddress2Required;
model.ZipPostalCodeEnabled = addressSettings.ZipPostalCodeEnabled;
model.ZipPostalCodeRequired = addressSettings.ZipPostalCodeRequired;
model.CityEnabled = addressSettings.CityEnabled;
model.CityRequired = addressSettings.CityRequired;
model.CountryEnabled = addressSettings.CountryEnabled;
model.StateProvinceEnabled = addressSettings.StateProvinceEnabled;
model.PhoneEnabled = addressSettings.PhoneEnabled;
model.PhoneRequired = addressSettings.PhoneRequired;
model.FaxEnabled = addressSettings.FaxEnabled;
model.FaxRequired = addressSettings.FaxRequired;
}
/// <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 allows only in specified store; pass 0 to load all records</param>
/// <returns>Shipping options</returns>
public virtual GetShippingOptionResponse GetShippingOptions(IList<OrganizedShoppingCartItem> cart, Address shippingAddress,
string allowedShippingRateComputationMethodSystemName = "", int storeId = 0)
{
if (cart == null)
throw new ArgumentNullException("cart");
var result = new GetShippingOptionResponse();
//create a package
var getShippingOptionRequest = CreateShippingOptionRequest(cart, shippingAddress);
var shippingRateComputationMethods = LoadActiveShippingRateComputationMethods(storeId)
.Where(srcm =>
String.IsNullOrWhiteSpace(allowedShippingRateComputationMethodSystemName) ||
allowedShippingRateComputationMethodSystemName.Equals(srcm.Metadata.SystemName, StringComparison.InvariantCultureIgnoreCase))
.ToList();
if (shippingRateComputationMethods.Count == 0)
throw new SmartException("Shipping rate computation method could not be loaded");
//get shipping options
foreach (var srcm in shippingRateComputationMethods)
{
var getShippingOptionResponse = srcm.Value.GetShippingOptions(getShippingOptionRequest);
foreach (var so2 in getShippingOptionResponse.ShippingOptions)
{
//system name
so2.ShippingRateComputationMethodSystemName = srcm.Metadata.SystemName;
//round
if (_shoppingCartSettings.RoundPricesDuringCalculation)
so2.Rate = Math.Round(so2.Rate, 2);
result.ShippingOptions.Add(so2);
}
//log errors
if (!getShippingOptionResponse.Success)
{
foreach (string error in getShippingOptionResponse.Errors)
{
result.AddError(error);
_logger.Warning(string.Format("Shipping ({0}). {1}", srcm.Metadata.FriendlyName, error));
}
}
}
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.Count > 0 && result.Errors.Count > 0)
result.Errors.Clear();
}
//no shipping options loaded
if (result.ShippingOptions.Count == 0 && result.Errors.Count == 0)
result.Errors.Add(_localizationService.GetResource("Checkout.ShippingOptionCouldNotBeLoaded"));
return result;
}
protected virtual void Alter(Address entity)
{
}
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);
}
}
