/// <summary>
/// Check whether authentication by the passed external authentication method is available
/// </summary>
/// <param name="systemName">System name of the external authentication method</param>
/// <returns>True if authentication is available; otherwise false</returns>
public virtual bool ExternalAuthenticationMethodIsAvailable(string systemName)
{
//load method
var authenticationMethod = LoadExternalAuthenticationMethodBySystemName(systemName);
return(authenticationMethod != null &&
this.IsExternalAuthenticationMethodActive(authenticationMethod) &&
authenticationMethod.PluginDescriptor.Installed &&
_pluginFinder.AuthorizedForUser(authenticationMethod.PluginDescriptor, _workContext.CurrentUser));
}
/// <summary>
/// Load active exchange rate provider
/// </summary>
/// <param name="customer">Load records allowed only to a specified customer; pass null to ignore ACL permissions</param>
/// <returns>Active exchange rate provider</returns>
public virtual IExchangeRateProvider LoadActiveExchangeRateProvider(Customer customer = null)
{
var exchangeRateProvider = LoadExchangeRateProviderBySystemName(_currencySettings.ActiveExchangeRateProviderSystemName);
if (exchangeRateProvider == null || !_pluginFinder.AuthorizedForUser(exchangeRateProvider.PluginDescriptor, customer))
{
exchangeRateProvider = LoadAllExchangeRateProviders(customer).FirstOrDefault();
}
return(exchangeRateProvider);
}
/// <summary>
/// Get discount validation result
/// </summary>
/// <param name="requirements">Collection of discount requirement</param>
/// <param name="groupInteractionType">Interaction type within the group of requirements</param>
/// <param name="customer">Customer</param>
/// <param name="errors">Errors</param>
/// <returns>True if result is valid; otherwise false</returns>
protected bool GetValidationResult(IEnumerable <DiscountRequirementForCaching> requirements,
RequirementGroupInteractionType groupInteractionType, Customer customer, List <string> errors)
{
var result = false;
foreach (var requirement in requirements)
{
if (requirement.IsGroup)
{
//get child requirements for the group
var interactionType = requirement.InteractionType ?? RequirementGroupInteractionType.And;
result = GetValidationResult(requirement.ChildRequirements, interactionType, customer, errors);
}
else
{
//or try to get validation result for the requirement
var requirementRulePlugin = LoadDiscountRequirementRuleBySystemName(requirement.SystemName);
if (requirementRulePlugin == null)
{
continue;
}
if (!_pluginFinder.AuthorizedForUser(requirementRulePlugin.PluginDescriptor, customer))
{
continue;
}
if (!_pluginFinder.AuthenticateStore(requirementRulePlugin.PluginDescriptor, _storeContext.CurrentStore.Id))
{
continue;
}
var ruleResult = requirementRulePlugin.CheckRequirement(new DiscountRequirementValidationRequest
{
DiscountRequirementId = requirement.Id,
Customer = customer,
Store = _storeContext.CurrentStore
});
//add validation error
if (!ruleResult.IsValid)
{
errors.Add(ruleResult.UserError);
}
result = ruleResult.IsValid;
}
//all requirements must be met, so return false
if (!result && groupInteractionType == RequirementGroupInteractionType.And)
{
return(false);
}
//any of requirements must be met, so return true
if (result && groupInteractionType == RequirementGroupInteractionType.Or)
{
return(true);
}
}
return(result);
}
private ActionResult LoginInternal(string returnUrl, bool verifyResponse)
{
var processor = _openAuthenticationService.LoadExternalAuthenticationMethodBySystemName("ExternalAuth.Facebook");
if (processor == null ||
!processor.IsMethodActive(_externalAuthenticationSettings) ||
!processor.PluginDescriptor.Installed ||
!_pluginFinder.AuthenticateStore(processor.PluginDescriptor, _storeContext.CurrentStore.Id) ||
!_pluginFinder.AuthorizedForUser(processor.PluginDescriptor, _workContext.CurrentCustomer))
{
throw new NopException("Facebook module cannot be loaded");
}
var viewModel = new LoginModel();
TryUpdateModel(viewModel);
var result = _oAuthProviderFacebookAuthorizer.Authorize(returnUrl, verifyResponse);
switch (result.AuthenticationStatus)
{
case OpenAuthenticationStatus.Error:
{
if (!result.Success)
{
foreach (var error in result.Errors)
{
ExternalAuthorizerHelper.AddErrorsToDisplay(error);
}
}
return(new RedirectResult(Url.LogOn(returnUrl)));
}
case OpenAuthenticationStatus.AssociateOnLogon:
{
return(new RedirectResult(Url.LogOn(returnUrl)));
}
case OpenAuthenticationStatus.AutoRegisteredEmailValidation:
{
//result
return(RedirectToRoute("RegisterResult", new { resultId = (int)UserRegistrationType.EmailValidation }));
}
case OpenAuthenticationStatus.AutoRegisteredAdminApproval:
{
return(RedirectToRoute("RegisterResult", new { resultId = (int)UserRegistrationType.AdminApproval }));
}
case OpenAuthenticationStatus.AutoRegisteredStandard:
{
return(RedirectToRoute("RegisterResult", new { resultId = (int)UserRegistrationType.Standard }));
}
default:
break;
}
if (result.Result != null)
{
return(result.Result);
}
return(HttpContext.Request.IsAuthenticated ? new RedirectResult(!string.IsNullOrEmpty(returnUrl) ? returnUrl : "~/") : new RedirectResult(Url.LogOn(returnUrl)));
}
/// <summary>
/// Validate discount
/// </summary>
/// <param name="discount">Discount</param>
/// <param name="customer">Customer</param>
/// <param name="couponCodesToValidate">Coupon codes to validate</param>
/// <returns>Discount validation result</returns>
public virtual DiscountValidationResult ValidateDiscount(DiscountForCaching discount, Customer customer, string[] couponCodesToValidate)
{
if (discount == null)
{
throw new ArgumentNullException("discount");
}
if (customer == null)
{
throw new ArgumentNullException("customer");
}
//invalid by default
var result = new DiscountValidationResult();
//check coupon code
if (discount.RequiresCouponCode)
{
if (String.IsNullOrEmpty(discount.CouponCode))
{
return(result);
}
if (couponCodesToValidate == null)
{
return(result);
}
if (!couponCodesToValidate.Any(x => x.Equals(discount.CouponCode, StringComparison.InvariantCultureIgnoreCase)))
{
return(result);
}
}
//Do not allow discounts applied to order subtotal or total when a customer has gift cards in the cart.
//Otherwise, this customer can purchase gift cards with discount and get more than paid ("free money").
if (discount.DiscountType == DiscountType.AssignedToOrderSubTotal ||
discount.DiscountType == DiscountType.AssignedToOrderTotal)
{
var cart = customer.ShoppingCartItems
.Where(sci => sci.ShoppingCartType == ShoppingCartType.ShoppingCart)
.LimitPerStore(_storeContext.CurrentStore.Id)
.ToList();
var hasGiftCards = cart.Any(x => x.Product.IsGiftCard);
if (hasGiftCards)
{
result.UserError = _localizationService.GetResource("ShoppingCart.Discount.CannotBeUsedWithGiftCards");
return(result);
}
}
//check date range
DateTime now = DateTime.UtcNow;
if (discount.StartDateUtc.HasValue)
{
DateTime startDate = DateTime.SpecifyKind(discount.StartDateUtc.Value, DateTimeKind.Utc);
if (startDate.CompareTo(now) > 0)
{
result.UserError = _localizationService.GetResource("ShoppingCart.Discount.NotStartedYet");
return(result);
}
}
if (discount.EndDateUtc.HasValue)
{
DateTime endDate = DateTime.SpecifyKind(discount.EndDateUtc.Value, DateTimeKind.Utc);
if (endDate.CompareTo(now) < 0)
{
result.UserError = _localizationService.GetResource("ShoppingCart.Discount.Expired");
return(result);
}
}
//discount limitation
switch (discount.DiscountLimitation)
{
case DiscountLimitationType.NTimesOnly:
{
var usedTimes = GetAllDiscountUsageHistory(discount.Id, null, null, 0, 1).TotalCount;
if (usedTimes >= discount.LimitationTimes)
{
return(result);
}
}
break;
case DiscountLimitationType.NTimesPerCustomer:
{
if (customer.IsRegistered())
{
var usedTimes = GetAllDiscountUsageHistory(discount.Id, customer.Id, null, 0, 1).TotalCount;
if (usedTimes >= discount.LimitationTimes)
{
result.UserError = _localizationService.GetResource("ShoppingCart.Discount.CannotBeUsedAnymore");
return(result);
}
}
}
break;
case DiscountLimitationType.Unlimited:
default:
break;
}
//discount requirements
string key = string.Format(DiscountEventConsumer.DISCOUNT_REQUIREMENT_MODEL_KEY, discount.Id);
var requirements = _cacheManager.Get(key, () =>
{
var cachedRequirements = new List <DiscountRequirementForCaching>();
foreach (var dr in GetAllDiscountRequirements(discount.Id))
{
cachedRequirements.Add(new DiscountRequirementForCaching
{
Id = dr.Id,
SystemName = dr.DiscountRequirementRuleSystemName
});
}
return(cachedRequirements);
});
foreach (var req in requirements)
{
//load a plugin
var requirementRulePlugin = LoadDiscountRequirementRuleBySystemName(req.SystemName);
if (requirementRulePlugin == null)
{
continue;
}
if (!_pluginFinder.AuthorizedForUser(requirementRulePlugin.PluginDescriptor, customer))
{
continue;
}
if (!_pluginFinder.AuthenticateStore(requirementRulePlugin.PluginDescriptor, _storeContext.CurrentStore.Id))
{
continue;
}
var ruleRequest = new DiscountRequirementValidationRequest
{
DiscountRequirementId = req.Id,
Customer = customer,
Store = _storeContext.CurrentStore
};
var ruleResult = requirementRulePlugin.CheckRequirement(ruleRequest);
if (!ruleResult.IsValid)
{
result.UserError = ruleResult.UserError;
return(result);
}
}
result.IsValid = true;
return(result);
}
