public AccountController(ModuleZeroSampleProjectUserManager userManager, IRepository <User, long> userRepository, IRepository <Tenant> tenantRepository, MultiTenancyConfig multiTenancy)
{
_userManager = userManager;
_userRepository = userRepository;
_tenantRepository = tenantRepository;
_multiTenancy = multiTenancy;
}
public static MultiTenancyConfig <TTenant> Use <TTenant, T>(this MultiTenancyConfig <TTenant> configuration, T entry, Action <T> entryAction)
{
if (configuration == null)
{
throw new ArgumentNullException(nameof(configuration));
}
entryAction?.Invoke(entry);
return(configuration);
}
/// <summary>
/// Add MultitenanCy Options.
/// </summary>
/// <param name="services">An IServiceCollection.</param>
/// <param name="multitenancyConfig">The object which containd multitenant config.</param>
/// <returns>IServiceCollection.</returns>
/// <typeparam name="TTenant">Tenant object.</typeparam>
internal static IServiceCollection AddMultitenancyOptions <TTenant>(this IServiceCollection services, MultiTenancyConfig <TTenant> multitenancyConfig)
{
if (services == null)
{
throw new ArgumentNullException($"Argument {nameof(services)} must not be null");
}
if (multitenancyConfig == null)
{
throw new ArgumentNullException($"Argument {nameof(multitenancyConfig)} must not be null");
}
services.Configure <MultitenancyOptions <TTenant> >(multitenancyConfig.Config.GetSection(nameof(MultitenancyConstants.MultitenancyOptions)));
services.AddSingleton <IPostConfigureOptions <MultitenancyOptions <TTenant> >, MultitenancyPostConfigureOptions <TTenant> >();
services.AddSingleton(sp => sp.GetService <IOptionsMonitor <MultitenancyOptions <TTenant> > >().CurrentValue);
services.AddSingleton <IMultitenancyOptionsProvider <TTenant> >(sp => new MultitenancyOptionsProvider <TTenant>(multitenancyConfig));
return(services);
}
private static ServiceDescriptor BuildConventionMultitenantBasedStartup <TTenant>(Type startupType, MultiTenancyConfig <TTenant> multitenancyConfig)
where TTenant : class => new ServiceDescriptor(
typeof(IStartup),
(IServiceProvider provider) =>
{
IHostingEnvironment hostingEnvironment = provider.GetRequiredService <IHostingEnvironment>();
StartupMethodsMultitenant <TTenant> methods = StartupLoaderMultitenant.LoadMethods <TTenant>(provider, startupType, hostingEnvironment.EnvironmentName);
return(new ConventionMultitenantBasedStartup <TTenant>(methods, multitenancyConfig.BuildTenantLogProvider()));
}, lifetime: ServiceLifetime.Singleton);
/// <summary>
/// Add multitenancy feature.
/// </summary>
/// <typeparam name="TStartup">The stratup class.</typeparam>
/// <typeparam name="TTenant">The tenant class.</typeparam>
/// <typeparam name="TResolver">The Resolver tenant.</typeparam>
/// <param name="hostBuilder">hostBuilder.</param>
/// <param name="startupType">The type of the startup class.</param>
/// <param name="multitenancyConfiguration">The configuration which contains MultitenancyOptions.</param>
/// <param name="throwErrorIfOptionsNotFound">Boolean to indicate if throws exception when MultitenancyOptions is not found.</param>
/// <param name="actionConfiguration">Additionnal config.</param>
/// <returns>IWebHostBuilder.</returns>
internal static IWebHostBuilder UseUnobtrusiveMulitenancyStartup <TStartup, TTenant, TResolver>(
this IWebHostBuilder hostBuilder,
Type startupType,
IConfigurationRoot multitenancyConfiguration,
bool throwErrorIfOptionsNotFound,
Action <MultiTenancyConfig <TTenant> > actionConfiguration)
where TStartup : class
where TTenant : class
where TResolver : class, ITenantResolver <TTenant>
{
if (hostBuilder == null)
{
throw new ArgumentNullException(nameof(hostBuilder));
}
string env = hostBuilder.GetSetting("environment");
IPostConfigureOptions <MultitenancyOptions <TTenant> >[] postConfigures = new[] {
new MultitenancyPostConfigureOptions <TTenant>()
};
MultiTenancyConfig <TTenant> multitenancyConfig = new MultiTenancyConfig <TTenant>(
env,
multitenancyConfiguration,
postConfigures: postConfigures);
MultitenancyOptions <TTenant> buildedOptions = multitenancyConfig.CurrentMultiTenacyOptionsValue;
if (throwErrorIfOptionsNotFound && (buildedOptions == null || !(buildedOptions?.Tenants?.Any() ?? false)))
{
throw new Exception("MultitenancyOptions not found in configuration.");
}
if (!(buildedOptions?.Tenants?.Any() ?? false))
{
return(hostBuilder.UseStartup <TStartup>());
}
else
{
string startupAssemblyName = startupType.GetTypeInfo().Assembly.GetName().Name;
return(hostBuilder
.UseDefaultServiceProvider(options => options.ValidateScopes = false)
.ConfigureAppConfiguration((hostingContext, config) =>
{
hostBuilder.UseSetting(WebHostDefaults.ApplicationKey, startupAssemblyName);
hostBuilder.UseSetting(MultitenancyConstants.UseUnobstrusiveMulitenancyStartupKey, startupAssemblyName);
hostBuilder.UseSetting(WebHostDefaults.StartupAssemblyKey, null);
})
.ConfigureServices((WebHostBuilderContext ctx, IServiceCollection services) =>
{
services.TryAddSingleton <IHttpContextAccessor, HttpContextAccessor>();
//services.TryAddSingleton<IActionContextAccessor, ActionContextAccessor>();
// Register multitenancy options.
services.AddMultitenancyOptions <TTenant>(multitenancyConfig);
services.AddMultitenancy <TTenant, TResolver>();
// manage IStartup
services.RemoveAll <IStartup>();
// Override config.
// Add logging
multitenancyConfig.UseColoredConsoleLogProvider();
actionConfiguration?.Invoke(multitenancyConfig);
services.TryAdd(ServiceDescriptor.Singleton <ILogProvider>(LogProvider.CurrentLogProvider));
services.TryAdd(ServiceDescriptor.Singleton(typeof(ILog <>), typeof(Log <>)));
services.AddSingleton <MultiTenancyConfig <TTenant> >(serviceProvider => multitenancyConfig);
ServiceDescriptor descriptor = BuildMultitenantRequestStartupFilter <TStartup, TTenant>();
services.Insert(0, descriptor);
ServiceDescriptor startuptDescriptor = BuildConventionMultitenantBasedStartup(startupType, multitenancyConfig);
services.Insert(1, startuptDescriptor);
})
);
}
}
public AbpSession(MultiTenancyConfig multiTenancy)
{
_multiTenancy = multiTenancy;
}
public void ConfigurePerTenantServices(IServiceCollection services, MultiTenancyConfig <TestTenant> config)
{
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="multiTenancy">Multi tenancy configuration</param>
public ZeroConfig(MultiTenancyConfig multiTenancy)
{
MultiTenancy = multiTenancy;
}
/// <summary>
/// Add additionnal ConfigureServices for specific tenant.
/// </summary>
/// <typeparam name="TTenant"></typeparam>
/// <param name="configuration">Object represents MultiTenancyConfig.</param>
/// <param name="action">Action to configure services.</param>
/// <returns></returns>
public static MultiTenancyConfig <TTenant> UseConfigureServicesTenant <TTenant>(
this MultiTenancyConfig <TTenant> configuration, Action <IServiceCollection, TTenant> action)
{
return(configuration.Use(action, x => configuration.SetConfigureServicesTenant(action)));
}
/// <summary>
///
/// </summary>
/// <typeparam name="TTenant"></typeparam>
/// <param name="configuration"></param>
/// <param name="func"></param>
/// <returns></returns>
public static MultiTenancyConfig <TTenant> UseCustomServicesTenant <TTenant>(
this MultiTenancyConfig <TTenant> configuration, Func <IServiceCollection, TTenant, IConfiguration, ILogProvider> func)
{
configuration.SetTenantLogProvider(func);
return(configuration);
}
/// <summary>
///
/// </summary>
/// <typeparam name="TTenant"></typeparam>
/// <typeparam name="TLogProvider"></typeparam>
/// <param name="configuration"></param>
/// <param name="tenant"></param>
/// <param name="tenantConfiguration"></param>
/// <param name="provider"></param>
/// <returns></returns>
public static MultiTenancyConfig <TTenant> UseLogCustomServicesTenant <TTenant, TLogProvider>(
this MultiTenancyConfig <TTenant> configuration, TTenant tenant, IConfiguration tenantConfiguration, TLogProvider provider)
where TLogProvider : ILogProvider
{
return(configuration.Use(provider, x => LogProvider.SetCurrentLogProvider(x)));
}
/// <summary>
/// Add serilo ProviderLog.
/// </summary>
/// <param name="configuration"></param>
/// <returns></returns>
internal static MultiTenancyConfig <TTenant> UseSerilogLogProvider <TTenant>(this MultiTenancyConfig <TTenant> configuration)
{
return(configuration.UseLogProvider(new SerilogLogProvider()));
}
/// <summary>
/// Activate ConsoleLog.
/// </summary>
/// <typeparam name="TTenant"></typeparam>
/// <param name="configuration"></param>
/// <returns></returns>
internal static MultiTenancyConfig <TTenant> UseColoredConsoleLogProvider <TTenant>(this MultiTenancyConfig <TTenant> configuration)
{
return(configuration.UseLogProvider(new ColoredConsoleLogProvider()));
}
