public ReviewService(ICommentService commentService, IRatingService ratingService,
IRatingStatisticsService ratingStatisticsService, ISynchronizedObjectInstanceCache cache)
{
_commentService = commentService;
_ratingService = ratingService;
_ratingStatisticsService = ratingStatisticsService;
_cache = cache;
}
public ReplaceablesManager(
IReplaceableStorageProvider replaceableRepository,
ILanguageBranchRepository languageBranchRepository,
ISynchronizedObjectInstanceCache cacheManager)
{
_replaceableRepository = replaceableRepository;
_languageBranchRepository = languageBranchRepository;
_cacheManager = cacheManager;
}
public FoundationPromotionEngineContentLoader(
IContentLoader contentLoader,
CampaignInfoExtractor campaignInfoExtractor,
IPriceService priceService,
ReferenceConverter referenceConverter,
ISynchronizedObjectInstanceCache objectInstanceCache,
MarketingOptions marketingOptions,
IContentCacheKeyCreator contentCacheKeyCreator) : base(contentLoader, campaignInfoExtractor, priceService, referenceConverter, objectInstanceCache, marketingOptions, contentCacheKeyCreator)
{
_referenceConverter = referenceConverter;
}
public ContentFilterService(
FilterConfiguration filterConfiguration,
CheckedOptionsService filterModelFactory,
IContentRepository contentRepository,
ISynchronizedObjectInstanceCache synchronizedObjectInstanceCache,
SearchSortingService searchSorter,
ReferenceConverter referenceConverter,
IClient client)
: base(filterConfiguration, filterModelFactory, contentRepository, synchronizedObjectInstanceCache, searchSorter, referenceConverter, client)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="TaxonomyPartialRouter{TForPageType, TRootPageType}"/> class.
/// </summary>
/// <param name="basePathRoot">The function to use when evaluating the root for the router.</param>
public TaxonomyPartialRouter(Func <TForPageType, ContentReference> basePathRoot)
{
this.getBasePathRoot = basePathRoot;
this.contentRootService = ServiceLocator.Current.GetInstance <ContentRootService>();
this.urlResolver = ServiceLocator.Current.GetInstance <UrlResolver>();
this.contentLoader = ServiceLocator.Current.GetInstance <IContentLoader>();
this.contentCacheKeyCreator = ServiceLocator.Current.GetInstance <IContentCacheKeyCreator>();
this.cache = ServiceLocator.Current.GetInstance <ISynchronizedObjectInstanceCache>();
this.taxonomyRoot = this.contentRootService.Get(TaxonomyRepositoryDescriptor.RepositoryKey);
}
public VirtualTemplateRepository(IVirtualTemplatesCache virtualTemplatesCache,
ISynchronizedObjectInstanceCache cache, IContentRepository contentRepo,
IVirtualTemplateVersionRepository templateVersionRepo, ITemplateKeyConverter keyConverter,
LocalizationService localization)
{
_virtualTemplatesCache = virtualTemplatesCache;
_cache = cache;
_contentRepo = contentRepo;
_templateVersionRepo = templateVersionRepo;
_keyConverter = keyConverter;
_localization = localization;
}
public CacheableContentRendererService(
IContentRenderer defaultRenderer,
ICacheableSettingsService settingsService,
ISynchronizedObjectInstanceCache cache,
ICacheableKeyCreator keyCreator,
IContentCacheKeyCreator contentCacheKeyCreator)
{
DefaultRenderer = defaultRenderer ?? throw new ArgumentNullException(nameof(defaultRenderer));
SettingsService = settingsService ?? throw new ArgumentNullException(nameof(settingsService));
Cache = cache ?? throw new ArgumentNullException(nameof(cache));
KeyCreator = keyCreator ?? throw new ArgumentNullException(nameof(keyCreator));
ContentCacheKeyCreator = contentCacheKeyCreator ?? throw new ArgumentNullException(nameof(contentCacheKeyCreator));
MasterCacheKeys = new[] { ContentCacheKeyCreator.VersionKey };
}
public CachedCatalogContentTypeResolver(ICatalogContentTypeResolver internalResolver,
ISynchronizedObjectInstanceCache cache,
IContentCacheKeyCreator contentCacheKeyCreator,
ReferenceConverter referenceConverter)
{
_internalResolver = internalResolver;
_cache = cache;
var masterKey = CachePrefix + "*";
_cacheEvictionPolicyFunc = (contentLink) =>
new CacheEvictionPolicy(TimeSpan.FromMinutes(10),
CacheTimeoutType.Sliding,
new[] { contentCacheKeyCreator.CreateCommonCacheKey(contentLink) },
new[] { masterKey });
_referenceConverter = referenceConverter;
}
public DefaultRawContentRetrieverInterceptor(IRawContentRetriever defaultRawContentRetriever
, IContentRepository contentRepository
, IContentTypeRepository contentTypeRepository
, ILanguageBranchRepository languageBranchRepository
, IContentCacheKeyCreator contentCacheKeyCreator
, ISynchronizedObjectInstanceCache synchronizedObjectInstanceCache
, IRawPropertyRetriever rawPropertyRetriever)
: base(contentRepository, contentTypeRepository, languageBranchRepository
, contentCacheKeyCreator, synchronizedObjectInstanceCache, rawPropertyRetriever)
{
this.defaultRawContentRetriever = defaultRawContentRetriever;
this.contentRepository = contentRepository;
this.contentTypeRepository = contentTypeRepository;
this.languageBranchRepository = languageBranchRepository;
this.contentCacheKeyCreator = contentCacheKeyCreator;
this.synchronizedObjectInstanceCache = synchronizedObjectInstanceCache;
this.rawPropertyRetriever = rawPropertyRetriever;
}
protected FilteringServiceBase(
FilterConfiguration filterConfiguration,
CheckedOptionsService filterModelFactory,
IContentRepository contentRepository,
ISynchronizedObjectInstanceCache synchronizedObjectInstanceCache,
SearchSortingService searchSorter,
ReferenceConverter referenceConverter,
IClient client)
{
_filterConfiguration = filterConfiguration;
CheckedOptionsService = filterModelFactory;
ContentRepository = contentRepository;
_synchronizedObjectInstanceCache = synchronizedObjectInstanceCache;
SearchSortingService = searchSorter;
ReferenceConverter = referenceConverter;
Client = client;
//FilterContentsWithGenericTypes = new Lazy<IEnumerable<FilterContentModelType>>(FilterContentsWithGenericTypesValueFactory, false);
}
public CatalogContentTypeResolver(ReferenceConverter referenceConverter,
IContentTypeRepository contentTypeRepository,
ContentTypeModelRepository contentTypeModelRepository, ISynchronizedObjectInstanceCache cache, IContentCacheKeyCreator contentCacheKeyCreator)
{
_referenceConverter = referenceConverter;
_contentTypeModelRepository = contentTypeModelRepository;
_cache = cache;
_contentCacheKeyCreator = contentCacheKeyCreator;
_metaClassContentTypeModelMap = PopulateMetadataMappings();
_catalogContentType = contentTypeRepository.Load(typeof(CatalogContent));
var masterKey = CachePrefix + "*";
_cacheEvictionPolicyFunc = (contentLink) =>
new CacheEvictionPolicy(TimeSpan.FromMinutes(10),
CacheTimeoutType.Sliding,
new [] { _contentCacheKeyCreator.CreateCommonCacheKey(contentLink) },
new [] { masterKey });
}
/// <summary>
/// Initializes a new instance of the <see cref="PredictionEngineService" /> class.
/// </summary>
/// <param name="associationRepository">The association repository.</param>
/// <param name="recommendationRepository">The recommendation repository.</param>
/// <param name="referenceConverter">The reference converter.</param>
/// <param name="orderRepository">The order repository.</param>
/// <param name="currentMarket">The current market.</param>
/// <param name="filterPublished">The filter published.</param>
/// <param name="contentLoader">The content loader.</param>
/// <param name="languageResolver">The language resolver.</param>
/// <param name="synchronizedObjectInstanceCache">The synchronized object instance cache.</param>
public PredictionEngineService(
IAssociationRepository associationRepository,
IRecommendationRepository recommendationRepository,
ReferenceConverter referenceConverter,
IOrderRepository orderRepository,
ICurrentMarket currentMarket,
FilterPublished filterPublished,
IContentLoader contentLoader,
LanguageResolver languageResolver,
ISynchronizedObjectInstanceCache synchronizedObjectInstanceCache)
{
this.associationRepository = associationRepository;
this.recommendationRepository = recommendationRepository;
this.referenceConverter = referenceConverter;
this.orderRepository = orderRepository;
this.currentMarket = currentMarket;
this.filterPublished = filterPublished;
this.contentLoader = contentLoader;
this.languageResolver = languageResolver;
this.synchronizedObjectInstanceCache = synchronizedObjectInstanceCache;
}
public DefaultDataExporterInterceptor(IDataExporter defaultDataExporter
, ITransferExportOptionsEx transferExportOptionsEx
, IContentVersionRepository contentVersionRepository
, IRawContentRetriever rawContentRetriever
, IContentLoader contentLoader
, IPropertyExporter propertyExporter
, IDataExportEventsRaiser eventRegister
, IDataExportEvents exportEvents
, IContentCacheKeyCreator contentCacheKeyCreator
, ISynchronizedObjectInstanceCache cacheInstance
, IContentRepository contentRepository
, IPermanentLinkMapper permanentLinkMapper
, IContentTypeRepository contentTypeRepository
, IContentProviderManager contentProviderManager
, ContentTypeAvailabilityService contentTypeAvailabilityService
, IAvailableSettingsRepository availableSettingsRepository
, IContentExporter contentExporter
, PropertyCategoryTransform categoryTransform
, ContentRootRepository contentRootRepository
, ISiteDefinitionRepository siteDefinitionRepository
, IMimeTypeResolver mimeTypeResolver)
: base(eventRegister, exportEvents, contentCacheKeyCreator
, cacheInstance, contentRepository
, permanentLinkMapper, contentTypeRepository
, contentProviderManager, contentTypeAvailabilityService
, availableSettingsRepository, contentExporter
, categoryTransform, contentRootRepository
, siteDefinitionRepository, mimeTypeResolver)
{
_defaultDataExporter = defaultDataExporter;
_transferExportOptionsEx = transferExportOptionsEx;
_contentVersionRepository = contentVersionRepository;
_contentExporter = contentExporter;
_rawContentRetiever = rawContentRetriever;
_contentLoader = contentLoader;
_propertyExporter = propertyExporter;
}
public CategoryStatisticServiceDecorate(ICategoryStatisticService categoryStatisticService, ISynchronizedObjectInstanceCache synchronizedObjectInstanceCache)
{
_categoryStatisticService = categoryStatisticService;
_synchronizedObjectInstanceCache = synchronizedObjectInstanceCache;
}
public MyPriceService(ICatalogSystem catalogSystem, IChangeNotificationManager changeManager, ISynchronizedObjectInstanceCache objectInstanceCache, CatalogKeyEventBroadcaster broadcaster, IApplicationContext applicationContext)
{
_marketService = ServiceLocator.Current.GetInstance<IMarketService>();
_referenceConverter = ServiceLocator.Current.GetInstance<ReferenceConverter>();
}
public MarketAccessRightsMarketService(ISynchronizedObjectInstanceCache cache) : base(cache)
{
}
public AuthorStatisticServiceDecorate(IAuthorStatisticService authorStatisticService, ISynchronizedObjectInstanceCache synchronizedObjectInstanceCache)
{
_authorStatisticService = authorStatisticService;
_synchronizedObjectInstanceCache = synchronizedObjectInstanceCache;
}
public FacetUrlService(DynamicDataStoreFactory dynamicDataStoreFactory, ISynchronizedObjectInstanceCache objectInstanceCache, UrlResolver urlResolver)
{
_dynamicDataStoreFactory = dynamicDataStoreFactory;
_objectInstanceCache = objectInstanceCache;
_urlResolver = urlResolver;
}
public MiniLockingCachedFindPagesWithCriterion(SearchPages searchPages, PageTypeRepository pageTypeRepository, ISynchronizedObjectInstanceCache synchronizedObjectInstanceCache)
{
_searchPages = searchPages;
_pageTypeRepository = pageTypeRepository;
_synchronizedObjectInstanceCache = synchronizedObjectInstanceCache;
}
public ObjectCacheCommand(ISynchronizedObjectInstanceCache synchronizedObjectInstanceCache)
{
_cache = synchronizedObjectInstanceCache;
}
public MarketServiceCache(ISynchronizedObjectInstanceCache cache)
{
this._cache = cache;
}
public NugetFeedParser(ISynchronizedObjectInstanceCache cache)
{
_cache = cache;
_packageRepository =
PackageRepositoryFactory.Default.CreateRepository("http://nuget.episerver.com/feed/packages.svc/");
}
/// <summary>
/// Initializes a new instance of the <see cref="RecommendationRepository"/> class.
/// </summary>
/// <param name="databaseExecutor">The database executor.</param>
/// <param name="synchronizedObjectInstanceCache">The synchronized object instance cache.</param>
public RecommendationRepository(ServiceAccessor <IDatabaseExecutor> databaseExecutor, ISynchronizedObjectInstanceCache synchronizedObjectInstanceCache)
{
this.databaseExecutor = databaseExecutor;
this.synchronizedObjectInstanceCache = synchronizedObjectInstanceCache;
}
public FacetUrlService(DynamicDataStoreFactory dynamicDataStoreFactory, ISynchronizedObjectInstanceCache objectInstanceCache, UrlResolver urlResolver)
{
_dynamicDataStoreFactory = dynamicDataStoreFactory;
_objectInstanceCache = objectInstanceCache;
_urlResolver = urlResolver;
}
//OLD, not done will go away
public MyPriceService(IChangeNotificationManager changeManager
, ISynchronizedObjectInstanceCache objectInstanceCache
, CatalogKeyEventBroadcaster broadcaster, EntryIdentityResolver entryIdentityResolver, IApplicationContext appContext)
: base(changeManager, objectInstanceCache, broadcaster, appContext, entryIdentityResolver)
{
}
public UniqueCouponService(IConnectionStringHandler connectionHandler, ISynchronizedObjectInstanceCache cache)
{
_connectionHandler = connectionHandler;
_cache = cache;
}
public CustomSynchronizedCache(ISynchronizedObjectInstanceCache defaultCache)
{
// Allows us to use Episerver's default instance of ISynchronizedObjectInstanceCache. We could omit this to totally roll our own.
_defaultCache = defaultCache;
}
public CatFun(IContentRouteHelper crh, IContentRepository repo, ISynchronizedObjectInstanceCache cache)
{
_routeHelper = crh;
_repo = repo;
_cache = cache;
}
public EPiFocalPointPlugin(IContentCacheKeyCreator contentCacheKeyCreator, ISynchronizedObjectInstanceCache cache)
{
this.contentCacheKeyCreator = contentCacheKeyCreator;
this.cache = cache;
}
public ClearCacheCommand(ISynchronizedObjectInstanceCache cache)
{
_cache = cache;
}
public InProcessDistributedCache(ISynchronizedObjectInstanceCache localCache)
{
_localCache = localCache;
}
public CacheService(ISynchronizedObjectInstanceCache synchronizedObjectInstanceCache)
{
_cache = synchronizedObjectInstanceCache;
}
public CacheHelper(ILogger log, ISynchronizedObjectInstanceCache cacheManager)
{
_log = log;
_cacheManager = cacheManager;
}
public CacheRepository(ISynchronizedObjectInstanceCache cache)
{
//Assert.NotNull(cache, "Cache is null");
Cache = cache;
}
