public DefaultLogger(IRepository<Log> logRepository, IWebHelper webHelper, IDbContext dbContext, IWorkContext workContext)
{
this._logRepository = logRepository;
this._webHelper = webHelper;
this._dbContext = dbContext;
this._workContext = workContext;
}
public CheckoutAttributeController(ICheckoutAttributeService checkoutAttributeService,
ILanguageService languageService,
ILocalizedEntityService localizedEntityService,
ILocalizationService localizationService,
ITaxCategoryService taxCategoryService,
IWorkContext workContext,
ICurrencyService currencyService,
ICustomerActivityService customerActivityService,
CurrencySettings currencySettings,
IMeasureService measureService,
MeasureSettings measureSettings,
IPermissionService permissionService,
IStoreService storeService,
IStoreMappingService storeMappingService)
{
this._checkoutAttributeService = checkoutAttributeService;
this._languageService = languageService;
this._localizedEntityService = localizedEntityService;
this._localizationService = localizationService;
this._taxCategoryService = taxCategoryService;
this._workContext = workContext;
this._currencyService = currencyService;
this._customerActivityService = customerActivityService;
this._currencySettings = currencySettings;
this._measureService = measureService;
this._measureSettings = measureSettings;
this._permissionService = permissionService;
this._storeService = storeService;
this._storeMappingService = storeMappingService;
}
public BlogController(IBlogService blogService,
IWorkContext workContext,
IStoreContext storeContext,
IPictureService pictureService,
ILocalizationService localizationService,
IDateTimeHelper dateTimeHelper,
IWorkflowMessageService workflowMessageService,
IWebHelper webHelper,
ICacheManager cacheManager,
ICustomerActivityService customerActivityService,
IStoreMappingService storeMappingService,
MediaSettings mediaSettings,
BlogSettings blogSettings,
LocalizationSettings localizationSettings,
CustomerSettings customerSettings,
CaptchaSettings captchaSettings)
{
this._blogService = blogService;
this._workContext = workContext;
this._storeContext = storeContext;
this._pictureService = pictureService;
this._localizationService = localizationService;
this._dateTimeHelper = dateTimeHelper;
this._workflowMessageService = workflowMessageService;
this._webHelper = webHelper;
this._cacheManager = cacheManager;
this._customerActivityService = customerActivityService;
this._storeMappingService = storeMappingService;
this._mediaSettings = mediaSettings;
this._blogSettings = blogSettings;
this._localizationSettings = localizationSettings;
this._customerSettings = customerSettings;
this._captchaSettings = captchaSettings;
}
/// <summary>
/// 经纪人提现初始化
/// </summary>
/// <param name="bankcardService">bankcardService</param>
/// <param name="workContext">workContext</param>
/// <param name="brokerwithdrawService">brokerwithdrawdetailService</param>
/// <param name="brokerService">brokerService</param>
public BrokerWithdrawController(IBankCardService bankcardService, IWorkContext workContext, IBrokerWithdrawService brokerwithdrawService, IBrokerService brokerService)
{
_brokerwithdrawService = brokerwithdrawService;
_brokerService = brokerService;
_workContext = workContext;
_bankcardService = bankcardService;
}
/// <summary>
/// Ctor
/// </summary>
/// <param name="sciRepository">Shopping cart repository</param>
/// <param name="workContext">Work context</param>
/// <param name="currencyService">Currency service</param>
/// <param name="productService">Product settings</param>
/// <param name="localizationService">Localization service</param>
/// <param name="productAttributeParser">Product attribute parser</param>
/// <param name="checkoutAttributeService">Checkout attribute service</param>
/// <param name="checkoutAttributeParser">Checkout attribute parser</param>
/// <param name="priceFormatter">Price formatter</param>
/// <param name="customerService">Customer service</param>
/// <param name="shoppingCartSettings">Shopping cart settings</param>
/// <param name="eventPublisher">Event publisher</param>
/// <param name="permissionService">Permission service</param>
/// <param name="aclService">ACL service</param>
public ShoppingCartService(IRepository<ShoppingCartItem> sciRepository,
IWorkContext workContext, ICurrencyService currencyService,
IProductService productService, ILocalizationService localizationService,
IProductAttributeParser productAttributeParser,
ICheckoutAttributeService checkoutAttributeService,
ICheckoutAttributeParser checkoutAttributeParser,
IPriceFormatter priceFormatter,
ICustomerService customerService,
ShoppingCartSettings shoppingCartSettings,
IEventPublisher eventPublisher,
IPermissionService permissionService,
IAclService aclService)
{
this._sciRepository = sciRepository;
this._workContext = workContext;
this._currencyService = currencyService;
this._productService = productService;
this._localizationService = localizationService;
this._productAttributeParser = productAttributeParser;
this._checkoutAttributeService = checkoutAttributeService;
this._checkoutAttributeParser = checkoutAttributeParser;
this._priceFormatter = priceFormatter;
this._customerService = customerService;
this._shoppingCartSettings = shoppingCartSettings;
this._eventPublisher = eventPublisher;
this._permissionService = permissionService;
this._aclService = aclService;
}
public FroogleService(IScheduleTaskService scheduleTaskService,
IGoogleService googleService,
IProductService productService,
ICategoryService categoryService,
IManufacturerService manufacturerService,
IPictureService pictureService,
ICurrencyService currencyService,
IWebHelper webHelper,
ISettingService settingService,
IWorkContext workContext,
IMeasureService measureService,
MeasureSettings measureSettings,
StoreInformationSettings storeInformationSettings,
FroogleSettings froogleSettings,
CurrencySettings currencySettings,
GoogleProductObjectContext objectContext)
{
this._scheduleTaskService = scheduleTaskService;
this._googleService = googleService;
this._productService = productService;
this._categoryService = categoryService;
this._manufacturerService = manufacturerService;
this._pictureService = pictureService;
this._currencyService = currencyService;
this._webHelper = webHelper;
this._settingService = settingService;
this._workContext = workContext;
this._measureService = measureService;
this._measureSettings = measureSettings;
this._storeInformationSettings = storeInformationSettings;
this._froogleSettings = froogleSettings;
this._currencySettings = currencySettings;
this._objectContext = objectContext;
}
public PaymentPayPalStandardController(IWorkContext workContext,
IStoreService storeService,
ISettingService settingService,
IPaymentService paymentService,
IOrderService orderService,
IOrderProcessingService orderProcessingService,
ILocalizationService localizationService,
IStoreContext storeContext,
ILogger logger,
IWebHelper webHelper,
PaymentSettings paymentSettings,
PayPalStandardPaymentSettings payPalStandardPaymentSettings)
{
this._workContext = workContext;
this._storeService = storeService;
this._settingService = settingService;
this._paymentService = paymentService;
this._orderService = orderService;
this._orderProcessingService = orderProcessingService;
this._localizationService = localizationService;
this._storeContext = storeContext;
this._logger = logger;
this._webHelper = webHelper;
this._paymentSettings = paymentSettings;
this._payPalStandardPaymentSettings = payPalStandardPaymentSettings;
}
public MiscFacebookShopController(IAclService aclService,
ICacheManager cacheManager,
CatalogSettings catalogSettings,
ICategoryService categoryService,
ICurrencyService currencyService,
ILocalizationService localizationService,
IPermissionService permissionService,
IPictureService pictureService,
IPriceCalculationService priceCalculationService,
IPriceFormatter priceFormatter,
IProductService productService,
IStoreContext storeContext,
IStoreMappingService storeMappingService,
ITaxService taxService,
IWorkContext workContext)
{
this._aclService = aclService;
this._cacheManager = cacheManager;
this._catalogSettings = catalogSettings;
this._categoryService = categoryService;
this._currencyService = currencyService;
this._localizationService = localizationService;
this._permissionService = permissionService;
this._pictureService = pictureService;
this._priceCalculationService = priceCalculationService;
this._priceFormatter = priceFormatter;
this._productService = productService;
this._storeContext = storeContext;
this._storeMappingService = storeMappingService;
this._taxService = taxService;
this._workContext = workContext;
}
public ReturnRequestController(IOrderService orderService,
IWorkContext workContext,
IStoreContext storeContext,
ICurrencyService currencyService,
IPriceFormatter priceFormatter,
IOrderProcessingService orderProcessingService,
ILocalizationService localizationService,
ICustomerService customerService,
IWorkflowMessageService workflowMessageService,
IDateTimeHelper dateTimeHelper,
LocalizationSettings localizationSettings,
OrderSettings orderSettings)
{
this._orderService = orderService;
this._workContext = workContext;
this._storeContext = storeContext;
this._currencyService = currencyService;
this._priceFormatter = priceFormatter;
this._orderProcessingService = orderProcessingService;
this._localizationService = localizationService;
this._customerService = customerService;
this._workflowMessageService = workflowMessageService;
this._dateTimeHelper = dateTimeHelper;
this._localizationSettings = localizationSettings;
this._orderSettings = orderSettings;
}
public PaymentSagePayServerController(ISettingService settingService,
IPaymentService paymentService, IOrderService orderService,
IOrderProcessingService orderProcessingService,
ILogger logger, SagePayServerPaymentSettings sagePayServerPaymentSettings,
PaymentSettings paymentSettings, ILocalizationService localizationService,
IWorkContext workContext, ISagePayServerTransactionService sagePayServerTransactionService,
IOrderTotalCalculationService orderTotalCalculationService, ICurrencyService currencyService, CurrencySettings currencySettings,
IMobileDeviceHelper mobileDeviceHelper, OrderSettings orderSettings, HttpContextBase httpContext)
{
this._settingService = settingService;
this._paymentService = paymentService;
this._orderService = orderService;
this._orderProcessingService = orderProcessingService;
this._localizationService = localizationService;
this._sagePayServerTransactionService = sagePayServerTransactionService;
this._orderTotalCalculationService = orderTotalCalculationService;
this._currencyService = currencyService;
this._sagePayServerPaymentSettings = sagePayServerPaymentSettings;
this._paymentSettings = paymentSettings;
this._currencySettings = currencySettings;
this._orderSettings = orderSettings;
this._logger = logger;
this._workContext = workContext;
this._httpContext = httpContext;
this._mobileDeviceHelper = mobileDeviceHelper;
}
public OrderController(IOrderService orderService,
IShipmentService shipmentService, IWorkContext workContext,
ICurrencyService currencyService, IPriceFormatter priceFormatter,
IOrderProcessingService orderProcessingService, IDateTimeHelper dateTimeHelper,
IPaymentService paymentService, ILocalizationService localizationService,
IPdfService pdfService, IShippingService shippingService,
ICountryService countryService, IProductAttributeParser productAttributeParser,
IWebHelper webHelper,
CatalogSettings catalogSettings, OrderSettings orderSettings,
TaxSettings taxSettings, PdfSettings pdfSettings,
ShippingSettings shippingSettings, AddressSettings addressSettings)
{
this._orderService = orderService;
this._shipmentService = shipmentService;
this._workContext = workContext;
this._currencyService = currencyService;
this._priceFormatter = priceFormatter;
this._orderProcessingService = orderProcessingService;
this._dateTimeHelper = dateTimeHelper;
this._paymentService = paymentService;
this._localizationService = localizationService;
this._pdfService = pdfService;
this._shippingService = shippingService;
this._countryService = countryService;
this._productAttributeParser = productAttributeParser;
this._webHelper = webHelper;
this._catalogSettings = catalogSettings;
this._orderSettings = orderSettings;
this._taxSettings = taxSettings;
this._pdfSettings = pdfSettings;
this._shippingSettings = shippingSettings;
this._addressSettings = addressSettings;
}
public GoogleCheckoutPaymentProcessor(ISettingService settingService,
IWebHelper webHelper, ITaxService taxService,
IShippingService shippingService,
IOrderTotalCalculationService orderTotalCalculationService,
IProductAttributeFormatter productAttributeFormatter,
IPriceCalculationService priceCalculationService, IWorkContext workContext,
ICustomerService customerService, IGenericAttributeService genericAttributeService,
ICountryService countryService,
IStateProvinceService stateProvinceService, IOrderProcessingService orderProcessingService,
IOrderService orderService, ILogger logger, HttpContextBase httpContext)
{
this._settingService = settingService;
this._webHelper = webHelper;
this._taxService = taxService;
this._shippingService = shippingService;
this._orderTotalCalculationService = orderTotalCalculationService;
this._productAttributeFormatter = productAttributeFormatter;
this._priceCalculationService = priceCalculationService;
this._workContext = workContext;
this._customerService = customerService;
this._genericAttributeService = genericAttributeService;
this._countryService = countryService;
this._stateProvinceService = stateProvinceService;
this._orderProcessingService = orderProcessingService;
this._orderService = orderService;
this._logger = logger;
this._httpContext = httpContext;
}
/// <summary>
/// Ctor
/// </summary>
/// <param name="workContext">Work context</param>
/// <param name="storeContext">Store context</param>
/// <param name="priceCalculationService">Price calculation service</param>
/// <param name="taxService">Tax service</param>
/// <param name="shippingService">Shipping service</param>
/// <param name="paymentService">Payment service</param>
/// <param name="checkoutAttributeParser">Checkout attribute parser</param>
/// <param name="discountService">Discount service</param>
/// <param name="giftCardService">Gift card service</param>
/// <param name="genericAttributeService">Generic attribute service</param>
/// <param name="taxSettings">Tax settings</param>
/// <param name="rewardPointsSettings">Reward points settings</param>
/// <param name="shippingSettings">Shipping settings</param>
/// <param name="shoppingCartSettings">Shopping cart settings</param>
/// <param name="catalogSettings">Catalog settings</param>
public OrderTotalCalculationService(IWorkContext workContext,
IStoreContext storeContext,
IPriceCalculationService priceCalculationService,
ITaxService taxService,
IShippingService shippingService,
IPaymentService paymentService,
ICheckoutAttributeParser checkoutAttributeParser,
IDiscountService discountService,
IGiftCardService giftCardService,
IGenericAttributeService genericAttributeService,
TaxSettings taxSettings,
RewardPointsSettings rewardPointsSettings,
ShippingSettings shippingSettings,
ShoppingCartSettings shoppingCartSettings,
CatalogSettings catalogSettings)
{
this._workContext = workContext;
this._storeContext = storeContext;
this._priceCalculationService = priceCalculationService;
this._taxService = taxService;
this._shippingService = shippingService;
this._paymentService = paymentService;
this._checkoutAttributeParser = checkoutAttributeParser;
this._discountService = discountService;
this._giftCardService = giftCardService;
this._genericAttributeService = genericAttributeService;
this._taxSettings = taxSettings;
this._rewardPointsSettings = rewardPointsSettings;
this._shippingSettings = shippingSettings;
this._shoppingCartSettings = shoppingCartSettings;
this._catalogSettings = catalogSettings;
}
public WorkflowMessageService(
IMessageTemplateService messageTemplateService,
IQueuedEmailService queuedEmailService,
ILanguageService languageService,
ITokenizer tokenizer,
IEmailAccountService emailAccountService,
IMessageTokenProvider messageTokenProvider,
IStoreService storeService,
IStoreContext storeContext,
EmailAccountSettings emailAccountSettings,
IEventPublisher eventPublisher,
IWorkContext workContext,
HttpRequestBase httpRequest,
IDownloadService downloadServioce)
{
this._messageTemplateService = messageTemplateService;
this._queuedEmailService = queuedEmailService;
this._languageService = languageService;
this._tokenizer = tokenizer;
this._emailAccountService = emailAccountService;
this._messageTokenProvider = messageTokenProvider;
this._storeService = storeService;
this._storeContext = storeContext;
this._emailAccountSettings = emailAccountSettings;
this._eventPublisher = eventPublisher;
this._workContext = workContext;
this._httpRequest = httpRequest;
this._downloadServioce = downloadServioce;
}
/// <summary>
/// Ctor
/// </summary>
/// <param name="cacheManager">Cache manager</param>
/// <param name="categoryRepository">Category repository</param>
/// <param name="productCategoryRepository">ProductCategory repository</param>
/// <param name="productRepository">Product repository</param>
/// <param name="aclRepository">ACL record repository</param>
/// <param name="storeMappingRepository">Store mapping repository</param>
/// <param name="workContext">Work context</param>
/// <param name="storeContext">Store context</param>
/// <param name="eventPublisher">Event publisher</param>
public CategoryService(ICacheManager cacheManager,
IRepository<Category> categoryRepository,
IRepository<ProductCategory> productCategoryRepository,
IRepository<Product> productRepository,
IRepository<AclRecord> aclRepository,
IRepository<StoreMapping> storeMappingRepository,
IWorkContext workContext,
IStoreContext storeContext,
IEventPublisher eventPublisher,
IStoreMappingService storeMappingService,
IAclService aclService,
Lazy<IEnumerable<ICategoryNavigationFilter>> navigationFilters,
ICustomerService customerService,
IProductService productService,
IStoreService storeService)
{
this._cacheManager = cacheManager;
this._categoryRepository = categoryRepository;
this._productCategoryRepository = productCategoryRepository;
this._productRepository = productRepository;
this._aclRepository = aclRepository;
this._storeMappingRepository = storeMappingRepository;
this._workContext = workContext;
this._storeContext = storeContext;
this._eventPublisher = eventPublisher;
this._storeMappingService = storeMappingService;
this._aclService = aclService;
this._navigationFilters = navigationFilters;
this._customerService = customerService;
this._productService = productService;
this._storeService = storeService;
this.QuerySettings = DbQuerySettings.Default;
}
public UserRoleController(CoreSettings coreSettings, IPermissionService permissionService, IUserService userService, IWorkContext workContext)
{
_coreSettings = coreSettings;
_permissionService = permissionService;
_userService = userService;
_workContext = workContext;
}
public HomeInstallationQuoteController(
IWorkContext workContext,
ISettingService settingService,
IGenericAttributeService genericAttributeService,
ILocalizationService localizationService,
IMessageTokenProvider messageTokenProvider,
IEmailAccountService emailAccountService,
IEventPublisher eventPublisher,
IMessageTemplateService messageTemplateService,
ITokenizer tokenizer,
IQueuedEmailService queuedEmailService,
IProductService productService,
CaptchaSettings captchaSettings,
EmailAccountSettings emailAccountSettings)
{
_workContext = workContext;
_settingService = settingService;
_genericAttributeService = genericAttributeService;
_localizationService = localizationService;
_messageTokenProvider = messageTokenProvider;
_emailAccountService = emailAccountService;
_eventPublisher = eventPublisher;
_messageTemplateService = messageTemplateService;
_tokenizer = tokenizer;
_queuedEmailService = queuedEmailService;
_productService = productService;
_captchaSettings = captchaSettings;
_emailAccountSettings = emailAccountSettings;
}
public static IList<ProductSpecificationModel> PrepareProductSpecificationModel(this Controller controller,
IWorkContext workContext,
ISpecificationAttributeService specificationAttributeService,
ICacheManager cacheManager,
Product product)
{
if (product == null)
throw new ArgumentNullException("product");
string cacheKey = string.Format(ModelCacheEventConsumer.PRODUCT_SPECS_MODEL_KEY, product.Id, workContext.WorkingLanguage.Id);
return cacheManager.Get(cacheKey, () =>
{
var model = specificationAttributeService.GetProductSpecificationAttributesByProductId(product.Id, null, true)
.Select(psa =>
{
return new ProductSpecificationModel()
{
SpecificationAttributeId = psa.SpecificationAttributeOption.SpecificationAttributeId,
SpecificationAttributeName = psa.SpecificationAttributeOption.SpecificationAttribute.GetLocalized(x => x.Name),
SpecificationAttributeOption = !String.IsNullOrEmpty(psa.CustomValue) ? psa.CustomValue : psa.SpecificationAttributeOption.GetLocalized(x => x.Name),
};
}).ToList();
return model;
});
}
public PromoController(
IPromoUtilities promoUtilities,
IPriceFormatter priceFormatter,
IWorkContext workContext,
PromoSettings promoSettings,
IProductMappingService productMappingService,
IProductPromoMappingService productPromoMappingService,
IPromoDetailService promoDetailService,
IStoreService storeService,
IStoreContext storeContext,
IAttributeValueService attributeValueService,
ICurrencyService currencyService,
IPromoPictureService promoPictureService,
IPictureService pictureService,
IProductService productService,
ILocalizationService localizationService)
{
this._promoUtilities = promoUtilities;
this._priceFormatter = priceFormatter;
this._workContext = workContext;
this._productMappingService = productMappingService;
this._productPromoMappingService = productPromoMappingService;
this._promoDetailService = promoDetailService;
this._promoSettings = promoSettings;
this._storeService = storeService;
this._storeContext = storeContext;
this._attributeValueService = attributeValueService;
this._currencyService = currencyService;
this._promoPictureService = promoPictureService;
this._pictureService = pictureService;
this._productService = productService;
this._localizationService = localizationService;
}
public ManufacturerController(ICategoryService categoryService, IManufacturerService manufacturerService,
IManufacturerTemplateService manufacturerTemplateService, IProductService productService,
IStoreService storeService, IStoreMappingService storeMappingService,
IUrlRecordService urlRecordService, IPictureService pictureService,
ILanguageService languageService, ILocalizationService localizationService, ILocalizedEntityService localizedEntityService,
IExportManager exportManager, IWorkContext workContext,
ICustomerActivityService customerActivityService, IPermissionService permissionService,
IDateTimeHelper dateTimeHelper,
AdminAreaSettings adminAreaSettings, CatalogSettings catalogSettings)
{
this._categoryService = categoryService;
this._manufacturerTemplateService = manufacturerTemplateService;
this._manufacturerService = manufacturerService;
this._productService = productService;
this._storeService = storeService;
this._storeMappingService = storeMappingService;
this._urlRecordService = urlRecordService;
this._pictureService = pictureService;
this._languageService = languageService;
this._localizationService = localizationService;
this._localizedEntityService = localizedEntityService;
this._exportManager = exportManager;
this._workContext = workContext;
this._customerActivityService = customerActivityService;
this._permissionService = permissionService;
this._dateTimeHelper = dateTimeHelper;
this._adminAreaSettings = adminAreaSettings;
this._catalogSettings = catalogSettings;
}
public DiyGroupController(IPermissionService permissionService,
IDiyService branchService,
ILanguageService languageService,
ILocalizationService localizationService,
IStoreMappingService storeMappingService,
ILocalizedEntityService localizedEntityService,
IStoreService storeService,
IPictureService pictureService,
IUrlRecordService urlRecordService,
ICustomerActivityService customerActivityService,
IWorkContext workContext,
ICacheManager cacheManager,
DiySettings diySettings,
IWebHelper webHelper)
{
_permissionService = permissionService;
_diyService = branchService;
_languageService = languageService;
_localizationService = localizationService;
_storeMappingService = storeMappingService;
_localizedEntityService = localizedEntityService;
_storeService = storeService;
_pictureService = pictureService;
_urlRecordService = urlRecordService;
_customerActivityService = customerActivityService;
_workContext = workContext;
_cacheManager = cacheManager;
_diySettings = diySettings;
_webHelper = webHelper;
}
public MobSocialMessageService(IMessageTemplateService messageTemplateService,
IStoreService storeService, IMessageTokenProvider messageTokenProvider,
ILanguageService languageService,
IStoreContext storeContext,
IEventPublisher eventPublisher,
ITokenizer tokenizer, IQueuedEmailService queuedEmailService,
IEmailAccountService emailAccountService,
EmailAccountSettings emailAccountSettings,
ILocalizationService localizationService,
MessageTemplatesSettings messageTemplateSettings,
CatalogSettings catalogSettings,
IProductAttributeParser productAttributeParser, IWorkContext workContext)
{
_messageTemplateService = messageTemplateService;
_storeService = storeService;
_messageTokenProvider = messageTokenProvider;
_languageService = languageService;
_storeContext = storeContext;
_eventPublisher = eventPublisher;
_tokenizer = tokenizer;
_queuedEmailService = queuedEmailService;
_emailAccountService = emailAccountService;
_emailAccountSettings = emailAccountSettings;
_localizationService = localizationService;
_messageTemplateSettings = messageTemplateSettings;
_catalogSettings = catalogSettings;
_productAttributeParser = productAttributeParser;
_workContext = workContext;
}
public CommonController(IPaymentService paymentService,
IShippingService shippingService,
IShoppingCartService shoppingCartService,
ICurrencyService currencyService,
IMeasureService measureService,
ICustomerService customerService,
IUrlRecordService urlRecordService,
IWebHelper webHelper,
CurrencySettings currencySettings,
MeasureSettings measureSettings,
IDateTimeHelper dateTimeHelper,
ILanguageService languageService,
IWorkContext workContext,
IStoreContext storeContext,
IPermissionService permissionService,
ILocalizationService localizationService)
{
this._paymentService = paymentService;
this._shippingService = shippingService;
this._shoppingCartService = shoppingCartService;
this._currencyService = currencyService;
this._measureService = measureService;
this._customerService = customerService;
this._urlRecordService = urlRecordService;
this._webHelper = webHelper;
this._currencySettings = currencySettings;
this._measureSettings = measureSettings;
this._dateTimeHelper = dateTimeHelper;
this._languageService = languageService;
this._workContext = workContext;
this._storeContext = storeContext;
this._permissionService = permissionService;
this._localizationService = localizationService;
}
public ProductController(IProductService productService,
IProductTemplateService productTemplateService,
ICategoryService categoryService, IManufacturerService manufacturerService,
IWorkContext workContext, ILanguageService languageService,
ILocalizationService localizationService, ILocalizedEntityService localizedEntityService,
ISpecificationAttributeService specificationAttributeService, IPictureService pictureService,
ITaxCategoryService taxCategoryService, IProductTagService productTagService,
ICopyProductService copyProductService, IPdfService pdfService,
IExportManager exportManager, IImportManager importManager,
ICustomerActivityService customerActivityService,
IPermissionService permissionService, AdminAreaSettings adminAreaSettings)
{
this._productService = productService;
this._productTemplateService = productTemplateService;
this._categoryService = categoryService;
this._manufacturerService = manufacturerService;
this._workContext = workContext;
this._languageService = languageService;
this._localizationService = localizationService;
this._localizedEntityService = localizedEntityService;
this._specificationAttributeService = specificationAttributeService;
this._pictureService = pictureService;
this._taxCategoryService = taxCategoryService;
this._productTagService = productTagService;
this._copyProductService = copyProductService;
this._pdfService = pdfService;
this._exportManager = exportManager;
this._importManager = importManager;
this._customerActivityService = customerActivityService;
this._permissionService = permissionService;
this._adminAreaSettings = adminAreaSettings;
}
bool IAsyncWork.StartAndContinueWith(IWorkContext context, Action<Exception, string, bool> callback, out Exception exception)
{
new Thread(
() =>
{
var start = DateTime.Now;
Thread.Sleep(2500);
callback(null, start + " sleep " + DateTime.Now, true);
Thread.Sleep(2500);
callback(null, start + " sleep " + DateTime.Now, true);
Thread.Sleep(2500);
callback(null, start + " sleep " + DateTime.Now, true);
Thread.Sleep(2500);
callback(null, start + " sleep " + DateTime.Now, true);
Thread.Sleep(2500);
callback(null, start + " sleep " + DateTime.Now, true);
Thread.Sleep(2500);
callback(null, start + " sleep " + DateTime.Now, true);
Thread.Sleep(2500);
callback(null, start + " sleep " + DateTime.Now, true);
Thread.Sleep(2500);
callback(null, start + " sleep " + DateTime.Now, true);
Thread.Sleep(2500);
callback(null, start + " sleep " + DateTime.Now, false);
}).Start();
exception = null;
return true;
}
public FatecController(
INewsService newsService, IFatecService fatecService, IWorkContext workContext)
{
_newsService = newsService;
_fatecService = fatecService;
_workContext = workContext;
}
public new void SetUp()
{
_taxSettings = new TaxSettings();
_taxSettings.DefaultTaxAddressId = 10;
_workContext = null;
_addressService = MockRepository.GenerateMock<IAddressService>();
//default tax address
_addressService.Expect(x => x.GetAddressById(_taxSettings.DefaultTaxAddressId)).Return(new Address { Id = _taxSettings.DefaultTaxAddressId });
var pluginFinder = new PluginFinder();
_eventPublisher = MockRepository.GenerateMock<IEventPublisher>();
_eventPublisher.Expect(x => x.Publish(Arg<object>.Is.Anything));
_geoLookupService = MockRepository.GenerateMock<IGeoLookupService>();
_countryService = MockRepository.GenerateMock<ICountryService>();
_logger = MockRepository.GenerateMock<ILogger>();
_customerSettings = new CustomerSettings();
_addressSettings = new AddressSettings();
_taxService = new TaxService(_addressService, _workContext, _taxSettings,
pluginFinder, _geoLookupService, _countryService, _logger
, _customerSettings, _addressSettings);
}
public DiscountController(IDiscountService discountService,
ILocalizationService localizationService,
ICurrencyService currencyService,
ICategoryService categoryService,
IProductService productService,
IWebHelper webHelper,
IDateTimeHelper dateTimeHelper,
ICustomerActivityService customerActivityService,
CurrencySettings currencySettings,
IPermissionService permissionService,
IWorkContext workContext,
IManufacturerService manufacturerService,
IStoreService storeService,
IVendorService vendorService,
IOrderService orderService,
IPriceFormatter priceFormatter)
{
this._discountService = discountService;
this._localizationService = localizationService;
this._currencyService = currencyService;
this._categoryService = categoryService;
this._productService = productService;
this._webHelper = webHelper;
this._dateTimeHelper = dateTimeHelper;
this._customerActivityService = customerActivityService;
this._currencySettings = currencySettings;
this._permissionService = permissionService;
this._workContext = workContext;
this._manufacturerService = manufacturerService;
this._storeService = storeService;
this._vendorService = vendorService;
this._orderService = orderService;
this._priceFormatter = priceFormatter;
}
public MessageTokenProvider(ILanguageService languageService,
ILocalizationService localizationService, IDateTimeHelper dateTimeHelper,
IEmailAccountService emailAccountService,
IPriceFormatter priceFormatter, ICurrencyService currencyService,IWebHelper webHelper,
IWorkContext workContext, IDownloadService downloadService,
IOrderService orderService,
StoreInformationSettings storeSettings, MessageTemplatesSettings templatesSettings,
EmailAccountSettings emailAccountSettings, CatalogSettings catalogSettings,
TaxSettings taxSettings)
{
this._languageService = languageService;
this._localizationService = localizationService;
this._dateTimeHelper = dateTimeHelper;
this._emailAccountService = emailAccountService;
this._priceFormatter = priceFormatter;
this._currencyService = currencyService;
this._webHelper = webHelper;
this._workContext = workContext;
this._downloadService = downloadService;
this._orderService = orderService;
this._storeSettings = storeSettings;
this._templatesSettings = templatesSettings;
this._emailAccountSettings = emailAccountSettings;
this._catalogSettings = catalogSettings;
this._taxSettings = taxSettings;
}
public CheckoutController(IWorkContext workContext,
IShoppingCartService shoppingCartService, ILocalizationService localizationService,
ITaxService taxService, ICurrencyService currencyService,
IPriceFormatter priceFormatter, IOrderProcessingService orderProcessingService,
ICustomerService customerService, ICountryService countryService,
IStateProvinceService stateProvinceService, IShippingService shippingService,
IPaymentService paymentService, IOrderTotalCalculationService orderTotalCalculationService,
ILogger logger, IOrderService orderService, IWebHelper webHelper,
OrderSettings orderSettings, RewardPointsSettings rewardPointsSettings,
PaymentSettings paymentSettings)
{
this._workContext = workContext;
this._shoppingCartService = shoppingCartService;
this._localizationService = localizationService;
this._taxService = taxService;
this._currencyService = currencyService;
this._priceFormatter = priceFormatter;
this._orderProcessingService = orderProcessingService;
this._customerService = customerService;
this._countryService = countryService;
this._stateProvinceService = stateProvinceService;
this._shippingService = shippingService;
this._paymentService = paymentService;
this._orderTotalCalculationService = orderTotalCalculationService;
this._logger = logger;
this._orderService = orderService;
this._webHelper = webHelper;
this._orderSettings = orderSettings;
this._rewardPointsSettings = rewardPointsSettings;
this._paymentSettings = paymentSettings;
}
public YachtMerchantAccMgtService(
AQYachtContext aqYachtContext,
IWorkContext workContext,
IMapper mapper) : base(aqYachtContext, workContext, mapper)
{
}
public CommonModelFactory(ICategoryService categoryService,
IProductService productService,
IManufacturerService manufacturerService,
ITopicService topicService,
ILanguageService languageService,
ICurrencyService currencyService,
ILocalizationService localizationService,
IWorkContext workContext,
IStoreContext storeContext,
ISitemapGenerator sitemapGenerator,
IThemeContext themeContext,
IThemeProvider themeProvider,
IForumService forumService,
IGenericAttributeService genericAttributeService,
IWebHelper webHelper,
IPermissionService permissionService,
ICacheManager cacheManager,
IPageHeadBuilder pageHeadBuilder,
IPictureService pictureService,
HttpContextBase httpContext,
CatalogSettings catalogSettings,
StoreInformationSettings storeInformationSettings,
CommonSettings commonSettings,
BlogSettings blogSettings,
NewsSettings newsSettings,
ForumSettings forumSettings,
LocalizationSettings localizationSettings,
CaptchaSettings captchaSettings,
VendorSettings vendorSettings)
{
this._categoryService = categoryService;
this._productService = productService;
this._manufacturerService = manufacturerService;
this._topicService = topicService;
this._languageService = languageService;
this._currencyService = currencyService;
this._localizationService = localizationService;
this._workContext = workContext;
this._storeContext = storeContext;
this._sitemapGenerator = sitemapGenerator;
this._themeContext = themeContext;
this._themeProvider = themeProvider;
this._forumservice = forumService;
this._genericAttributeService = genericAttributeService;
this._webHelper = webHelper;
this._permissionService = permissionService;
this._cacheManager = cacheManager;
this._pageHeadBuilder = pageHeadBuilder;
this._pictureService = pictureService;
this._httpContext = httpContext;
this._catalogSettings = catalogSettings;
this._storeInformationSettings = storeInformationSettings;
this._commonSettings = commonSettings;
this._blogSettings = blogSettings;
this._newsSettings = newsSettings;
this._forumSettings = forumSettings;
this._localizationSettings = localizationSettings;
this._captchaSettings = captchaSettings;
this._vendorSettings = vendorSettings;
}
public ProductCommentController(IProductCommentService productCommentService, IProductService productService, IMemberService memberService, IWorkContext workContext, IOrderDetailService orderDetailService)
{
_productCommentService = productCommentService;
_productService = productService;
_memberService = memberService;
_workContext = workContext;
_orderDetailService = orderDetailService;
}
public PasswordFilter(IWorkContext workContext, IMediator mediator)
{
_workContext = workContext;
_mediator = mediator;
}
public KnowledgebaseController(KnowledgebaseSettings knowledgebaseSettings, IKnowledgebaseService knowledgebaseService, IWorkContext workContext,
IStoreContext storeContext, ICacheManager cacheManager, IAclService aclService, IStoreMappingService storeMappingService, ILocalizationService localizationService,
CaptchaSettings captchaSettings, LocalizationSettings localizationSettings, IWorkflowMessageService workflowMessageService,
ICustomerActivityService customerActivityService, IDateTimeHelper dateTimeHelper, CustomerSettings customerSettings,
MediaSettings mediaSettings, IPictureService pictureService)
{
this._knowledgebaseSettings = knowledgebaseSettings;
this._knowledgebaseService = knowledgebaseService;
this._workContext = workContext;
this._storeContext = storeContext;
this._cacheManager = cacheManager;
this._aclService = aclService;
this._storeMappingService = storeMappingService;
this._localizationService = localizationService;
this._captchaSettings = captchaSettings;
this._localizationSettings = localizationSettings;
this._workflowMessageService = workflowMessageService;
this._customerActivityService = customerActivityService;
this._dateTimeHelper = dateTimeHelper;
this._customerSettings = customerSettings;
this._mediaSettings = mediaSettings;
this._pictureService = pictureService;
}
public virtual IActionResult ArticleCommentAdd(string articleId, KnowledgebaseArticleModel model, bool captchaValid,
[FromServices] IWorkContext workContext)
{
if (!_knowledgebaseSettings.Enabled)
{
return(RedirectToRoute("HomePage"));
}
var article = _knowledgebaseService.GetPublicKnowledgebaseArticle(articleId);
if (article == null || !article.AllowComments)
{
return(RedirectToRoute("HomePage"));
}
if (workContext.CurrentCustomer.IsGuest() && !_knowledgebaseSettings.AllowNotRegisteredUsersToLeaveComments)
{
ModelState.AddModelError("", _localizationService.GetResource("Knowledgebase.Article.Comments.OnlyRegisteredUsersLeaveComments"));
}
//validate CAPTCHA
if (_captchaSettings.Enabled && _captchaSettings.ShowOnArticleCommentPage && !captchaValid)
{
ModelState.AddModelError("", _captchaSettings.GetWrongCaptchaMessage(_localizationService));
}
if (ModelState.IsValid)
{
var customer = _workContext.CurrentCustomer;
var comment = new KnowledgebaseArticleComment
{
ArticleId = article.Id,
CustomerId = customer.Id,
CommentText = model.AddNewComment.CommentText,
CreatedOnUtc = DateTime.UtcNow,
ArticleTitle = article.Name,
};
_knowledgebaseService.InsertArticleComment(comment);
if (!customer.HasContributions)
{
EngineContext.Current.Resolve <ICustomerService>().UpdateContributions(customer);
}
//notify a store owner
if (_knowledgebaseSettings.NotifyAboutNewArticleComments)
{
_workflowMessageService.SendArticleCommentNotificationMessage(comment, _localizationSettings.DefaultAdminLanguageId);
}
//activity log
_customerActivityService.InsertActivity("PublicStore.AddArticleComment", comment.Id, _localizationService.GetResource("ActivityLog.PublicStore.AddArticleComment"));
//The text boxes should be cleared after a comment has been posted
//That' why we reload the page
TempData["Grand.knowledgebase.addarticlecomment.result"] = _localizationService.GetResource("Knowledgebase.Article.Comments.SuccessfullyAdded");
return(RedirectToRoute("KnowledgebaseArticle", new { SeName = article.GetSeName() }));
}
//If we got this far, something failed, redisplay form
PrepareKnowledgebaseArticleModel(model, article);
return(View("Article", model));
}
public CrossSellProductModelValidator(
IEnumerable <IValidatorConsumer <ProductModel.CrossSellProductModel> > validators,
ILocalizationService localizationService, IProductService productService, IWorkContext workContext)
: base(validators)
{
if (workContext.CurrentCustomer.IsStaff())
{
RuleFor(x => x).MustAsync(async(x, y, context) =>
{
var product = await productService.GetProductById(x.ProductId);
if (product != null)
{
if (!product.AccessToEntityByStore(workContext.CurrentCustomer.StaffStoreId))
{
return(false);
}
}
return(true);
}).WithMessage(localizationService.GetResource("Admin.Catalog.Products.Permisions"));
}
else if (workContext.CurrentVendor != null)
{
RuleFor(x => x).MustAsync(async(x, y, context) =>
{
var product = await productService.GetProductById(x.ProductId);
if (product != null)
{
if (product != null && product.VendorId != workContext.CurrentVendor.Id)
{
return(false);
}
}
return(true);
}).WithMessage(localizationService.GetResource("Admin.Catalog.Products.Permisions"));
}
}
public OrderSummaryViewComponent(ICartService cartService, IWorkContext workContext)
{
_cartService = cartService;
_workContext = workContext;
}
public CommonModelFactory(AdminAreaSettings adminAreaSettings,
CatalogSettings catalogSettings,
CurrencySettings currencySettings,
IActionContextAccessor actionContextAccessor,
ICurrencyService currencyService,
ICustomerService customerService,
IDateTimeHelper dateTimeHelper,
IExternalAuthenticationService externalAuthenticationService,
INopFileProvider fileProvider,
IHttpContextAccessor httpContextAccessor,
ILanguageService languageService,
ILocalizationService localizationService,
IMaintenanceService maintenanceService,
IMeasureService measureService,
IOrderService orderService,
IPaymentService paymentService,
IPluginFinder pluginFinder,
IProductService productService,
IReturnRequestService returnRequestService,
ISearchTermService searchTermService,
IShippingService shippingService,
IStoreContext storeContext,
IStoreService storeService,
IUrlHelperFactory urlHelperFactory,
IUrlRecordService urlRecordService,
IWebHelper webHelper,
IWidgetService widgetService,
IWorkContext workContext,
MeasureSettings measureSettings,
TaxSettings taxSettings)
{
this._adminAreaSettings = adminAreaSettings;
this._catalogSettings = catalogSettings;
this._currencySettings = currencySettings;
this._actionContextAccessor = actionContextAccessor;
this._currencyService = currencyService;
this._customerService = customerService;
this._dateTimeHelper = dateTimeHelper;
this._externalAuthenticationService = externalAuthenticationService;
this._fileProvider = fileProvider;
this._httpContextAccessor = httpContextAccessor;
this._languageService = languageService;
this._localizationService = localizationService;
this._maintenanceService = maintenanceService;
this._measureService = measureService;
this._orderService = orderService;
this._paymentService = paymentService;
this._pluginFinder = pluginFinder;
this._productService = productService;
this._returnRequestService = returnRequestService;
this._searchTermService = searchTermService;
this._shippingService = shippingService;
this._storeContext = storeContext;
this._storeService = storeService;
this._urlHelperFactory = urlHelperFactory;
this._urlRecordService = urlRecordService;
this._webHelper = webHelper;
this._widgetService = widgetService;
this._workContext = workContext;
this._measureSettings = measureSettings;
this._taxSettings = taxSettings;
}
public PopupActionViewComponent(IPopupService popupService, IWorkContext workContext, IMediator mediator)
{
_popupService = popupService;
_workContext = workContext;
_mediator = mediator;
}
public string Run(IWorkContext context)
{
throw new NotImplementedException();
}
public SaveLastActivityFilter(ICustomerService customerService,
IWorkContext workContext)
{
this._customerService = customerService;
this._workContext = workContext;
}
public StockApiController(IRepository <Stock> stockRepository, IStockService stockService, IWorkContext workContext, IRepository <Warehouse> warehouseRepository, IRepository <StockHistory> stockHistoryRepository)
{
_stockRepository = stockRepository;
_stockService = stockService;
_workContext = workContext;
_warehouseRepository = warehouseRepository;
_stockHistoryRepository = stockHistoryRepository;
}
public DefaultAddressViewComponent(IRepository <Address> addressRepository, IWorkContext workContext)
{
_addressRepository = addressRepository;
_workContext = workContext;
}
public PermissionService(IDbAccessor omsAccessor, IWorkContext workContext) : base(omsAccessor, workContext)
{
}
public NovellActiveDirectoryAuthenticationController(NovellActiveDirectoryExternalAuthSettings novellActiveDirectoryExternalAuthSettings, IExternalAuthenticationService externalAuthenticationService, ILocalizationService localizationService, IPermissionService permissionService, ISettingService settingService, ICustomerService customerService, IAuthenticationService authenticationService, IShoppingCartService shoppingCartService, IWorkContext workContext, IEventPublisher eventPublisher, ICustomerActivityService customerActivityService, IStaticCacheManager cacheManager, INotificationService notificationService, ILdapService ldapService, IStoreService storeService, IStoreContext storeContext, IAuthenticationPluginManager authenticationPluginManager)
{
_novellActiveDirectoryExternalAuthSettings = novellActiveDirectoryExternalAuthSettings;
_externalAuthenticationService = externalAuthenticationService;
_localizationService = localizationService;
_permissionService = permissionService;
_settingService = settingService;
_customerService = customerService;
_authenticationService = authenticationService;
_shoppingCartService = shoppingCartService;
_workContext = workContext;
_eventPublisher = eventPublisher;
_customerActivityService = customerActivityService;
_cacheManager = cacheManager;
_notificationService = notificationService;
_ldapService = ldapService;
_storeService = storeService;
_storeContext = storeContext;
_authenticationPluginManager = authenticationPluginManager;
}
public MemberController(IMemberService memberService, AdminSettings adminSettings, IWorkContext workContext, IRoleService roleService)
{
_adminSettings = adminSettings;
_memberService = memberService;
_workContext = workContext;
_roleService = roleService;
}
public SidebarViewComponent(IPermissionService permissionService,
IWorkContext workContext)
{
this._permissionService = permissionService;
this._workContext = workContext;
}
public void TestInitialize()
{
var cacheManager = new TestMemoryCacheManager(new Mock <IMemoryCache>().Object);
tempWorkContext = new Mock <IWorkContext>();
{
_workContext = tempWorkContext.Object;
}
_currencySettings = new CurrencySettings();
var currency01 = new Currency
{
Id = "1",
Name = "Euro",
CurrencyCode = "EUR",
DisplayLocale = "",
CustomFormatting = "€0.00",
DisplayOrder = 1,
Published = true,
CreatedOnUtc = DateTime.UtcNow,
UpdatedOnUtc = DateTime.UtcNow
};
var currency02 = new Currency
{
Id = "1",
Name = "US Dollar",
CurrencyCode = "USD",
DisplayLocale = "en-US",
CustomFormatting = "",
DisplayOrder = 2,
Published = true,
CreatedOnUtc = DateTime.UtcNow,
UpdatedOnUtc = DateTime.UtcNow
};
var tempCurrencyRepo = new Mock <IRepository <Currency> >();
{
var tempIMongoCollection = new Mock <IMongoCollection <Currency> >().Object;
tempIMongoCollection.InsertOne(currency01);
tempIMongoCollection.InsertOne(currency02);
tempCurrencyRepo.Setup(x => x.Table).Returns(tempIMongoCollection.AsQueryable());
}
_storeMappingService = new Mock <IStoreMappingService>().Object;
_currencyRepo = new Mock <IRepository <Currency> >().Object;
var pluginFinder = new PluginFinder();
_currencyService = new CurrencyService(
cacheManager,
_currencyRepo,
_storeMappingService,
_currencySettings,
pluginFinder,
null);
_taxSettings = new TaxSettings();
var tempLocalizationService = new Mock <ILocalizationService>();
{
tempLocalizationService.Setup(x => x.GetResource("Products.InclTaxSuffix", "1", false, "", false)).Returns("{0} incl tax");
tempLocalizationService.Setup(x => x.GetResource("Products.ExclTaxSuffix", "1", false, "", false)).Returns("{0} excl tax");
_localizationService = tempLocalizationService.Object;
}
_priceFormatter = new PriceFormatter(_workContext, _currencyService, _localizationService, _taxSettings, _currencySettings);
}
public UserController(IUserService userService, IAuthorizeService authorizeService, IRoleService roleService, IMapper mapper, IEncryptionService encryptionService, IWorkContext workContext)
{
this.userService = userService;
this.authorizeService = authorizeService;
this.roleService = roleService;
this.mapper = mapper;
this.encryptionService = encryptionService;
this.workContext = workContext;
}
public HomeController(IWorkContext workContext)
{
_workContext = workContext;
}
public LawsManageController(ILawService lawsService, IWorkContext workContext)
{
this._lawsService = lawsService;
this._workContext = workContext;
}
public ProductReviewValidator(ILocalizationService localizationService, IDbContext dbContext, IWorkContext workContext)
{
var isLoggedInAsVendor = workContext.CurrentVendor != null;
//vendor can edit "Reply text" only
if (!isLoggedInAsVendor)
{
RuleFor(x => x.Title).NotEmpty().WithMessage(localizationService.GetResource("Admin.Catalog.ProductReviews.Fields.Title.Required"));
RuleFor(x => x.ReviewText).NotEmpty().WithMessage(localizationService.GetResource("Admin.Catalog.ProductReviews.Fields.ReviewText.Required"));
}
SetDatabaseValidationRules <ProductReview>(dbContext);
}
public CommonModelFactory(BlogSettings blogSettings,
CaptchaSettings captchaSettings,
CatalogSettings catalogSettings,
CommonSettings commonSettings,
CustomerSettings customerSettings,
DisplayDefaultFooterItemSettings displayDefaultFooterItemSettings,
ForumSettings forumSettings,
IActionContextAccessor actionContextAccessor,
IBlogService blogService,
ICategoryService categoryService,
ICurrencyService currencyService,
ICustomerService customerService,
IForumService forumService,
IGenericAttributeService genericAttributeService,
IHttpContextAccessor httpContextAccessor,
ILanguageService languageService,
ILocalizationService localizationService,
IManufacturerService manufacturerService,
INewsService newsService,
INopFileProvider fileProvider,
IPageHeadBuilder pageHeadBuilder,
IPermissionService permissionService,
IPictureService pictureService,
IProductService productService,
IProductTagService productTagService,
IShoppingCartService shoppingCartService,
ISitemapGenerator sitemapGenerator,
IStaticCacheManager cacheManager,
IStoreContext storeContext,
IThemeContext themeContext,
IThemeProvider themeProvider,
ITopicService topicService,
IUrlHelperFactory urlHelperFactory,
IUrlRecordService urlRecordService,
IWebHelper webHelper,
IWorkContext workContext,
LocalizationSettings localizationSettings,
MediaSettings mediaSettings,
NewsSettings newsSettings,
SitemapSettings sitemapSettings,
SitemapXmlSettings sitemapXmlSettings,
StoreInformationSettings storeInformationSettings,
VendorSettings vendorSettings)
{
_blogSettings = blogSettings;
_captchaSettings = captchaSettings;
_catalogSettings = catalogSettings;
_commonSettings = commonSettings;
_customerSettings = customerSettings;
_displayDefaultFooterItemSettings = displayDefaultFooterItemSettings;
_forumSettings = forumSettings;
_actionContextAccessor = actionContextAccessor;
_blogService = blogService;
_categoryService = categoryService;
_currencyService = currencyService;
_customerService = customerService;
_forumService = forumService;
_genericAttributeService = genericAttributeService;
_httpContextAccessor = httpContextAccessor;
_languageService = languageService;
_localizationService = localizationService;
_manufacturerService = manufacturerService;
_newsService = newsService;
_fileProvider = fileProvider;
_pageHeadBuilder = pageHeadBuilder;
_permissionService = permissionService;
_pictureService = pictureService;
_productService = productService;
_productTagService = productTagService;
_shoppingCartService = shoppingCartService;
_sitemapGenerator = sitemapGenerator;
_cacheManager = cacheManager;
_storeContext = storeContext;
_themeContext = themeContext;
_themeProvider = themeProvider;
_topicService = topicService;
_urlHelperFactory = urlHelperFactory;
_urlRecordService = urlRecordService;
_webHelper = webHelper;
_workContext = workContext;
_mediaSettings = mediaSettings;
_localizationSettings = localizationSettings;
_newsSettings = newsSettings;
_sitemapSettings = sitemapSettings;
_sitemapXmlSettings = sitemapXmlSettings;
_storeInformationSettings = storeInformationSettings;
_vendorSettings = vendorSettings;
}
public static IEnumerable <ProductOverviewModel> PrepareProductOverviewModels(this Controller controller,
IWorkContext workContext,
IStoreContext storeContext,
ICategoryService categoryService,
IProductService productService,
ISpecificationAttributeService specificationAttributeService,
IPriceCalculationService priceCalculationService,
IPriceFormatter priceFormatter,
IPermissionService permissionService,
ILocalizationService localizationService,
ITaxService taxService,
ICurrencyService currencyService,
IPictureService pictureService,
IWebHelper webHelper,
ICacheManager cacheManager,
CatalogSettings catalogSettings,
MediaSettings mediaSettings,
IEnumerable <Product> products,
bool preparePriceModel = true, bool preparePictureModel = true,
int?productThumbPictureSize = null, bool prepareSpecificationAttributes = false,
bool forceRedirectionAfterAddingToCart = false)
{
if (products == null)
{
throw new ArgumentNullException("products");
}
var models = new List <ProductOverviewModel>();
foreach (var product in products)
{
var model = new ProductOverviewModel
{
Id = product.Id,
Name = product.GetLocalized(x => x.Name),
ShortDescription = product.GetLocalized(x => x.ShortDescription),
FullDescription = product.GetLocalized(x => x.FullDescription),
SeName = product.GetSeName(),
};
//price
if (preparePriceModel)
{
#region Prepare product price
var priceModel = new ProductOverviewModel.ProductPriceModel
{
ForceRedirectionAfterAddingToCart = forceRedirectionAfterAddingToCart
};
switch (product.ProductType)
{
case ProductType.GroupedProduct:
{
#region Grouped product
var associatedProducts = productService.GetAssociatedProducts(product.Id, storeContext.CurrentStore.Id);
switch (associatedProducts.Count)
{
case 0:
{
//no associated products
//priceModel.DisableBuyButton = true;
//priceModel.DisableWishlistButton = true;
//compare products
priceModel.DisableAddToCompareListButton = !catalogSettings.CompareProductsEnabled;
//priceModel.AvailableForPreOrder = false;
}
break;
default:
{
//we have at least one associated product
//priceModel.DisableBuyButton = true;
//priceModel.DisableWishlistButton = true;
//compare products
priceModel.DisableAddToCompareListButton = !catalogSettings.CompareProductsEnabled;
//priceModel.AvailableForPreOrder = false;
if (permissionService.Authorize(StandardPermissionProvider.DisplayPrices))
{
//find a minimum possible price
decimal?minPossiblePrice = null;
Product minPriceProduct = null;
foreach (var associatedProduct in associatedProducts)
{
//calculate for the maximum quantity (in case if we have tier prices)
var tmpPrice = priceCalculationService.GetFinalPrice(associatedProduct,
workContext.CurrentCustomer, decimal.Zero, true, int.MaxValue);
if (!minPossiblePrice.HasValue || tmpPrice < minPossiblePrice.Value)
{
minPriceProduct = associatedProduct;
minPossiblePrice = tmpPrice;
}
}
if (minPriceProduct != null && !minPriceProduct.CustomerEntersPrice)
{
if (minPriceProduct.CallForPrice)
{
priceModel.OldPrice = null;
priceModel.Price = localizationService.GetResource("Products.CallForPrice");
}
else if (minPossiblePrice.HasValue)
{
//calculate prices
decimal taxRate;
decimal finalPriceBase = taxService.GetProductPrice(minPriceProduct, minPossiblePrice.Value, out taxRate);
decimal finalPrice = currencyService.ConvertFromPrimaryStoreCurrency(finalPriceBase, workContext.WorkingCurrency);
priceModel.OldPrice = null;
priceModel.Price = String.Format(localizationService.GetResource("Products.PriceRangeFrom"), priceFormatter.FormatPrice(finalPrice));
}
else
{
//Actually it's not possible (we presume that minimalPrice always has a value)
//We never should get here
Debug.WriteLine("Cannot calculate minPrice for product #{0}", product.Id);
}
}
}
else
{
//hide prices
priceModel.OldPrice = null;
priceModel.Price = null;
}
}
break;
}
#endregion
}
break;
case ProductType.SimpleProduct:
default:
{
#region Simple product
//add to cart button
priceModel.DisableBuyButton = product.DisableBuyButton ||
!permissionService.Authorize(StandardPermissionProvider.EnableShoppingCart) ||
!permissionService.Authorize(StandardPermissionProvider.DisplayPrices);
//add to wishlist button
priceModel.DisableWishlistButton = product.DisableWishlistButton ||
!permissionService.Authorize(StandardPermissionProvider.EnableWishlist) ||
!permissionService.Authorize(StandardPermissionProvider.DisplayPrices);
//compare products
priceModel.DisableAddToCompareListButton = !catalogSettings.CompareProductsEnabled;
//rental
priceModel.IsRental = product.IsRental;
//pre-order
if (product.AvailableForPreOrder)
{
priceModel.AvailableForPreOrder = !product.PreOrderAvailabilityStartDateTimeUtc.HasValue ||
product.PreOrderAvailabilityStartDateTimeUtc.Value >= DateTime.UtcNow;
priceModel.PreOrderAvailabilityStartDateTimeUtc = product.PreOrderAvailabilityStartDateTimeUtc;
}
//prices
if (permissionService.Authorize(StandardPermissionProvider.DisplayPrices))
{
if (!product.CustomerEntersPrice)
{
if (product.CallForPrice)
{
//call for price
priceModel.OldPrice = null;
priceModel.Price = localizationService.GetResource("Products.CallForPrice");
}
else
{
//prices
//calculate for the maximum quantity (in case if we have tier prices)
decimal minPossiblePrice = priceCalculationService.GetFinalPrice(product,
workContext.CurrentCustomer, decimal.Zero, true, int.MaxValue);
decimal taxRate;
decimal oldPriceBase = taxService.GetProductPrice(product, product.OldPrice, out taxRate);
decimal finalPriceBase = taxService.GetProductPrice(product, minPossiblePrice, out taxRate);
decimal oldPrice = currencyService.ConvertFromPrimaryStoreCurrency(oldPriceBase, workContext.WorkingCurrency);
decimal finalPrice = currencyService.ConvertFromPrimaryStoreCurrency(finalPriceBase, workContext.WorkingCurrency);
//do we have tier prices configured?
var tierPrices = new List <TierPrice>();
if (product.HasTierPrices)
{
tierPrices.AddRange(product.TierPrices
.OrderBy(tp => tp.Quantity)
.ToList()
.FilterByStore(storeContext.CurrentStore.Id)
.FilterForCustomer(workContext.CurrentCustomer)
.RemoveDuplicatedQuantities());
}
//When there is just one tier (with qty 1),
//there are no actual savings in the list.
bool displayFromMessage = tierPrices.Count > 0 &&
!(tierPrices.Count == 1 && tierPrices[0].Quantity <= 1);
if (displayFromMessage)
{
priceModel.OldPrice = null;
priceModel.Price = String.Format(localizationService.GetResource("Products.PriceRangeFrom"), priceFormatter.FormatPrice(finalPrice));
}
else
{
if (finalPriceBase != oldPriceBase && oldPriceBase != decimal.Zero)
{
priceModel.OldPrice = priceFormatter.FormatPrice(oldPrice);
priceModel.Price = priceFormatter.FormatPrice(finalPrice);
}
else
{
priceModel.OldPrice = null;
priceModel.Price = priceFormatter.FormatPrice(finalPrice);
}
}
if (product.IsRental)
{
//rental product
priceModel.OldPrice = priceFormatter.FormatRentalProductPeriod(product, priceModel.OldPrice);
priceModel.Price = priceFormatter.FormatRentalProductPeriod(product, priceModel.Price);
}
//property for German market
//we display tax/shipping info only with "shipping enabled" for this product
//we also ensure this it's not free shipping
priceModel.DisplayTaxShippingInfo = catalogSettings.DisplayTaxShippingInfoProductBoxes &&
product.IsShipEnabled &&
!product.IsFreeShipping;
}
}
}
else
{
//hide prices
priceModel.OldPrice = null;
priceModel.Price = null;
}
#endregion
}
break;
}
model.ProductPrice = priceModel;
#endregion
}
//picture
if (preparePictureModel)
{
#region Prepare product picture
//If a size has been set in the view, we use it in priority
int pictureSize = productThumbPictureSize.HasValue ? productThumbPictureSize.Value : mediaSettings.ProductThumbPictureSize;
//prepare picture model
var defaultProductPictureCacheKey = string.Format(ModelCacheEventConsumer.PRODUCT_DEFAULTPICTURE_MODEL_KEY, product.Id, pictureSize, true, workContext.WorkingLanguage.Id, webHelper.IsCurrentConnectionSecured(), storeContext.CurrentStore.Id);
model.DefaultPictureModel = cacheManager.Get(defaultProductPictureCacheKey, () =>
{
var picture = pictureService.GetPicturesByProductId(product.Id, 1).FirstOrDefault();
var pictureModel = new PictureModel
{
ImageUrl = pictureService.GetPictureUrl(picture, pictureSize),
FullSizeImageUrl = pictureService.GetPictureUrl(picture)
};
//"title" attribute
pictureModel.Title = (picture != null && !string.IsNullOrEmpty(picture.TitleAttribute)) ?
picture.TitleAttribute :
string.Format(localizationService.GetResource("Media.Product.ImageLinkTitleFormat"), model.Name);
//"alt" attribute
pictureModel.AlternateText = (picture != null && !string.IsNullOrEmpty(picture.AltAttribute)) ?
picture.AltAttribute :
string.Format(localizationService.GetResource("Media.Product.ImageAlternateTextFormat"), model.Name);
return(pictureModel);
});
#endregion
}
//specs
if (prepareSpecificationAttributes)
{
model.SpecificationAttributeModels = PrepareProductSpecificationModel(controller, workContext,
specificationAttributeService, cacheManager, product);
}
//reviews
model.ReviewOverviewModel = new ProductReviewOverviewModel
{
ProductId = product.Id,
RatingSum = product.ApprovedRatingSum,
TotalReviews = product.ApprovedTotalReviews,
AllowCustomerReviews = product.AllowCustomerReviews
};
models.Add(model);
}
return(models);
}
public virtual void PrepareSpecsFilters(IList <string> alreadyFilteredSpecOptionIds,
IList <string> filterableSpecificationAttributeOptionIds,
ISpecificationAttributeService specificationAttributeService,
IWebHelper webHelper,
IWorkContext workContext,
ICacheManager cacheManager)
{
string cacheKey = string.Format(ModelCacheEventConsumer.SPECS_FILTER_MODEL_KEY,
filterableSpecificationAttributeOptionIds != null ? string.Join(",", filterableSpecificationAttributeOptionIds) : "",
workContext.WorkingLanguage.Id);
var allFilters = cacheManager.Get(cacheKey, () =>
{
var _allFilters = new List <SpecificationAttributeOptionFilter>();
foreach (var sao in filterableSpecificationAttributeOptionIds)
{
string _specificationAttributeId = sao.Split(':').FirstOrDefault().ToString();
string _specificationAttributeOptionId = sao.Split(':').LastOrDefault().ToString();
var sa = EngineContext.Current.Resolve <ISpecificationAttributeService>().GetSpecificationAttributeById(_specificationAttributeId);
if (sa != null)
{
_allFilters.Add(new SpecificationAttributeOptionFilter
{
SpecificationAttributeId = sa.Id,
SpecificationAttributeName = sa.GetLocalized(x => x.Name, workContext.WorkingLanguage.Id),
SpecificationAttributeDisplayOrder = sa.DisplayOrder,
SpecificationAttributeOptionId = sao,
SpecificationAttributeOptionName = sa.SpecificationAttributeOptions.FirstOrDefault(x => x.Id == _specificationAttributeOptionId).GetLocalized(x => x.Name, workContext.WorkingLanguage.Id),
SpecificationAttributeOptionDisplayOrder = sa.SpecificationAttributeOptions.FirstOrDefault(x => x.Id == _specificationAttributeOptionId).DisplayOrder,
SpecificationAttributeOptionColorRgb = sa.SpecificationAttributeOptions.FirstOrDefault(x => x.Id == _specificationAttributeOptionId).ColorSquaresRgb,
});
}
}
return(_allFilters.ToList());
});
//sort loaded options
allFilters = allFilters.OrderBy(saof => saof.SpecificationAttributeDisplayOrder)
.ThenBy(saof => saof.SpecificationAttributeName)
.ThenBy(saof => saof.SpecificationAttributeOptionDisplayOrder)
.ThenBy(saof => saof.SpecificationAttributeOptionName).ToList();
//get already filtered specification options
var alreadyFilteredOptions = allFilters
.Where(x => alreadyFilteredSpecOptionIds.Contains(x.SpecificationAttributeOptionId))
.Select(x => x)
.ToList();
//get not filtered specification options
var notFilteredOptions = new List <SpecificationAttributeOptionFilter>();
foreach (var saof in allFilters)
{
//do not add already filtered specification options
if (alreadyFilteredOptions.FirstOrDefault(x => x.SpecificationAttributeId == saof.SpecificationAttributeId) != null)
{
continue;
}
//else add it
notFilteredOptions.Add(saof);
}
//prepare the model properties
if (alreadyFilteredOptions.Count > 0 || notFilteredOptions.Count > 0)
{
this.Enabled = true;
this.AlreadyFilteredItems = alreadyFilteredOptions.ToList().Select(x =>
{
var item = new SpecificationFilterItem();
item.SpecificationAttributeName = x.SpecificationAttributeName;
item.SpecificationAttributeOptionName = x.SpecificationAttributeOptionName;
item.SpecificationAttributeOptionColorRgb = x.SpecificationAttributeOptionColorRgb;
return(item);
}).ToList();
this.NotFilteredItems = notFilteredOptions.ToList().Select(x =>
{
var item = new SpecificationFilterItem();
item.SpecificationAttributeName = x.SpecificationAttributeName;
item.SpecificationAttributeOptionName = x.SpecificationAttributeOptionName;
item.SpecificationAttributeOptionColorRgb = x.SpecificationAttributeOptionColorRgb;
//filter URL
var alreadyFilteredOptionIds = GetAlreadyFilteredSpecOptionIds(webHelper);
if (!alreadyFilteredOptionIds.Contains(x.SpecificationAttributeOptionId.ToString()))
{
alreadyFilteredOptionIds.Add(x.SpecificationAttributeOptionId.ToString());
}
string newQueryParam = GenerateFilteredSpecQueryParam(alreadyFilteredOptionIds);
string filterUrl = webHelper.ModifyQueryString(webHelper.GetThisPageUrl(true), QUERYSTRINGPARAM + "=" + newQueryParam, null);
filterUrl = ExcludeQueryStringParams(filterUrl, webHelper);
item.FilterUrl = filterUrl;
return(item);
}).ToList();
//remove filter URL
string removeFilterUrl = webHelper.RemoveQueryString(webHelper.GetThisPageUrl(true), QUERYSTRINGPARAM);
removeFilterUrl = ExcludeQueryStringParams(removeFilterUrl, webHelper);
this.RemoveFilterUrl = removeFilterUrl;
}
else
{
this.Enabled = false;
}
}
public virtual void PrepareSpecsFilters(IList <int> alreadyFilteredSpecOptionIds,
IList <int> filterableSpecificationAttributeOptionIds,
ISpecificationAttributeService specificationAttributeService,
IWebHelper webHelper,
IWorkContext workContext)
{
var allFilters = new List <SpecificationAttributeOptionFilter>();
if (filterableSpecificationAttributeOptionIds != null)
{
foreach (var saoId in filterableSpecificationAttributeOptionIds)
{
var sao = specificationAttributeService.GetSpecificationAttributeOptionById(saoId);
if (sao != null)
{
var sa = sao.SpecificationAttribute;
if (sa != null)
{
allFilters.Add(new SpecificationAttributeOptionFilter
{
SpecificationAttributeId = sa.Id,
SpecificationAttributeName = sa.GetLocalized(x => x.Name, workContext.WorkingLanguage.Id),
SpecificationAttributeDisplayOrder = sa.DisplayOrder,
SpecificationAttributeOptionId = sao.Id,
SpecificationAttributeOptionName = sao.GetLocalized(x => x.Name, workContext.WorkingLanguage.Id),
SpecificationAttributeOptionDisplayOrder = sao.DisplayOrder
});
}
}
}
}
//sort loaded options
allFilters = allFilters.OrderBy(saof => saof.SpecificationAttributeDisplayOrder)
.ThenBy(saof => saof.SpecificationAttributeOptionDisplayOrder)
.ThenBy(saof => saof.SpecificationAttributeName)
.ThenBy(saof => saof.SpecificationAttributeOptionName).ToList();
//get already filtered specification options
var alreadyFilteredOptions = allFilters
.Where(x => alreadyFilteredSpecOptionIds.Contains(x.SpecificationAttributeOptionId))
.Select(x => x)
.ToList();
//get not filtered specification options
var notFilteredOptions = new List <SpecificationAttributeOptionFilter>();
foreach (var saof in allFilters)
{
//do not add already filtered specification options
if (alreadyFilteredOptions
.Where(x => x.SpecificationAttributeId == saof.SpecificationAttributeId)
.FirstOrDefault() != null)
{
continue;
}
//else add it
notFilteredOptions.Add(saof);
}
//prepare the model properties
if (alreadyFilteredOptions.Count > 0 || notFilteredOptions.Count > 0)
{
this.Enabled = true;
this.AlreadyFilteredItems = alreadyFilteredOptions.ToList().Select(x =>
{
var item = new SpecificationFilterItem();
item.SpecificationAttributeName = x.SpecificationAttributeName;
item.SpecificationAttributeOptionName = x.SpecificationAttributeOptionName;
return(item);
}).ToList();
this.NotFilteredItems = notFilteredOptions.ToList().Select(x =>
{
var item = new SpecificationFilterItem();
item.SpecificationAttributeName = x.SpecificationAttributeName;
item.SpecificationAttributeOptionName = x.SpecificationAttributeOptionName;
//filter URL
var alreadyFilteredOptionIds = GetAlreadyFilteredSpecOptionIds(webHelper);
if (!alreadyFilteredOptionIds.Contains(x.SpecificationAttributeOptionId))
{
alreadyFilteredOptionIds.Add(x.SpecificationAttributeOptionId);
}
string newQueryParam = GenerateFilteredSpecQueryParam(alreadyFilteredOptionIds);
string filterUrl = webHelper.ModifyQueryString(webHelper.GetThisPageUrl(true), QUERYSTRINGPARAM + "=" + newQueryParam, null);
filterUrl = ExcludeQueryStringParams(filterUrl, webHelper);
item.FilterUrl = filterUrl;
return(item);
}).ToList();
//remove filter URL
string removeFilterUrl = webHelper.RemoveQueryString(webHelper.GetThisPageUrl(true), QUERYSTRINGPARAM);
removeFilterUrl = ExcludeQueryStringParams(removeFilterUrl, webHelper);
this.RemoveFilterUrl = removeFilterUrl;
}
else
{
this.Enabled = false;
}
}
public EPayPaymentProcessor(ISettingService settingService,
ICurrencyService currencyService, ICustomerService customerService,
CurrencySettings currencySettings, IWebHelper webHelper,
IStoreContext storeContext,
INotificationService notificationService,
IOrderTotalCalculationService orderTotalCalculationService, IWorkContext workContext, EPayPaymentSettings ePayPaymentSettings,
IOrderService orderService, ILocalizationService localizationService, IHttpContextAccessor httpContextAccessor, IGenericAttributeService genericAttributeService,
IPaymentService paymentService)
{
_settingService = settingService;
_currencyService = currencyService;
_customerService = customerService;
_currencySettings = currencySettings;
_notificationService = notificationService;
_webHelper = webHelper;
_storeContext = storeContext;
_orderTotalCalculationService = orderTotalCalculationService;
_workContext = workContext;
_ePayPaymentSettings = ePayPaymentSettings;
_orderService = orderService;
_localizationService = localizationService;
_httpContextAccessor = httpContextAccessor;
_genericAttributeService = genericAttributeService;
_paymentService = paymentService;
}
/// <summary>
/// Get localized value of enum
/// </summary>
/// <typeparam name="T">Enum</typeparam>
/// <param name="enumValue">Enum value</param>
/// <param name="localizationService">Localization service</param>
/// <param name="workContext">Work context</param>
/// <returns>Localized value</returns>
public static string GetLocalizedEnum <T>(this T enumValue, ILocalizationService localizationService, IWorkContext workContext)
where T : struct
{
if (workContext == null)
{
throw new ArgumentNullException("workContext");
}
return(GetLocalizedEnum <T>(enumValue, localizationService, workContext.WorkingLanguage.Id));
}
public static IList <ProductSpecificationModel> PrepareProductSpecificationModel(this Controller controller,
IWorkContext workContext,
ISpecificationAttributeService specificationAttributeService,
ICacheManager cacheManager,
Product product)
{
if (product == null)
{
throw new ArgumentNullException("product");
}
string cacheKey = string.Format(ModelCacheEventConsumer.PRODUCT_SPECS_MODEL_KEY, product.Id, workContext.WorkingLanguage.Id);
return(cacheManager.Get(cacheKey, () =>
specificationAttributeService.GetProductSpecificationAttributes(product.Id, 0, null, true)
.Select(psa =>
{
var m = new ProductSpecificationModel
{
SpecificationAttributeId = psa.SpecificationAttributeOption.SpecificationAttributeId,
SpecificationAttributeName = psa.SpecificationAttributeOption.SpecificationAttribute.GetLocalized(x => x.Name),
};
switch (psa.AttributeType)
{
case SpecificationAttributeType.Option:
m.ValueRaw = HttpUtility.HtmlEncode(psa.SpecificationAttributeOption.GetLocalized(x => x.Name));
break;
case SpecificationAttributeType.CustomText:
m.ValueRaw = HttpUtility.HtmlEncode(psa.CustomValue);
break;
case SpecificationAttributeType.CustomHtmlText:
m.ValueRaw = psa.CustomValue;
break;
case SpecificationAttributeType.Hyperlink:
m.ValueRaw = string.Format("<a href='{0}' target='_blank'>{0}</a>", psa.CustomValue);
break;
default:
break;
}
return m;
}).ToList()
));
}
