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; }