public ApplicationDbContext(
DbContextOptions <ApplicationDbContext> options,
ITenantProvider tenantProvider,
IEntityTypeProvider entityTypeProvider)
: base(options)
{
_teanantId = tenantProvider.GetTenantId();
_entityTypeProvider = entityTypeProvider;
}
/// <summary>
/// Initializes a new instance of the <see cref="CreateNotificationActivity"/> class.
/// </summary>
/// <param name="tenantProvider">The tenant provider.</param>
/// <param name="notificationStoreFactory">The factory for the notification store.</param>
public CreateNotificationActivity(
ITenantProvider tenantProvider,
ITenantedUserNotificationStoreFactory notificationStoreFactory)
{
this.tenantProvider = tenantProvider
?? throw new ArgumentNullException(nameof(tenantProvider));
this.notificationStoreFactory = notificationStoreFactory
?? throw new ArgumentNullException(nameof(notificationStoreFactory));
}
/// <summary>
/// Creates new instance of <see cref="TenantDbContextFactory{TContext,TTenant,TTenancy,TKey}"/>
/// </summary>
/// <param name="tenantProvider"><see cref="ITenantProvider{TTenant,TKey}"/></param>
/// <param name="tenantManager"><see cref="TenantManager{TTenant}"/></param>
/// <param name="onConfiguringDbContextOptionsBuilderProvider"><see cref="IOnConfiguringDbContextOptionsBuilderProvider"/></param>
public TenantDbContextFactory(
ITenantProvider <TTenant, TKey> tenantProvider,
TenantManager <TTenant, TKey> tenantManager,
IOnConfiguringDbContextOptionsBuilderProvider onConfiguringDbContextOptionsBuilderProvider)
{
_tenantProvider = tenantProvider;
_tenantManager = tenantManager;
_onConfiguringDbContextOptionsBuilderProvider = onConfiguringDbContextOptionsBuilderProvider;
}
public async Task ThenThereIsATenantWithIdAsAChildOfTheRootTenant(string tenantId)
{
ITenantProvider tenantProvider = ContainerBindings.GetServiceProvider(this.scenarioContext).GetRequiredService <ITenantProvider>();
// A TenantNotFound exception will be thrown if the tenant doesn't exist
ITenant tenant = await tenantProvider.GetTenantAsync(tenantId).ConfigureAwait(false);
Assert.AreEqual(tenantProvider.Root.Id, tenant.GetRequiredParentId());
}
public CreateTenantProviderSettingsCommandHandler(
ITenantProviderSettingsRepository providerSettingsRepository,
ITenantProvider tenantProvider,
IMapper mapper)
{
_providerSettingsRepository = providerSettingsRepository;
_tenantProvider = tenantProvider;
_mapper = mapper;
}
/// <summary>
/// Initializes a new instance of the <see cref="GetWorkflowInstanceCountActivity"/> class.
/// </summary>
/// <param name="workflowInstanceStoreFactory">The factory class for the workflow instance store.</param>
/// <param name="serializerSettingsProvider">The serialization settings provider.</param>
/// <param name="tenantProvider">The tenant provider.</param>
public GetWorkflowInstanceCountActivity(
ITenantedWorkflowInstanceStoreFactory workflowInstanceStoreFactory,
IJsonSerializerSettingsProvider serializerSettingsProvider,
ITenantProvider tenantProvider)
{
this.workflowInstanceStoreFactory = workflowInstanceStoreFactory;
this.tenantProvider = tenantProvider;
this.serializerSettingsProvider = serializerSettingsProvider;
}
public void WhenIRemoveTheCosmosConfigurationFromTheTenant()
{
IServiceProvider serviceProvider = ContainerBindings.GetServiceProvider(this.scenarioContext);
ITenantProvider tenantProvider = serviceProvider.GetRequiredService <ITenantProvider>();
CosmosContainerDefinition definition = this.containerDefinition;
tenantProvider.Root.UpdateProperties(
propertiesToRemove: definition.RemoveCosmosConfiguration());
}
/// <summary>
/// Initializes a new instance of the <see cref="TenantedCosmosContentStoreFactory"/> class.
/// </summary>
/// <param name="tenantProvider">The <see cref="ITenantProvider"/> that will be used to retrieve Tenant info.</param>
/// <param name="containerFactory">The <see cref="ITenantCosmosContainerFactory"/> that will be used to create
/// underlying <see cref="Container"/> instances for the content stores.</param>
/// <param name="containerDefinition">The <see cref="CosmosContainerDefinition"/> to use when creating tenanted
/// <see cref="Container"/> instances.</param>
public TenantedCosmosContentStoreFactory(
ITenantProvider tenantProvider,
ITenantCosmosContainerFactory containerFactory,
CosmosContainerDefinition containerDefinition)
{
this.tenantProvider = tenantProvider;
this.containerFactory = containerFactory;
this.containerDefinition = containerDefinition;
}
/// <inheritdoc />
public ApiSettingController(ISettingService settingService, ITenantProvider tenantProvider, IMapper mapper,
IUserService userService, IStringLocalizer <ApiSettingController> localizer)
{
_settingService = settingService;
_mapper = mapper;
_userService = userService;
_localizer = localizer;
_tenantProvider = tenantProvider;
}
public DatabaseBasedConnectionStringProvider(
ITenantProvider tenantProvider,
IDataBaseManager dataBaseManager,
IOptions <DatabaseOptions> options)
{
this.tenantProvider = tenantProvider;
this.dataBaseManager = dataBaseManager;
this.options = options.Value;
}
public async Task Invoke(HttpContext httpContext, ITenantProvider tenantProvider)
{
if (tenantProvider.GetTenant() == null)
{
httpContext.Response.Redirect(missingTenantUrl);
return;
}
await next.Invoke(httpContext);
}
public PollApiViewModelService(ITenantProvider tenantProvider, IPollService pollService, IMapper mapper,
IVoteService voteService, IUserService userService, ISettingService settingService)
{
_tenantProvider = tenantProvider;
_pollService = pollService;
_mapper = mapper;
_voteService = voteService;
_userService = userService;
_settingService = settingService;
}
public static async Task CleanUpTenantStore(FeatureContext featureContext)
{
if (featureContext.FeatureInfo.Tags.Any(t => t == "perFeatureContainer"))
{
IServiceProvider sp = ContainerBindings.GetServiceProvider(featureContext);
ITenantProvider p = sp.GetRequiredService <ITenantProvider>();
await featureContext.RunAndStoreExceptionsAsync(() => CoreCleanupAsync(sp, p.Root))
.ConfigureAwait(false);
}
}
public UserController(SandBankDbContext db,
IJwtTokenService jwtTokenService,
ITenantProvider tenantProvider,
ILogger <UserController> logger)
{
_db = db;
_jwtTokenService = jwtTokenService;
_tenantProvider = tenantProvider;
_logger = logger;
}
public BloggingContext(DbContextOptions <BloggingContext> options,
ITenantProvider tenantProvider)
: base(options)
{
_tenant = tenantProvider.GetTenant();
if (Database.EnsureCreated())
{
// seed data base
}
}
public SyncEntityNameActor(IQuery query,
ITenantProvider tenantProvider,
IBulkRepository <EntityName> bulkRepository,
IEqualityComparerFactory equalityComparerFactory)
{
_query = query;
_tenantProvider = tenantProvider;
_bulkRepository = bulkRepository;
_dataChangesDetector = new TwoPhaseDataChangesDetector <EntityName>(equalityComparerFactory);
}
public AddonAuthenticationHandler(
IOptionsMonitor <AuthenticationSchemeOptions> options,
ILoggerFactory logger,
UrlEncoder encoder,
ISystemClock clock,
ITenantProvider tenantProvider)
: base(options, logger, encoder, clock)
{
_tenantProvider = tenantProvider;
}
public void ThenTheTenantedCloudBlobContainerShouldBeNamedUsingAHashOfTheTenantIdAndTheNameSpecifiedInTheBlobConfiguration()
{
ITenantProvider tenantProvider = this.serviceProvider.GetRequiredService <ITenantProvider>();
BlobStorageConfiguration blobStorageConfiguration = tenantProvider.Root.GetBlobStorageConfiguration(this.blobStorageContainerDefinition);
string expectedNamePlain = string.Concat(RootTenant.RootTenantId, "-", blobStorageConfiguration.Container);
string expectedName = AzureStorageNameHelper.HashAndEncodeBlobContainerName(expectedNamePlain);
Assert.AreEqual(expectedName, this.Container.Name);
}
public async Task Invoke(HttpContext httpContext, ITenantProvider provider)
{
if (provider.GetTenant() == null)
{
httpContext.Response.Redirect(_defaultTenantUrl);
return;
}
await _next.Invoke(httpContext);
}
public UserController(IUserService service,
ITenantProvider tenantProvider,
IFeatureProvider featureProvider,
ICompanyProvider companyProvider) : base(service)
{
_service = service;
_tenantProvider = tenantProvider;
_featureProvider = featureProvider;
_companyProvider = companyProvider;
}
public async Task Invoke(
HttpContext httpContext,
ITenantProvider tenantProvider,
ITenantManager tenantManager,
IOptions <MultiTenantOptions> multiTenantOptionsWrapper,
ILogger <MultiTenantCurrentTenantMiddleware> logger = null)
{
var multiTenantOptionsOptions = multiTenantOptionsWrapper.Value;
if (multiTenantOptionsOptions.TenantIdentificationSource != TenantIdentificationSource.None)
{
Guid tenantId;
var tenantIdentificationSourceName = multiTenantOptionsOptions.TenantIdentificationSourceName;
if (multiTenantOptionsOptions.TenantIdentificationSource == TenantIdentificationSource.Headers)
{
if (httpContext.Request.Headers.ContainsKey(tenantIdentificationSourceName))
{
var tenantIdAsString = httpContext.Request.Headers[tenantIdentificationSourceName];
if (!Guid.TryParse(tenantIdAsString, out tenantId))
{
logger?.LogWarning(
$"Cannot set TenantId. Check header {tenantIdentificationSourceName} has valid value");
}
}
}
else if (multiTenantOptionsOptions.TenantIdentificationSource == TenantIdentificationSource.Claims)
{
var claim = httpContext.User.Claims.SingleOrDefault(c => c.Type == tenantIdentificationSourceName);
var tenantIdAsString = string.Empty;
if (claim != null)
{
tenantIdAsString = claim.Value;
}
if (!Guid.TryParse(tenantIdAsString, out tenantId))
{
logger?.LogWarning(
$"Cannot set TenantId. Check header {tenantIdentificationSourceName} has valid value");
}
}
else if (multiTenantOptionsOptions.TenantIdentificationSource == TenantIdentificationSource.Custom)
{
tenantId = multiTenantOptionsOptions.TenantIdentificationCustomProvider(httpContext);
}
var tenant = tenantManager.GetById(tenantId);
tenantProvider.SetCurrentTenant(tenant);
}
await _next(httpContext);
}
public DocumentProfile(ITenantProvider tenantProvider)
{
this.tenantProvider = tenantProvider;
CreateMap <WorkflowDefinitionVersion, WorkflowDefinitionVersionDocument>()
.ForMember(d => d.TenantId, opt => opt.MapFrom(s => this.tenantProvider.GetTenantId <WorkflowDefinitionVersionDocument>()))
.ReverseMap();
CreateMap <WorkflowInstance, WorkflowInstanceDocument>()
.ForMember(d => d.TenantId, opt => opt.MapFrom(s => this.tenantProvider.GetTenantId <WorkflowInstanceDocument>()))
.ReverseMap();
}
public ApplicationOAuthProvider(string publicClientId)
{
if (publicClientId == null)
{
throw new ArgumentNullException(nameof(publicClientId));
}
_publicClientId = publicClientId;
_tenantProvider = new TenantProvider();
_sessionProvider = new SessionProvider();
}
public static Task TearDownTransientTenant(FeatureContext context)
{
return(context.RunAndStoreExceptionsAsync(() =>
{
IServiceProvider provider = ContainerBindings.GetServiceProvider(context);
ITenantProvider tenantProvider = provider.GetRequiredService <ITenantProvider>();
ITenant tenant = context.Get <ITenant>();
return tenantProvider.DeleteTenantAsync(tenant.Id);
}));
}
public ReactAdvantageContext(
DbContextOptions <ReactAdvantageContext> options,
ILogger <ReactAdvantageContext> logger,
ITenantProvider tenantProvider
)
: base(options)
{
Logger = logger;
TenantFilterValue = tenantProvider.GetTenantId();
IsTenantFilterEnabled = true;
}
public Repository(CoreContext context, ILoggerFactory logger, ITenantProvider <TKey> tenantProvider = null)
{
_logger = logger.CreateLogger(nameof(Repository <TEntity, TKey>));
_logger?.LogInformation($"Inicializando Repository<{ typeof(TEntity).Name }, { typeof(TKey).Name }>");
Context = context ?? throw new DbContextNullException();
this.Set = context.Set <TEntity>();
_tenantProvider = tenantProvider;
ValidateTentatProvider();
}
public ApiPolicyController(IPolicyService policyService, IPollService pollService,
IStringLocalizer <ApiPolicyController> localizer, IPollApiViewModelService pollViewModelService,
ITenantProvider tenantProvider, IMapper mapper)
{
_policyService = policyService;
_pollService = pollService;
_localizer = localizer;
_pollViewModelService = pollViewModelService;
_tenantProvider = tenantProvider;
_mapper = mapper;
}
public ApiAccountController(ITenantService tenantService, IUserService userService,
UserManager <ApplicationUser> userManager, IEmailSender emailSender,
IConfiguration config, IStringLocalizer <ApiAccountController> localizer, ITenantProvider tenantProvider)
{
_tenantService = tenantService;
_userService = userService;
_userManager = userManager;
_emailSender = emailSender;
_config = config;
_localizer = localizer;
_tenantProvider = tenantProvider;
}
public static async Task TeardownBlobStorage(FeatureContext featureContext)
{
// Pretty nasty hack to get rid of the underlying containers for the stores.
IServiceProvider serviceProvider = ContainerBindings.GetServiceProvider(featureContext);
ITenantProvider tenantProvider = serviceProvider.GetRequiredService <ITenantProvider>();
ITenantedWorkflowStoreFactory workflowStoreFactory = serviceProvider.GetRequiredService <ITenantedWorkflowStoreFactory>();
var workflowStore = (BlobStorageWorkflowStore)await workflowStoreFactory.GetWorkflowStoreForTenantAsync(tenantProvider.Root).ConfigureAwait(false);
await featureContext.RunAndStoreExceptionsAsync(
() => workflowStore.Container.DeleteAsync()).ConfigureAwait(false);
}
public UserService(ISecurityRepository <User, string> userRepository,
IEmailSender emailSender,
ITenantProvider tenantProvider,
IAppSession appSession,
RoleManager roleManager) : base(userRepository)
{
_userRepository = userRepository;
_emailSender = emailSender;
_tenantProvider = tenantProvider;
_appSession = appSession;
_roleManager = roleManager;
}
public SuperAdminController(ITenantProvider tenants)
{
_tenants = tenants;
}
