/// <summary>
/// Deletes the provider.
/// </summary>
/// <param name="providerName">Name of the provider.</param>
/// <returns> <c>true</c> if [the provider was removed]; otherwise, <c>false</c>.</returns>
/// <exception cref="System.InvalidOperationException">
/// Provider setting not found.
/// or
/// </exception>
public static bool DeleteProvider(string providerName)
{
IContentProviderManager providerManager = ServiceLocator.Current.GetInstance <IContentProviderManager>();
ContentProvider pageProvider = providerManager.ProviderMap.GetProvider(providerName);
try
{
if (pageProvider != null)
{
providerManager.ProviderMap.RemoveProvider(providerName);
}
ClonedContentProviderSettings providerSetting = SettingsRepository.Instance.Get(providerName);
if (providerSetting != null)
{
SettingsRepository.Instance.Delete(providerSetting);
}
CacheManager.Clear();
}
catch (Exception exception)
{
Logger.Error(exception.Message, exception);
throw new InvalidOperationException(exception.Message);
}
return(true);
}
public DefaultContentImporterInterceptor(IContentImporter defaultContentImporter
, IPropertyImporter propertyImporter
, IContentRepository contentRepository
, ContentLanguageSettingRepository contentLanguageSettingRepository
, IPermanentLinkMapper permanentLinkMapper
, IContentProviderManager contentProviderManager
, IContentCacheRemover contentCacheRemover
, IContentCacheListingRemover contentCacheListingRemover
, IPageQuickSearch pageQuickSearch
, IContentTypeRepository contentTypeRepository
, IDynamicPropertiesLoader dynamicPropertiesLoader)
: base(propertyImporter, contentRepository, contentLanguageSettingRepository
, permanentLinkMapper, contentProviderManager, contentCacheRemover
, contentCacheListingRemover, pageQuickSearch, contentTypeRepository
, dynamicPropertiesLoader)
{
this.defaultContentImporter = defaultContentImporter;
this.propertyImporter = propertyImporter;
this.contentRepository = contentRepository;
this.contentLanguageSettingRepository = contentLanguageSettingRepository;
this.permanentLinkMapper = permanentLinkMapper;
this.contentProviderManager = contentProviderManager;
this.contentCacheRemover = contentCacheRemover;
this.contentCacheListingRemover = contentCacheListingRemover;
this.pageQuickSearch = pageQuickSearch;
this.contentTypeRepository = contentTypeRepository;
this.dynamicPropertiesLoader = dynamicPropertiesLoader;
}
public PreviewUrlResolver(UrlResolver defaultUrlResolver, IContentLoader contentLoader,
IPermanentLinkMapper permanentLinkMapper, IContentProviderManager providerManager)
{
_defaultUrlResolver = defaultUrlResolver;
_contentLoader = contentLoader;
_permanentLinkMapper = permanentLinkMapper;
_providerManager = providerManager;
}
public ExtendedWasteBasketStore(
IContentProviderManager contentProviderManager,
IContentLoader contentLoader,
IContentRepository contentRepository)
{
_contentProviderManager = contentProviderManager;
_contentLoader = contentLoader;
_contentRepository = contentRepository;
}
/// <summary>
/// Initializes a new instance of the <see cref="GetFilteredChildrenQuery" /> class.
/// </summary>
/// <param name="queryHelper">The query helper.</param>
/// <param name="contentRepository">The content repository.</param>
/// <param name="languageSelectorFactory">The language selector factory.</param>
/// <param name="contentProviderManager">The content provider manager.</param>
/// <param name="filterContentFactory"></param>
public GetFilteredChildrenQuery(
IContentProviderManager contentProviderManager,
IContentRepository contentRepository,
ContentFilterService filterContentFactory,
IContentQueryHelper queryHelper,
LanguageSelectorFactory languageSelectorFactory)
: base(queryHelper, contentRepository, languageSelectorFactory)
{
_contentProviderManager = contentProviderManager;
_filterContentFactory = filterContentFactory;
}
public YouTubeSearchProvider(LocalizationService localizationService,
SiteDefinitionResolver siteDefinitionResolver,
IContentTypeRepository contentTypeRepository,
IContentProviderManager contentProviderManager,
YouTubeRepository youTubeRepository,
IdentityMappingService identityMappingService)
: base(localizationService, siteDefinitionResolver, contentTypeRepository)
{
_youTubeRepository = youTubeRepository;
_identityMappingService = identityMappingService;
_youTubeProvider = contentProviderManager.GetProvider(YouTubeSettings.ProviderKey) as YouTubeProvider;
}
public ReviewsContentLoader(IContentLoader contentLoader, IContentLanguageAccessor languageAccessor,
ProjectContentResolver projectContentResolver,
IContentVersionRepository contentVersionRepository,
LanguageResolver languageResolver,
IContentProviderManager contentProviderManager,
IContentChildrenSorter childrenSorter)
{
_contentLoader = contentLoader;
_languageAccessor = languageAccessor;
_projectContentResolver = projectContentResolver;
_contentVersionRepository = contentVersionRepository;
_languageResolver = languageResolver;
_contentProviderManager = contentProviderManager;
_childrenSorter = childrenSorter;
}
/// <summary>
/// Loads the provider.
/// </summary>
/// <returns>
/// [true] if the provider has been loaded.
/// </returns>
private static bool LoadProviders()
{
IContentProviderManager providerManager = ServiceLocator.Current.GetInstance <IContentProviderManager>();
Collection <ClonedContentProviderSettings> providerCollection = SettingsRepository.Instance.GetAll();
foreach (ClonedContentProviderSettings providerSettings in providerCollection)
{
try
{
ContentProvider contentProvider = providerManager.GetProvider(providerSettings.Name);
if (contentProvider != null)
{
continue;
}
CategoryList categoryList =
new CategoryList(
providerSettings.CategoryList.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries)
.Select(int.Parse)
.ToArray());
ClonedContentProvider provider = new ClonedContentProvider(
providerSettings.Name,
new PageReference(providerSettings.Root),
new PageReference(providerSettings.EntryPoint),
categoryList);
providerManager.ProviderMap.AddProvider(provider);
}
catch (ArgumentNullException)
{
return(false);
}
catch (ArgumentException)
{
return(false);
}
catch (NotSupportedException)
{
return(false);
}
}
return(true);
}
/// <summary>
/// Adds the provider.
/// </summary>
/// <param name="root">The root.</param>
/// <param name="entryPoint">The entry point.</param>
/// <param name="providerName">Name of the provider.</param>
/// <param name="categoryList">The category list.</param>
/// <returns>
/// <c>true</c> if [the provider has been attached]; otherwise, <c>false</c>.
/// </returns>
/// <exception cref="System.InvalidOperationException">Content provider for this node already attached.
/// or
/// Content provider with same name already attached.</exception>
public static bool AddProvider(int root, int entryPoint, string providerName, CategoryList categoryList)
{
string name = string.Format(CultureInfo.InvariantCulture, "{0}-ClonedContent-{1}-{2}", providerName, root, entryPoint);
IQueryable <ClonedContentProviderSettings> providerCollection = SettingsRepository.Instance.GetAll().AsQueryable();
if (providerCollection.Count(pc => pc.EntryPoint.Equals(entryPoint)) > 0)
{
// A provider is already attached to this node.
throw new InvalidOperationException("Content provider for this node already attached.");
}
if (providerCollection.Count(pc => pc.Name.Equals(name)) > 0)
{
// A provider with the same name already exists.
throw new InvalidOperationException("Content provider with same name already attached.");
}
CategoryList categories = categoryList ?? new CategoryList();
ClonedContentProvider provider = new ClonedContentProvider(
name,
new PageReference(root),
new PageReference(entryPoint),
categories);
IContentProviderManager providerManager = ServiceLocator.Current.GetInstance <IContentProviderManager>();
ClonedContentProviderSettings contentProviderSettings = new ClonedContentProviderSettings
{
Name = name,
EntryPoint = entryPoint,
Root = root,
CategoryList =
string.Join(
",",
categories)
};
providerManager.ProviderMap.AddProvider(provider);
SettingsRepository.Instance.SaveSettings(contentProviderSettings);
CacheManager.Clear();
return(true);
}
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 ContentLocator(IContentLoader contentLoader, IContentProviderManager providerManager, IPageCriteriaQueryService pageCriteriaQueryService)
{
_contentLoader = contentLoader;
_providerManager = providerManager;
_pageCriteriaQueryService = pageCriteriaQueryService;
}
public YouTubeRepositoryDescriptor(IContentProviderManager providerManager)
{
_providerManager = providerManager;
}
public YouTubeRepositoryDescriptor(IContentProviderManager providerManager)
{
_providerManager = providerManager;
}
public PageListBlockController(IContentLoader contentLoader, IPageCriteriaQueryService pageCriteriaQueryService, IContentProviderManager providerManager)
{
_contentLoader = contentLoader;
_pageCriteriaQueryService = pageCriteriaQueryService;
_providerManager = providerManager;
}
public SiteDataFactory(IContentLoader contentLoader, IPageCriteriaQueryService pageCriteriaService, IContentProviderManager contentProviderManager)
{
_contentLoader = contentLoader;
_pageCriteriaService = pageCriteriaService;
_contentProviderManager = contentProviderManager;
}
private static void SetupProvider <TProvider>(TProvider provider, ContentReference entryPoint, IContentProviderManager contentProviderManager)
where TProvider : ContentProvider
{
NameValueCollection config = new NameValueCollection
{
{ ContentProviderElement.EntryPointString, entryPoint.ToString() }
};
provider.Initialize(provider.Name, config);
contentProviderManager.ProviderMap.AddProvider(provider);
}
