public virtual Customer GetAuthenticatedCustomer()
{
if (_cachedCustomer != null)
return _cachedCustomer;
if (_httpContext == null || _httpContext.Request == null || !_httpContext.Request.IsAuthenticated || _httpContext.User == null)
return null;
Customer customer = null;
FormsIdentity formsIdentity = null;
SmartStoreIdentity smartNetIdentity = null;
if ((formsIdentity = _httpContext.User.Identity as FormsIdentity) != null)
{
customer = GetAuthenticatedCustomerFromTicket(formsIdentity.Ticket);
}
else if ((smartNetIdentity = _httpContext.User.Identity as SmartStoreIdentity) != null)
{
customer = _customerService.GetCustomerById(smartNetIdentity.CustomerId);
}
if (customer != null && customer.Active && !customer.Deleted && customer.IsRegistered())
{
_cachedCustomer = customer;
}
return _cachedCustomer;
}
/// <summary>
/// Checks discount limitation for customer
/// </summary>
/// <param name="discount">Discount</param>
/// <param name="customer">Customer</param>
/// <returns>Value indicating whether discount can be used</returns>
protected virtual bool CheckDiscountLimitations(Discount discount, Customer customer)
{
if (discount == null)
throw new ArgumentNullException("discount");
switch (discount.DiscountLimitation)
{
case DiscountLimitationType.Unlimited:
{
return true;
}
case DiscountLimitationType.NTimesOnly:
{
var totalDuh = GetAllDiscountUsageHistory(discount.Id, null, 0, 1).TotalCount;
return totalDuh < discount.LimitationTimes;
}
case DiscountLimitationType.NTimesPerCustomer:
{
if (customer != null && !customer.IsGuest())
{
//registered customer
var totalDuh = GetAllDiscountUsageHistory(discount.Id, customer.Id, 0, 1).TotalCount;
return totalDuh < discount.LimitationTimes;
}
else
{
//guest
return true;
}
}
default:
break;
}
return false;
}
public virtual void SignIn(Customer customer, bool createPersistentCookie)
{
var now = DateTime.UtcNow.ToLocalTime();
var ticket = new FormsAuthenticationTicket(
1 /*version*/,
_customerSettings.UsernamesEnabled ? customer.Username : customer.Email,
now,
now.Add(_expirationTimeSpan),
createPersistentCookie,
_customerSettings.UsernamesEnabled ? customer.Username : customer.Email,
FormsAuthentication.FormsCookiePath);
var encryptedTicket = FormsAuthentication.Encrypt(ticket);
var cookie = new HttpCookie(FormsAuthentication.FormsCookieName, encryptedTicket);
cookie.HttpOnly = true;
if (ticket.IsPersistent)
{
cookie.Expires = ticket.Expiration;
}
cookie.Secure = FormsAuthentication.RequireSSL;
cookie.Path = FormsAuthentication.FormsCookiePath;
if (FormsAuthentication.CookieDomain != null)
{
cookie.Domain = FormsAuthentication.CookieDomain;
}
_httpContext.Response.Cookies.Add(cookie);
_cachedCustomer = customer;
}
public virtual void AssociateExternalAccountWithUser(Customer customer, OpenAuthenticationParameters parameters)
{
if (customer == null)
throw new ArgumentNullException("customer");
//find email
string email = null;
if (parameters.UserClaims != null)
foreach (var userClaim in parameters.UserClaims
.Where(x => x.Contact != null && !String.IsNullOrEmpty(x.Contact.Email)))
{
//found
email = userClaim.Contact.Email;
break;
}
var externalAuthenticationRecord = new ExternalAuthenticationRecord()
{
CustomerId = customer.Id,
Email = email,
ExternalIdentifier = parameters.ExternalIdentifier,
ExternalDisplayIdentifier = parameters.ExternalDisplayIdentifier,
OAuthToken = parameters.OAuthToken,
OAuthAccessToken = parameters.OAuthAccessToken,
ProviderSystemName = parameters.ProviderSystemName,
};
_externalAuthenticationRecordRepository.Insert(externalAuthenticationRecord);
}
protected virtual void LogUnauthorized(HttpActionContext actionContext, HmacResult result, Customer customer)
{
try
{
var logger = EngineContext.Current.Resolve<ILogger>();
var localization = EngineContext.Current.Resolve<ILocalizationService>();
string strResult = result.ToString();
string description = localization.GetResource("Admin.WebApi.AuthResult." + strResult, 0, false, strResult);
var logContext = new LogContext()
{
ShortMessage = localization.GetResource("Admin.WebApi.UnauthorizedRequest").FormatWith(strResult),
FullMessage = "{0}\r\n{1}".FormatWith(description, actionContext.Request.Headers.ToString()),
LogLevel = LogLevel.Warning,
Customer = customer,
HashNotFullMessage = true,
HashIpAddress = true
};
logger.InsertLog(logContext);
}
catch (Exception exc)
{
exc.Dump();
}
}
public void Can_check_whether_customer_is_admin()
{
var customer = new Customer();
customer.CustomerRoles.Add(new CustomerRole()
{
Active = true,
Name = "Registered",
SystemName = SystemCustomerRoleNames.Registered
});
customer.CustomerRoles.Add(new CustomerRole()
{
Active = true,
Name = "Guests",
SystemName = SystemCustomerRoleNames.Guests
});
customer.IsAdmin().ShouldBeFalse();
customer.CustomerRoles.Add(
new CustomerRole()
{
Active = true,
Name = "Administrators",
SystemName = SystemCustomerRoleNames.Administrators
});
customer.IsAdmin().ShouldBeTrue();
}
/// <summary>
/// Filter tier prices for a customer
/// </summary>
/// <param name="source">Tier prices</param>
/// <param name="customer">Customer</param>
/// <returns>Filtered tier prices</returns>
public static IEnumerable<TierPrice> FilterForCustomer(this IEnumerable<TierPrice> source, Customer customer)
{
if (source == null)
throw new ArgumentNullException("source");
foreach (var tierPrice in source)
{
//check customer role requirement
if (tierPrice.CustomerRole != null)
{
if (customer == null)
continue;
var customerRoles = customer.CustomerRoles.Where(cr => cr.Active);
if (!customerRoles.Any())
continue;
bool roleIsFound = false;
foreach (var customerRole in customerRoles)
{
if (customerRole == tierPrice.CustomerRole)
roleIsFound = true;
}
if (!roleIsFound)
continue;
}
yield return tierPrice;
}
}
public void Can_check_taxExempt_customer()
{
var customer = new Customer();
customer.IsTaxExempt = true;
_taxService.IsTaxExempt(null, customer).ShouldEqual(true);
customer.IsTaxExempt = false;
_taxService.IsTaxExempt(null, customer).ShouldEqual(false);
}
public void Can_get_rewardPointsHistoryBalance()
{
var customer = new Customer();
customer.AddRewardPointsHistoryEntry(1, "Points for registration");
//customer.AddRewardPointsHistoryEntry(3, "Points for registration");
customer.GetRewardPointsBalance().ShouldEqual(1);
}
public void Can_add_rewardPointsHistoryEntry()
{
var customer = new Customer();
customer.AddRewardPointsHistoryEntry(1, "Points for registration");
customer.RewardPointsHistory.Count.ShouldEqual(1);
customer.RewardPointsHistory.First().Points.ShouldEqual(1);
}
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);
}
public new void SetUp()
{
_activityType1 = new ActivityLogType
{
Id = 1,
SystemKeyword = "TestKeyword1",
Enabled = true,
Name = "Test name1"
};
_activityType2 = new ActivityLogType
{
Id = 2,
SystemKeyword = "TestKeyword2",
Enabled = true,
Name = "Test name2"
};
_customer1 = new Customer()
{
Id = 1,
Email = "*****@*****.**",
Username = "******",
Deleted = false,
};
_customer2 = new Customer()
{
Id = 2,
Email = "*****@*****.**",
Username = "******",
Deleted = false,
};
_activity1 = new ActivityLog()
{
Id = 1,
ActivityLogType = _activityType1,
CustomerId = _customer1.Id,
Customer = _customer1
};
_activity2 = new ActivityLog()
{
Id = 2,
ActivityLogType = _activityType1,
CustomerId = _customer2.Id,
Customer = _customer2
};
_workContext = MockRepository.GenerateMock<IWorkContext>();
_activityLogRepository = MockRepository.GenerateMock<IRepository<ActivityLog>>();
_activityLogTypeRepository = MockRepository.GenerateMock<IRepository<ActivityLogType>>();
_customerRepository = MockRepository.GenerateMock<IRepository<Customer>>();
_activityLogTypeRepository.Expect(x => x.Table).Return(new List<ActivityLogType>() { _activityType1, _activityType2 }.AsQueryable());
_activityLogRepository.Expect(x => x.Table).Return(new List<ActivityLog>() { _activity1, _activity2 }.AsQueryable());
_customerActivityService = new CustomerActivityService(_activityLogRepository, _activityLogTypeRepository, _customerRepository, _workContext, null);
}
private static void FilteredLog(ILogger logger, LogLevel level, string message, Exception exception = null, Customer customer = null)
{
// don't log thread abort exception
if ((exception != null) && (exception is System.Threading.ThreadAbortException))
return;
if (logger.IsEnabled(level))
{
string fullMessage = exception == null ? string.Empty : exception.ToString();
logger.InsertLog(level, message, fullMessage, customer);
}
}
public CustomerRegistrationRequest(Customer customer, string email, string username,
string password,
PasswordFormat passwordFormat,
bool isApproved = true)
{
this.Customer = customer;
this.Email = email;
this.Username = username;
this.Password = password;
this.PasswordFormat = passwordFormat;
this.IsApproved = isApproved;
}
protected override void Alter(Customer entity)
{
base.Alter(entity);
if (entity.SystemName == "*****@*****.**")
{
entity.AdminComment = "System Gastkonto für Suchmaschinenanfragen.";
}
else if (entity.SystemName == "*****@*****.**")
{
entity.AdminComment = "System Konto für geplante Aufgaben.";
}
}
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();
}
/// <summary>
/// Gets allowed discounts
/// </summary>
/// <param name="product">Product</param>
/// <param name="customer">Customer</param>
/// <returns>Discounts</returns>
protected virtual IList<Discount> GetAllowedDiscounts(Product product, Customer customer)
{
var allowedDiscounts = new List<Discount>();
if (_catalogSettings.IgnoreDiscounts)
return allowedDiscounts;
if (product.HasDiscountsApplied)
{
//we use this property ("HasDiscountsApplied") for performance optimziation to avoid unnecessary database calls
foreach (var discount in product.AppliedDiscounts)
{
if (_discountService.IsDiscountValid(discount, customer) &&
discount.DiscountType == DiscountType.AssignedToSkus &&
!allowedDiscounts.ContainsDiscount(discount))
{
allowedDiscounts.Add(discount);
}
}
}
//performance optimization
//load all category discounts just to ensure that we have at least one
if (_discountService.GetAllDiscounts(DiscountType.AssignedToCategories).Any())
{
var productCategories = _categoryService.GetProductCategoriesByProductId(product.Id);
if (productCategories != null)
{
foreach (var productCategory in productCategories)
{
var category = productCategory.Category;
if (category.HasDiscountsApplied)
{
//we use this property ("HasDiscountsApplied") for performance optimziation to avoid unnecessary database calls
var categoryDiscounts = category.AppliedDiscounts;
foreach (var discount in categoryDiscounts)
{
if (_discountService.IsDiscountValid(discount, customer) &&
discount.DiscountType == DiscountType.AssignedToCategories &&
!allowedDiscounts.ContainsDiscount(discount))
{
allowedDiscounts.Add(discount);
}
}
}
}
}
}
return allowedDiscounts;
}
protected virtual bool HasPermission(HttpActionContext actionContext, Customer customer)
{
bool result = true;
try
{
if (Permission.HasValue() && _permissionService.GetPermissionRecordBySystemName(Permission) != null)
{
result = _permissionService.Authorize(Permission, customer);
}
}
catch (Exception)
{
}
return result;
}
protected override void Alter(Customer entity)
{
base.Alter(entity);
if (entity.SystemName == SystemCustomerNames.SearchEngine)
{
entity.AdminComment = "System-Gastkonto für Suchmaschinenanfragen.";
}
else if (entity.SystemName == SystemCustomerNames.BackgroundTask)
{
entity.AdminComment = "Systemkonto für geplante Aufgaben.";
}
else if (entity.SystemName == SystemCustomerNames.PdfConverter)
{
entity.AdminComment = "Systemkonto für den PDF-Konverter.";
}
}
/// <summary>
/// Authorize permission
/// </summary>
/// <param name="permission">Permission record</param>
/// <param name="customer">Customer</param>
/// <returns>true - authorized; otherwise, false</returns>
public virtual bool Authorize(PermissionRecord permission, Customer customer)
{
if (permission == null)
return false;
if (customer == null)
return false;
//old implementation of Authorize method
//var customerRoles = customer.CustomerRoles.Where(cr => cr.Active);
//foreach (var role in customerRoles)
// foreach (var permission1 in role.PermissionRecords)
// if (permission1.SystemName.Equals(permission.SystemName, StringComparison.InvariantCultureIgnoreCase))
// return true;
//return false;
return Authorize(permission.SystemName, customer);
}
public void Can_check_IsInCustomerRole()
{
var customer = new Customer()
{
/*CustomerRoles = new List<CustomerRole>()
{
new CustomerRole()
{
Active = true,
Name = "Test name 1",
SystemName = "Test system name 1",
},
new CustomerRole()
{
Active = false,
Name = "Test name 2",
SystemName = "Test system name 2",
},
}*/
};
customer.CustomerRoles.Add(new CustomerRole()
{
Active = true,
Name = "Test name 1",
SystemName = "Test system name 1",
});
customer.CustomerRoles.Add(new CustomerRole()
{
Active = false,
Name = "Test name 2",
SystemName = "Test system name 2",
});
customer.IsInCustomerRole("Test system name 1", false).ShouldBeTrue();
customer.IsInCustomerRole("Test system name 1", true).ShouldBeTrue();
customer.IsInCustomerRole("Test system name 2", false).ShouldBeTrue();
customer.IsInCustomerRole("Test system name 2", true).ShouldBeFalse();
customer.IsInCustomerRole("Test system name 3", false).ShouldBeFalse();
customer.IsInCustomerRole("Test system name 3", true).ShouldBeFalse();
}
public void Can_check_taxExempt_customer_in_taxExemptCustomerRole()
{
var customer = new Customer();
customer.IsTaxExempt = false;
_taxService.IsTaxExempt(null, customer).ShouldEqual(false);
var customerRole = new CustomerRole()
{
TaxExempt = true,
Active = true
};
customer.CustomerRoles.Add(customerRole);
_taxService.IsTaxExempt(null, customer).ShouldEqual(true);
customerRole.TaxExempt = false;
_taxService.IsTaxExempt(null, customer).ShouldEqual(false);
//if role is not active, weshould ignore 'TaxExempt' property
customerRole.Active = false;
_taxService.IsTaxExempt(null, customer).ShouldEqual(false);
}
protected virtual void Alter(Customer entity)
{
}
public Customer BackgroundTaskUser()
{
var entity = new Customer()
{
Email = "*****@*****.**",
CustomerGuid = Guid.NewGuid(),
PasswordFormat = PasswordFormat.Clear,
AdminComment = "Built-in system record used for background tasks.",
Active = true,
IsSystemAccount = true,
SystemName = SystemCustomerNames.BackgroundTask,
CreatedOnUtc = DateTime.UtcNow,
LastActivityDateUtc = DateTime.UtcNow,
};
this.Alter(entity);
return entity;
}
public Customer SearchEngineUser()
{
var entity = new Customer()
{
Email = "*****@*****.**",
CustomerGuid = Guid.NewGuid(),
PasswordFormat = PasswordFormat.Clear,
AdminComment = "Built-in system guest record used for requests from search engines.",
Active = true,
IsSystemAccount = true,
SystemName = SystemCustomerNames.SearchEngine,
CreatedOnUtc = DateTime.UtcNow,
LastActivityDateUtc = DateTime.UtcNow,
};
this.Alter(entity);
return entity;
}
/// <summary>
/// Reset data required for checkout
/// </summary>
/// <param name="customer">Customer</param>
/// <param name="storeId">Store identifier</param>
/// <param name="clearCouponCodes">A value indicating whether to clear coupon code</param>
/// <param name="clearCheckoutAttributes">A value indicating whether to clear selected checkout attributes</param>
/// <param name="clearRewardPoints">A value indicating whether to clear "Use reward points" flag</param>
/// <param name="clearShippingMethod">A value indicating whether to clear selected shipping method</param>
/// <param name="clearPaymentMethod">A value indicating whether to clear selected payment method</param>
public virtual void ResetCheckoutData(Customer customer, int storeId,
bool clearCouponCodes = false, bool clearCheckoutAttributes = false,
bool clearRewardPoints = true, bool clearShippingMethod = true,
bool clearPaymentMethod = true)
{
if (customer == null)
throw new ArgumentNullException();
//clear entered coupon codes
if (clearCouponCodes)
{
_genericAttributeService.SaveAttribute<ShippingOption>(customer, SystemCustomerAttributeNames.DiscountCouponCode, null);
_genericAttributeService.SaveAttribute<ShippingOption>(customer, SystemCustomerAttributeNames.GiftCardCouponCodes, null);
}
//clear checkout attributes
if (clearCheckoutAttributes)
{
_genericAttributeService.SaveAttribute<ShippingOption>(customer, SystemCustomerAttributeNames.CheckoutAttributes, null);
}
//clear reward points flag
if (clearRewardPoints)
{
_genericAttributeService.SaveAttribute<bool>(customer, SystemCustomerAttributeNames.UseRewardPointsDuringCheckout, false, storeId);
}
//clear selected shipping method
if (clearShippingMethod)
{
_genericAttributeService.SaveAttribute<ShippingOption>(customer, SystemCustomerAttributeNames.SelectedShippingOption, null, storeId);
_genericAttributeService.SaveAttribute<ShippingOption>(customer, SystemCustomerAttributeNames.OfferedShippingOptions, null, storeId);
}
//clear selected payment method
if (clearPaymentMethod)
{
_genericAttributeService.SaveAttribute<string>(customer, SystemCustomerAttributeNames.SelectedPaymentMethod, null, storeId);
}
UpdateCustomer(customer);
}
/// <summary>
/// Updates the customer
/// </summary>
/// <param name="customer">Customer</param>
public virtual void UpdateCustomer(Customer customer)
{
if (customer == null)
throw new ArgumentNullException("customer");
_customerRepository.Update(customer);
//event notification
_eventPublisher.EntityUpdated(customer);
}
/// <summary>
/// Insert a guest customer
/// </summary>
/// <returns>Customer</returns>
public virtual Customer InsertGuestCustomer()
{
var customer = new Customer()
{
CustomerGuid = Guid.NewGuid(),
Active = true,
CreatedOnUtc = DateTime.UtcNow,
LastActivityDateUtc = DateTime.UtcNow,
};
//add to 'Guests' role
var guestRole = GetCustomerRoleBySystemName(SystemCustomerRoleNames.Guests);
if (guestRole == null)
throw new SmartException("'Guests' role could not be loaded");
customer.CustomerRoles.Add(guestRole);
_customerRepository.Insert(customer);
return customer;
}
/// <summary>
/// Delete a customer
/// </summary>
/// <param name="customer">Customer</param>
public virtual void DeleteCustomer(Customer customer)
{
if (customer == null)
throw new ArgumentNullException("customer");
if (customer.IsSystemAccount)
throw new SmartException(string.Format("System customer account ({0}) could not be deleted", customer.SystemName));
customer.Deleted = true;
UpdateCustomer(customer);
}
public void Can_validate_discount_dateRange()
{
var discount = new Discount
{
DiscountType = DiscountType.AssignedToSkus,
Name = "Discount 2",
UsePercentage = false,
DiscountPercentage = 0,
DiscountAmount = 5,
StartDateUtc = DateTime.UtcNow.AddDays(-1),
EndDateUtc = DateTime.UtcNow.AddDays(1),
RequiresCouponCode = false,
DiscountLimitation = DiscountLimitationType.Unlimited,
};
var customer = new Customer
{
CustomerGuid = Guid.NewGuid(),
AdminComment = "",
Active = true,
Deleted = false,
CreatedOnUtc = new DateTime(2010, 01, 01),
LastActivityDateUtc = new DateTime(2010, 01, 02)
};
var result1 = _discountService.IsDiscountValid(discount, customer);
result1.ShouldEqual(true);
discount.StartDateUtc = DateTime.UtcNow.AddDays(1);
var result2 = _discountService.IsDiscountValid(discount, customer);
result2.ShouldEqual(false);
}