public static IFhirService GetFhirService(Uri baseUri, IStorageBuilder storageBuilder,
IServiceListener[] listeners = null)
{
FhirExtensionsBuilder extensionsBuilder = new FhirExtensionsBuilder(storageBuilder, baseUri);
return(GetFhirService(baseUri, extensionsBuilder, storageBuilder, listeners));
}
/// <summary>
/// Uses the EntityFramework Core as a storage for saving and loading data.
/// <para>
/// Note: It means Parbad can save and load the data in different database providers
/// such as SQL Server, MySql, Sqlite, PostgreSQL, Oracle, InMemory, etc.
/// For more information see: https://docs.microsoft.com/en-us/ef/core/providers/.
/// </para>
/// <para>Note: This database is only for internal usages such as saving and loading payment information.
/// You don't need to think about merging and using this database with your own database.
/// The important payment information such as Tracking Number, Transaction Code, etc. will you get from the result of
/// all payment requests.</para>
/// </summary>
/// <param name="builder"></param>
/// <param name="configureEfCoreOptions">Configures the EntityFrameworkCore options for Parbad.</param>
public static IStorageBuilder UseEfCore(this IStorageBuilder builder, Action <EntityFrameworkCoreOptions> configureEfCoreOptions)
{
if (builder == null)
{
throw new ArgumentNullException(nameof(builder));
}
if (configureEfCoreOptions == null)
{
throw new ArgumentNullException(nameof(configureEfCoreOptions));
}
var options = new EntityFrameworkCoreOptions();
configureEfCoreOptions(options);
builder.Services.Configure(configureEfCoreOptions);
builder.Services.AddDbContext <ParbadDataContext>(dbBuilder =>
{
options.ConfigureDbContext?.Invoke(dbBuilder);
});
builder.AddStorage <EntityFrameworkCoreStorage>(ServiceLifetime.Transient);
builder.AddStorageManager <EntityFrameworkCoreStorageManager>(ServiceLifetime.Transient);
return(builder);
}
/// <summary>
/// Uses <see cref="IDistributedCache"/> for saving and loading data.
/// </summary>
/// <param name="builder"></param>
/// <param name="configureOptions"></param>
public static IStorageBuilder UseDistributedCache(this IStorageBuilder builder, Action <DistributedCacheStorageOptions> configureOptions)
{
builder.Services.Configure(configureOptions);
builder.AddStorage <DistributedCacheStorage>(ServiceLifetime.Transient);
return(builder);
}
public static IDomainStorageBuilder UseDomainStorage(this IStorageBuilder builder)
{
if (builder == null)
{
throw new ArgumentNullException(nameof(builder));
}
var services = builder.Services;
// Configure necessary application parts
services.ConfigureApplicationParts(ConfigureFeatureProviders);
// TODO: Replace
//services.AddSingleton(new JsonSerializerSettings
//{
// TypeNameHandling = TypeNameHandling.Auto,
// Formatting = Formatting.Indented,
// PreserveReferencesHandling = PreserveReferencesHandling.Objects,
// ReferenceLoopHandling = ReferenceLoopHandling.Serialize,
// ConstructorHandling = ConstructorHandling.AllowNonPublicDefaultConstructor
//});
services.AddTransient <ISerializerSettingsResolver, SerializerSettingsResolver>();
AddStreamStore(services);
AddDomainStorageEngine(services);
AddProjectionEngine(services);
AddMessageProcessors(services);
return(new DomainStorageBuilder(builder));
}
public ScopedFhirServiceBuilder(Uri baseUri, IStorageBuilder <TScope> storageBuilder,
IServiceListener[] listeners = null)
{
this.baseUri = baseUri;
this.storageBuilder = storageBuilder;
this.listeners = listeners;
this.fhirService = FhirServiceFactory.GetFhirService(baseUri, storageBuilder, listeners);
}
/// <summary>
/// Uses the default implementation of <see cref="IStorageManager"/>.
/// </summary>
/// <param name="builder"></param>
public static IStorageBuilder UseDefaultStorageManager(this IStorageBuilder builder)
{
if (builder == null)
{
throw new ArgumentNullException(nameof(builder));
}
return(builder.AddStorageManager <StorageManager>(ServiceLifetime.Transient));
}
public static IStorageBuilder UseInMemoryDatabase(this IStorageBuilder builder)
{
if (builder == null)
{
throw new ArgumentNullException(nameof(builder));
}
builder.UseDatabase <InMemoryDatabase>();
return(builder);
}
public static IStorageBuilder AddSqlServerQueue(this IStorageBuilder builder, string name, Action <SqlServerQueueOptions> configure)
{
builder.AddQueueClient <SqlServerQueueClient, SqlServerQueueOptions>(name, configure);
builder.Services.AddDbContext <QueueDbContext>((serviceProvider, dbContextBuilder) =>
{
var optionsMonitor = serviceProvider.GetRequiredService <IOptionsMonitor <SqlServerQueueOptions> >();
var options = optionsMonitor.Get(Helpers.GetQualifiedQueueName(name));
dbContextBuilder.UseQueryTrackingBehavior(QueryTrackingBehavior.NoTracking);
dbContextBuilder.UseSqlServer(options.ConnectionString);
}, ServiceLifetime.Singleton, ServiceLifetime.Singleton);
return(builder);
}
public FhirExtensionsBuilder(IStorageBuilder fhirStoreBuilder, Uri baseUri)
{
this.fhirStoreBuilder = fhirStoreBuilder;
this.baseUri = baseUri;
var extensionBuilders = new Func <IFhirServiceExtension>[]
{
GetSearch,
GetHistory,
GetConformance,
GetPaging,
GetStorage
};
extensions = extensionBuilders.Select(builder => builder()).Where(ext => ext != null).ToList();
}
/// <summary>
/// Adds an implementation of <see cref="IStorageManager"/> which required by Parbad for managing the storage operations.
/// </summary>
/// <param name="builder"></param>
/// <param name="factory"></param>
/// <param name="lifetime">The lifetime of given StorageManager.</param>
public static IStorageBuilder AddStorageManager(this IStorageBuilder builder, Func <IServiceProvider, IStorageManager> factory, ServiceLifetime lifetime)
{
if (builder == null)
{
throw new ArgumentNullException(nameof(builder));
}
if (factory == null)
{
throw new ArgumentNullException(nameof(factory));
}
builder.Services.AddOrUpdate(factory, lifetime);
return(builder);
}
public static IStorageBuilder Configure(this IStorageBuilder builder, Action <StorageOptions> configuration)
{
if (builder == null)
{
throw new ArgumentNullException(nameof(builder));
}
if (configuration == null)
{
throw new ArgumentNullException(nameof(configuration));
}
builder.Services.Configure(configuration);
return(builder);
}
public static IStorageBuilder ExtendStorage(this IStorageBuilder builder,
IEnumerable <IStorageExtension> extensions)
{
if (builder == null)
{
throw new ArgumentNullException(nameof(builder));
}
if (extensions == null)
{
throw new ArgumentNullException(nameof(extensions));
}
// TODO
return(builder); // .Configure(options => options.Extensions.AddRange(hooks));
}
/// <summary>
/// Adds an implementation of <see cref="IStorageManager"/> which required by Parbad for managing the storage operations.
/// </summary>
/// <param name="builder"></param>
/// <param name="storageManager"></param>
public static IStorageBuilder AddStorageManager(this IStorageBuilder builder, IStorageManager storageManager)
{
if (builder == null)
{
throw new ArgumentNullException(nameof(builder));
}
if (storageManager == null)
{
throw new ArgumentNullException(nameof(storageManager));
}
builder.Services
.RemoveAll <IStorageManager>()
.AddSingleton(storageManager);
return(builder);
}
public static IStorageBuilder UseMongoDB(this IStorageBuilder builder, Action <MongoOptions> configuration, bool useNativeTransactions = false)
{
if (builder == null)
{
throw new ArgumentNullException(nameof(builder));
}
if (configuration == null)
{
throw new ArgumentNullException(nameof(configuration));
}
builder.UseMongoDB(useNativeTransactions);
builder.Services.Configure(configuration);
return(builder);
}
/// <summary>
/// Uses the Entityframework Core as a storage for saving and loading data.
/// <para>
/// Note: It means Parbad can save and load the data in different database providers
/// such as SQL Server, MySql, Sqlite, PostgreSQL, Oracle, InMemory, etc.
/// For more information see: https://docs.microsoft.com/en-us/ef/core/providers/.
/// </para>
/// <para>Note: This database is only for internal usages such as saving and loading payment information.
/// You don't need to think about merging and using this database with your own database.
/// The important payment information such as Tracking Number, Transaction Code, etc. will you get from the result of
/// all payment requests.</para>
/// </summary>
/// <param name="builder"></param>
/// <param name="configureDatabaseBuilder">Configure what database must be used and how it must be created.</param>
public static IEntityFrameworkCoreStorageBuilder UseEntityFrameworkCore(this IStorageBuilder builder,
Action <DbContextOptionsBuilder> configureDatabaseBuilder)
{
if (builder == null)
{
throw new ArgumentNullException(nameof(builder));
}
if (configureDatabaseBuilder == null)
{
throw new ArgumentNullException(nameof(configureDatabaseBuilder));
}
builder.Services.AddDbContext <ParbadDataContext>(configureDatabaseBuilder);
builder.AddStorage <EntityFrameworkCoreStorage>(ServiceLifetime.Transient);
return(new EntityFrameworkCoreStorageBuilder(builder.Services));
}
public static IDomainStorageBuilder UseDomainStorage(this IStorageBuilder builder,
Action <DomainStorageOptions> configuration)
{
if (builder == null)
{
throw new ArgumentNullException(nameof(builder));
}
if (configuration == null)
{
throw new ArgumentNullException(nameof(configuration));
}
var result = UseDomainStorage(builder);
result.Services.Configure(configuration);
return(result);
}
public static IFhirService GetFhirService(Uri baseUri, IFhirExtensionsBuilder extensionsBuilder,
IStorageBuilder storageBuilder, //we won't need this anymore if we can remove the Transfer dependency for IFhirService
IServiceListener[] listeners = null)
{
IGenerator generator = storageBuilder.GetStore <IGenerator>();
IFhirServiceExtension[] extensions = extensionsBuilder.GetExtensions().ToArray();
IServiceListener[] computedListeners = (listeners ?? Enumerable.Empty <IServiceListener>())
.Union(extensions.OfType <IServiceListener>())
.ToArray();
ICompositeServiceListener serviceListener = new ServiceListener(new Localhost(baseUri), computedListeners);
Transfer transfer = new Transfer(generator, new Localhost(baseUri));
return(new FhirService(extensions,
GetFhirResponseFactory(baseUri),
transfer,
serviceListener));
}
public static IStorageBuilder UseDatabase <TDatabase>(this IStorageBuilder builder)
where TDatabase : class, IDatabase
{
if (builder == null)
{
throw new ArgumentNullException(nameof(builder));
}
var services = builder.Services;
services.AddSingleton <IDatabase, TDatabase>();
services.AddSingleton(p => p.GetRequiredService <IDatabase>() as IFilterableDatabase);
services.AddSingleton(p => p.GetRequiredService <IDatabase>() as IQueryableDatabase);
services.UseTransactionSubsystem();
return(builder);
}
public static IStorageBuilder UseMongoDB(this IStorageBuilder builder, string database, bool useNativeTransactions = false)
{
if (builder == null)
{
throw new ArgumentNullException(nameof(builder));
}
if (database == null)
{
throw new ArgumentNullException(nameof(database));
}
builder.UseMongoDB(useNativeTransactions);
builder.Services.Configure <MongoOptions>(options =>
{
options.Database = database;
});
return(builder);
}
/// <summary>
/// Create default session channels and return IEnumerable list of them.
/// In the case when checkPendingAsimovEvents == true call method on Vortex channel
/// to check whether pending telemetry is exists and in case existing Start this channel
/// immediately.
/// </summary>
/// <param name="telemetrySession"></param>
/// <param name="checkPendingAsimovEvents"></param>
/// <returns></returns>
public IEnumerable <ISessionChannel> CreateSessionChannels(TelemetrySession telemetrySession, bool checkPendingAsimovEvents)
{
IStorageBuilder storageBuilder = GetStorageBuilder();
IProcessLockFactory processLockFactory = GetProcessLock();
if (AppInsightsInstrumentationKey != null)
{
yield return(new DefaultAppInsightsSessionChannel(AppInsightsInstrumentationKey, telemetrySession.UserId.ToString(), storageBuilder, processLockFactory));
}
if (AsimovInstrumentationKey != null)
{
AsimovAppInsightsSessionChannel asimovAppInsightsSessionChannel = new AsimovAppInsightsSessionChannel("aivortex", false, AsimovInstrumentationKey, telemetrySession.UserId.ToString(), ChannelProperties.Default | ChannelProperties.NotForUnitTest, telemetrySession, storageBuilder, processLockFactory);
if (checkPendingAsimovEvents)
{
asimovAppInsightsSessionChannel.CheckPendingEventsAndStartChannel(telemetrySession.SessionId);
}
yield return(asimovAppInsightsSessionChannel);
yield return(new AsimovAppInsightsSessionChannel("aiasimov", Platform.IsWindows, AsimovInstrumentationKey, telemetrySession.UserId.ToString(), ChannelProperties.NotForUnitTest, telemetrySession, storageBuilder, processLockFactory));
}
yield return(new TelemetryLogToFileChannel());
}
public static IStorageBuilder UseMongoDB(this IStorageBuilder builder, bool useNativeTransactions = false)
{
if (builder == null)
{
throw new ArgumentNullException(nameof(builder));
}
builder.Services.AddOptions();
builder.Services.AddSingleton(BuildMongoClient);
builder.Services.AddSingleton(BuildMongoDatabase);
if (useNativeTransactions)
{
builder.UseTransactionalDatabase <MongoDatabase>();
}
else
{
builder.UseDatabase <MongoDatabase>();
}
return(builder);
}
public static IStorageBuilder UseTransactionalDatabase <TDatabase>(this IStorageBuilder builder, Func <IServiceProvider, TDatabase> factory)
where TDatabase : class, IDatabase, ITransactionalDatabase
{
if (builder == null)
{
throw new ArgumentNullException(nameof(builder));
}
if (factory == null)
{
throw new ArgumentNullException(nameof(factory));
}
var services = builder.Services;
services.AddSingleton <IDatabase, TDatabase>(factory);
services.AddSingleton(p => p.GetRequiredService <IDatabase>() as IFilterableDatabase);
services.AddSingleton(p => p.GetRequiredService <IDatabase>() as IQueryableDatabase);
services.AddSingleton <ITransactionalDatabase, TDatabase>(p => p.GetRequiredService <IDatabase>() as TDatabase);
services.AddSingleton(p => p.GetRequiredService <ITransactionalDatabase>() as IQueryableTransactionalDatabase);
return(builder);
}
public static IStorageBuilder AddAzureBlob(this IStorageBuilder storageBuilder, ServiceLifetime serviceLifetime, Action <AzureBlobConfiguration> configure)
{
return(storageBuilder.AddAzureBlob(Options.Options.DefaultName, serviceLifetime, configure));
}
/// <summary>
/// Adds an implementation of <see cref="IStorageManager"/> which required by Parbad for managing the storage operations.
/// </summary>
/// <typeparam name="TManager"></typeparam>
/// <param name="builder"></param>
/// <param name="lifetime">The lifetime of given StorageManager.</param>
public static IStorageBuilder AddStorageManager <TManager>(this IStorageBuilder builder, ServiceLifetime lifetime) where TManager : class, IStorageManager
{
builder.Services.AddOrUpdate <IStorageManager, TManager>(lifetime);
return(builder);
}
/// <summary>
/// Uses the default implementation of <see cref="IStorageManager"/>.
/// </summary>
/// <param name="builder"></param>
public static IStorageBuilder UseDefaultStorageManager(this IStorageBuilder builder)
{
return(AddStorageManager <StorageManager>(builder, ServiceLifetime.Transient));
}
public DomainStorageBuilder(IStorageBuilder storageBuilder)
{
Assert(storageBuilder != null);
_storageBuilder = storageBuilder;
}
public static IStorageBuilder AddAzureTable(this IStorageBuilder storageBuilder, string name, ServiceLifetime serviceLifetime, Action <AzureTableConfiguration> configure)
{
return(storageBuilder.AddAzureTable <TableItemAssembler>(name, serviceLifetime, configure));
}
public static IStorageBuilder AddAzureTable <TTableItemAssembler>(this IStorageBuilder storageBuilder, string name, ServiceLifetime serviceLifetime, Action <AzureTableConfiguration> configure) where TTableItemAssembler : class, ITableItemAssembler
{
storageBuilder.AddTableClient <AzureTableClient>(name, serviceLifetime).Configure(configure);
storageBuilder.Services.AddSingleton <ITableItemAssembler, TTableItemAssembler>();
return(storageBuilder);
}
public static IStorageBuilder AddAzureQueue(this IStorageBuilder storageBuilder, string name, ServiceLifetime serviceLifetime, Action <AzureQueueConfiguration> configure)
{
storageBuilder.AddQueueClient <AzureQueueClient>(name, serviceLifetime).Configure(configure);
return(storageBuilder);
}
/// <summary>
/// Uses <see cref="IDistributedCache"/> for saving and loading data.
/// </summary>
/// <param name="builder"></param>
public static IStorageBuilder UseDistributedCache(this IStorageBuilder builder)
=> UseDistributedCache(builder, options => { });
