/// <summary>
/// Sets the provided instance as the client for search service communication.
/// </summary>
/// <param name="repositoryBuilder">The <see cref="IRepositoryBuilder"/> instance.</param>
/// <param name="serviceClient">The client instance.</param>
public static IRepositoryBuilder UseLucene29CentralizedServiceClient(this IRepositoryBuilder repositoryBuilder,
ISearchServiceClient serviceClient)
{
SearchServiceClient.Instance = serviceClient;
return(repositoryBuilder);
}
/// <summary>
/// Sets the blob provider selector.
/// </summary>
/// <param name="repositoryBuilder"></param>
/// <param name="selector">IBlobProviderSelector instance.</param>
public static IRepositoryBuilder UseBlobProviderSelector(this IRepositoryBuilder repositoryBuilder, IBlobProviderSelector selector)
{
Configuration.Providers.Instance.BlobProviderSelector = selector;
WriteLog("BlobProviderSelector", selector);
return(repositoryBuilder);
}
/// <summary>
/// Sets the blob provider store.
/// </summary>
/// <param name="repositoryBuilder"></param>
/// <param name="store">IBlobProviderStore instance.</param>
public static IRepositoryBuilder UseBlobProviderStore(this IRepositoryBuilder repositoryBuilder, IBlobProviderStore store)
{
Configuration.Providers.Instance.BlobProviders = store;
WriteLog("IBlobProviderStore", store);
return(repositoryBuilder);
}
public static IRepositoryBuilder SetSource <TModel>(this IRepositoryBuilder repositoryBuilder, EntityFrameworkRepositorySource <TModel> repositorySource)
where TModel : class
{
repositoryBuilder.RepositorySource = repositorySource;
return(repositoryBuilder);
}
/// <summary>
/// Sets the application cache provider.
/// </summary>
/// <param name="repositoryBuilder"></param>
/// <param name="applicationCacheProvider">IApplicationCache instance.</param>
public static IRepositoryBuilder UseApplicationCacheProvider(this IRepositoryBuilder repositoryBuilder, IApplicationCache applicationCacheProvider)
{
Configuration.Providers.Instance.ApplicationCacheProvider = applicationCacheProvider;
WriteLog("ApplicationCacheProvider", applicationCacheProvider);
return(repositoryBuilder);
}
/// <summary>
/// Sets the membership extender used for extending user membership on-the-fly.
/// </summary>
/// <param name="repositoryBuilder"></param>
/// <param name="membershipExtender">MembershipExtender instance.</param>
public static IRepositoryBuilder UseMembershipExtender(this IRepositoryBuilder repositoryBuilder, MembershipExtenderBase membershipExtender)
{
Configuration.Providers.Instance.MembershipExtender = membershipExtender;
WriteLog("MembershipExtender", membershipExtender);
return(repositoryBuilder);
}
public RepositoryFactory(IRepositoryBuilder repositoryBuilder
, ILogger logger
)
{
_repositoryBuilder = repositoryBuilder;
_logger = logger;
}
/// <summary>
/// Sets the security message provider used for security messaging operations.
/// </summary>
/// <param name="repositoryBuilder"></param>
/// <param name="securityMessageProvider">IMessageProvider instance that will handle security-related messages.</param>
public static IRepositoryBuilder UseSecurityMessageProvider(this IRepositoryBuilder repositoryBuilder, IMessageProvider securityMessageProvider)
{
Configuration.Providers.Instance.SecurityMessageProvider = securityMessageProvider;
WriteLog("SecurityMessageProvider", securityMessageProvider);
return(repositoryBuilder);
}
/// <summary>
/// Sets the cache provider.
/// </summary>
/// <param name="repositoryBuilder"></param>
/// <param name="cacheProvider">ICache instance.</param>
public static IRepositoryBuilder UseCacheProvider(this IRepositoryBuilder repositoryBuilder, ISnCache cacheProvider)
{
Configuration.Providers.Instance.CacheProvider = cacheProvider;
WriteLog("CacheProvider", cacheProvider);
return(repositoryBuilder);
}
/// <summary>
/// Sets the access provider responsible for user-related technical operations in the system.
/// </summary>
/// <param name="repositoryBuilder"></param>
/// <param name="accessProvider">AccessProvider instance.</param>
public static IRepositoryBuilder UseAccessProvider(this IRepositoryBuilder repositoryBuilder, AccessProvider accessProvider)
{
Configuration.Providers.Instance.AccessProvider = accessProvider;
WriteLog("AccessProvider", accessProvider);
return(repositoryBuilder);
}
/// <summary>
/// Sets the permission filter factory responsible for creating a filter for every query execution.
/// </summary>
/// <param name="repositoryBuilder"></param>
/// <param name="permissionFilterFactory">IPermissionFilterFactory implementation instance.</param>
public static IRepositoryBuilder UsePermissionFilterFactory(this IRepositoryBuilder repositoryBuilder, IPermissionFilterFactory permissionFilterFactory)
{
Configuration.Providers.Instance.PermissionFilterFactory = permissionFilterFactory;
WriteLog("PermissionFilterFactory", permissionFilterFactory);
return(repositoryBuilder);
}
public static IRepositoryBuilder UseDocumentPreviewProvider(this IRepositoryBuilder repositoryBuilder,
DocumentPreviewProvider previewProvider)
{
Providers.Instance.PreviewProvider = previewProvider;
return(repositoryBuilder);
}
public static IRepositoryBuilder BuildInMemoryRepository(this IRepositoryBuilder repositoryBuilder,
InitialData initialData, InMemoryIndex initialIndex)
{
if (initialData == null)
{
throw new ArgumentNullException(nameof(initialData));
}
if (initialIndex == null)
{
throw new ArgumentNullException(nameof(initialIndex));
}
// Precedence: if a service is registered in the collection, use that
// instead of creating instances locally.
var services = (repositoryBuilder as RepositoryBuilder)?.Services;
if (services?.GetService <DataProvider>() is InMemoryDataProvider dataProvider)
{
// If there is an instance in the container, use that. We have to set
// these instances manually instead of using the extension method so that
// we do not overwrite the store instance.
Providers.Instance.DataProvider = dataProvider;
Providers.Instance.DataStore = services.GetService <IDataStore>();
}
else
{
dataProvider = new InMemoryDataProvider();
repositoryBuilder.UseDataProvider(dataProvider);
}
Providers.Instance.ResetBlobProviders();
var searchEngine = services?.GetService <ISearchEngine>() ?? new InMemorySearchEngine(initialIndex);
repositoryBuilder
.UseLogger(new DebugWriteLoggerAdapter())
.UseTracer(new SnDebugViewTracer())
.UseInitialData(initialData)
.UseSharedLockDataProviderExtension(new InMemorySharedLockDataProvider())
.UseExclusiveLockDataProviderExtension(new InMemoryExclusiveLockDataProvider())
.UseBlobMetaDataProvider(new InMemoryBlobStorageMetaDataProvider(dataProvider))
.UseBlobProviderSelector(new InMemoryBlobProviderSelector())
.AddBlobProvider(new InMemoryBlobProvider())
.UseAccessTokenDataProviderExtension(new InMemoryAccessTokenDataProvider())
.UsePackagingDataProviderExtension(new InMemoryPackageStorageProvider())
.UseSearchEngine(searchEngine)
.UseSecurityDataProvider(GetSecurityDataProvider(dataProvider))
.UseSecurityMessageProvider(new DefaultMessageProvider(new MessageSenderManager()))
.UseElevatedModificationVisibilityRuleProvider(new ElevatedModificationVisibilityRule())
.StartWorkflowEngine(false);
var statDp = services?.GetService <IStatisticalDataProvider>() as InMemoryStatisticalDataProvider
?? new InMemoryStatisticalDataProvider();
repositoryBuilder.UseStatisticalDataProvider(statDp);
Providers.Instance.PropertyCollector = new EventPropertyCollector();
return(repositoryBuilder);
}
/// <summary>
/// Sets the search engine used for querying and indexing.
/// </summary>
/// <param name="repositoryBuilder"></param>
/// <param name="searchEngine">SearchEngine instance.</param>
public static IRepositoryBuilder UseSearchEngine(this IRepositoryBuilder repositoryBuilder, ISearchEngine searchEngine)
{
Configuration.Providers.Instance.SearchEngine = searchEngine;
WriteLog("SearchEngine", searchEngine);
return(repositoryBuilder);
}
public static IRepositoryBuilder UseMailProvider(this IRepositoryBuilder repositoryBuilder, MailProvider mailProvider)
{
Providers.Instance.SetProvider(typeof(MailProvider), mailProvider);
SnLog.WriteInformation($"MailProvider created: {mailProvider?.GetType().FullName}");
return(repositoryBuilder);
}
/// <summary>
/// Sets the cluster channel provider.
/// </summary>
/// <param name="repositoryBuilder"></param>
/// <param name="clusterChannelProvider">IClusterChannel instance.</param>
public static IRepositoryBuilder UseClusterChannelProvider(this IRepositoryBuilder repositoryBuilder, IClusterChannel clusterChannelProvider)
{
Configuration.Providers.Instance.ClusterChannelProvider = clusterChannelProvider;
WriteLog("ClusterChannelProvider", clusterChannelProvider);
return(repositoryBuilder);
}
/// <summary>
/// Sets the blob metadata provider.
/// </summary>
/// <param name="repositoryBuilder"></param>
/// <param name="metaDataProvider">IBlobStorageMetaDataProvider instance.</param>
public static IRepositoryBuilder UseBlobMetaDataProvider(this IRepositoryBuilder repositoryBuilder, IBlobStorageMetaDataProvider metaDataProvider)
{
Configuration.Providers.Instance.BlobMetaDataProvider = metaDataProvider;
WriteLog("BlobMetaDataProvider", metaDataProvider);
return(repositoryBuilder);
}
/// <summary>
/// Sets the data provider used for all db operations in the system.
/// </summary>
/// <param name="repositoryBuilder"></param>
/// <param name="dataProvider">DataProvider instance.</param>
public static IRepositoryBuilder UseDataProvider(this IRepositoryBuilder repositoryBuilder, DataProvider dataProvider)
{
Configuration.Providers.Instance.DataProvider = dataProvider;
Configuration.Providers.Instance.InitializeDataStore();
return(repositoryBuilder);
}
public static IRepositoryBuilder BuildInMemoryRepository(this IRepositoryBuilder repositoryBuilder,
InitialData initialData, InMemoryIndex initialIndex)
{
if (initialData == null)
{
throw new ArgumentNullException(nameof(initialData));
}
if (initialIndex == null)
{
throw new ArgumentNullException(nameof(initialIndex));
}
var dataProvider = new InMemoryDataProvider();
repositoryBuilder
.UseLogger(new DebugWriteLoggerAdapter())
.UseTracer(new SnDebugViewTracer())
.UseDataProvider(dataProvider)
.UseInitialData(initialData)
.UseSharedLockDataProviderExtension(new InMemorySharedLockDataProvider())
.UseExclusiveLockDataProviderExtension(new InMemoryExclusiveLockDataProvider())
.UseBlobMetaDataProvider(new InMemoryBlobStorageMetaDataProvider(dataProvider))
.UseBlobProviderSelector(new InMemoryBlobProviderSelector())
.UseAccessTokenDataProviderExtension(new InMemoryAccessTokenDataProvider())
.UsePackagingDataProviderExtension(new InMemoryPackageStorageProvider())
.UseSearchEngine(new InMemorySearchEngine(initialIndex))
.UseSecurityDataProvider(GetSecurityDataProvider(dataProvider))
.UseElevatedModificationVisibilityRuleProvider(new ElevatedModificationVisibilityRule())
.StartWorkflowEngine(false);
Providers.Instance.PropertyCollector = new EventPropertyCollector();
return(repositoryBuilder);
}
public RepositoryFactory(IRepositoryBuilder repositoryBuilder
, ILogger <RepositoryFactory> logger
)
{
Init();
_repositoryBuilder = repositoryBuilder;
_logger = logger;
}
public RepositoryBuilder_Test(SmartSqlFixture smartSqlFixture)
{
SqlMapper = smartSqlFixture.SqlMapper;
_repositoryBuilder = new EmitRepositoryBuilder(null, null,
smartSqlFixture.LoggerFactory.CreateLogger <EmitRepositoryBuilder>());
_repositoryFactory = new RepositoryFactory(_repositoryBuilder,
smartSqlFixture.LoggerFactory.CreateLogger <RepositoryFactory>());
}
/// <summary>
/// Switches the ResponseLengthLimiter feature on.
/// </summary>
/// <param name="builder">The IRepositoryBuilder instance.</param>
/// <param name="maxResponseLengthInBytes">Response length limit value in bytes (optional).</param>
/// <param name="maxFileLengthInBytes">File length limit value in bytes (optional).</param>
/// <returns>The IRepositoryBuilder instance.</returns>
public static IRepositoryBuilder UseResponseLimiter(this IRepositoryBuilder builder,
long maxResponseLengthInBytes = 0, long maxFileLengthInBytes = 0)
{
Providers.Instance.SetProvider(typeof(IResponseLimiter),
new SnResponseLimiter(maxResponseLengthInBytes, maxFileLengthInBytes));
return(builder);
}
/// <summary>
/// Deletes the existing <see cref="IEventProcessor"/>s and registers the given elements.
/// </summary>
/// <param name="builder">The <see cref="IRepositoryBuilder"/> instance.</param>
/// <param name="processors">One or more <see cref="IEventProcessor"/> instance.</param>
/// <returns>The updated <see cref="IRepositoryBuilder"/>.</returns>
public static IRepositoryBuilder UseAsyncEventProcessors(this IRepositoryBuilder builder, params IEventProcessor[] processors)
{
var list = Providers.Instance.AsyncEventProcessors;
list.Clear();
builder.AddAsyncEventProcessors(processors);
return(builder);
}
/// <summary>
/// Sets DocumentBinaryProvider instances.
/// </summary>
public static IRepositoryBuilder UseDocumentBinaryProvider(this IRepositoryBuilder repositoryBuilder,
DocumentBinaryProvider documentBinaryProvider)
{
Configuration.Providers.Instance.SetProvider(DocumentBinaryProvider.DocumentBinaryProviderKey,
documentBinaryProvider);
return(repositoryBuilder);
}
/// <summary>
/// Set the centralized Lucene engine as the search engine and
/// sets the <see cref="GrpcServiceClient"/> as the client for
/// search service communication.
/// </summary>
/// <param name="repositoryBuilder">The <see cref="IRepositoryBuilder"/> instance.</param>
/// <param name="serviceAddress">Url of the gRPC search service.</param>
/// <param name="configure">Optional configure method.</param>
public static IRepositoryBuilder UseLucene29CentralizedSearchEngineWithGrpc(
this IRepositoryBuilder repositoryBuilder,
string serviceAddress,
Action <GrpcChannelOptions> configure = null)
{
return(repositoryBuilder
.UseLucene29CentralizedSearchEngine()
.UseLucene29CentralizedGrpcServiceClient(serviceAddress, configure));
}
public static IRepositoryBuilder SetProvider <T>(this IRepositoryBuilder repositoryBuilder, T provider)
{
var providerType = typeof(T);
Configuration.Providers.Instance.SetProvider(providerType, provider);
WriteLog(providerType.Name, provider);
return(repositoryBuilder);
}
/// <summary>
/// Registers one or more features in the system, represented by component instances.
/// Do not use this method directly in your code, it is intended to be used by the system.
/// Use the AddComponent extension method for the IServiceCollection api instead.
/// </summary>
public static IRepositoryBuilder UseComponent(this IRepositoryBuilder repositoryBuilder, params ISnComponent[] components)
{
foreach (var component in components)
{
Configuration.Providers.Instance.AddComponent(component);
}
return(repositoryBuilder);
}
public ScheduleManager(IRepositoryBuilder builder = null, IConfiguration configuration = null)
{
_log = LogManager.GetLogger(typeof(ScheduleManager));
Builder = builder ?? ServiceLocator.Current.GetInstance <IRepositoryBuilder>();
#if NETFRAMEWORK
httpRuntimeURL = ConfigurationManager.AppSettings["WebServerUrl"];
#else
httpRuntimeURL = configuration?.GetValue <string>("configuration:appSettings:add:WebServerUrl:value");
#endif
}
/// <summary>
/// Sets the Centralized Lucene search engine as the current search engine.
/// </summary>
public static IRepositoryBuilder UseLucene29CentralizedSearchEngine(this IRepositoryBuilder repositoryBuilder)
{
var searchEngine = new Lucene29SearchEngine(
new Lucene29CentralizedIndexingEngine(null, Options.Create(new CentralizedOptions())),
new Lucene29CentralizedQueryEngine());
repositoryBuilder.UseSearchEngine(searchEngine);
return(repositoryBuilder);
}
/// <summary>
/// Sets the <see cref="InitialData"/> that will be installed to the database in the repository start sequence.
/// </summary>
/// <param name="repositoryBuilder"></param>
/// <param name="initialData">Data file instance.</param>
/// <returns></returns>
public static IRepositoryBuilder UseInitialData(this IRepositoryBuilder repositoryBuilder, InitialData initialData)
{
if (!(repositoryBuilder is RepositoryBuilder repoBuilder))
{
throw new ApplicationException(
$"The repositoryBuilder is not an instance of {typeof(RepositoryBuilder).FullName}.");
}
repoBuilder.InitialData = initialData;
return(repositoryBuilder);
}
