/// <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); }