public void Setup() { Effort.Provider.EffortProviderConfiguration.RegisterProvider(); var connection = DbConnectionFactory.CreateTransient(); _context = new ApplicationDbContext(connection); _context.GenerateRandomData(); _resolver = new HostNameTenantResolver(new List<ITenant> { new Tenant(1, "local", "localhost"), new Tenant(2, "sample", "sample.local") }, "TenantId"); _server = TestServer.Create(app => { app.UseTenantCore(_resolver); app.Run(context => { var tenant = context.GetCurrentTenant(); return context.Response.WriteAsync(tenant.Name); }); }); }
public RequestTimeZoneIdResolver( IHttpContextAccessor contextAccessor, ITenantResolver<SiteContext> siteResolver, SiteUserManager<SiteUser> userManager ) { this.contextAccessor = contextAccessor; this.siteResolver = siteResolver; this.userManager = userManager; }
public MultiTenantOAuthOptionsResolver( //ISiteResolver siteResolver, IHttpContextAccessor contextAccessor, ITenantResolver<SiteSettings> siteResolver, MultiTenantOptions multiTenantOptions) { this.siteResolver = siteResolver; this.contextAccessor = contextAccessor; //site = currentSite; this.multiTenantOptions = multiTenantOptions; }
public MultiTenantAuthCookieValidator( IHttpContextAccessor contextAccessor, ITenantResolver<SiteSettings> siteResolver, ISecurityStampValidator securityStampValidator, ILogger<MultiTenantAuthCookieValidator> logger ) { this.contextAccessor = contextAccessor; this.securityStampValidator = securityStampValidator; this.siteResolver = siteResolver; log = logger; }
public UserController(IUserRepository users, IRoleRepository roles, IUserRoleRepository userRoles, UserManager <IdentityUser> identityUserManager, SignInManager <IdentityUser> identitySignInManager, ITenantResolver tenants, INotificationRepository notifications, IFolderRepository folders, ISyncManager syncManager, ISiteRepository sites, ILogManager logger) { _users = users; _roles = roles; _userRoles = userRoles; _identityUserManager = identityUserManager; _identitySignInManager = identitySignInManager; _tenants = tenants; _folders = folders; _notifications = notifications; _syncManager = syncManager; _sites = sites; _logger = logger; }
/// <summary> /// /// </summary> /// <param name="environment"></param> /// <returns></returns> public async Task Invoke(IDictionary <string, object> environment) { Ensure.Argument.NotNull(environment, nameof(environment)); ITenantResolver <TTenant> tenantResolver = _tenantResolverFactory(); TenantContext <TTenant> tenantContext = await tenantResolver.ResolveAsync(environment); if (tenantContext != null) { environment.SetTenantContext(tenantContext); } await _next(environment); }
//private string requiredSiteFolder; //public SiteFolderRouteConstraint(string folderParam) //{ // requiredSiteFolder = folderParam; //} //TODO: is this getting called on requests for static resources? // want to make sure it is not, we don't want to hit the db on requests for static files public bool Match( HttpContext httpContext, IRouter route, string parameterName, IDictionary <string, object> values, RouteDirection routeDirection) { // TODO: problem here is we want to make this method be async //https://github.com/aspnet/Mvc/issues/1094 // but may have to jump through some hoops // for now we are calling an async method synchronously while blocking the thread string requestFolder = httpContext.Request.Path.StartingSegment(); //return string.Equals(requiredSiteFolder, requestFolder, StringComparison.CurrentCultureIgnoreCase); ITenantResolver <SiteSettings> siteResolver = httpContext.ApplicationServices.GetService <ITenantResolver <SiteSettings> >(); if (siteResolver != null) { try { // exceptions expected here until db install scripts have run or if db connection error //ISiteSettings site = siteResolver.Resolve(); //var siteContext = Task.Run<TenantContext<SiteSettings>>(fun => siteResolver.ResolveAsync(httpContext)); // Func <Task <TenantContext <SiteSettings> > > f = delegate() { return(siteResolver.ResolveAsync(httpContext)); }; //http://stackoverflow.com/questions/22628087/calling-async-method-synchronously var siteContext = Task.Run <TenantContext <SiteSettings> >(f).Result; if ((siteContext != null) && (siteContext.Tenant != null) && (siteContext.Tenant.SiteFolderName == requestFolder)) { return(true); } } catch { // do we need to log this? } } return(false); }
/// <summary> /// Add TenantCore to an AppBuilder /// </summary> /// <param name="app">The AppBuilder instance</param> /// <param name="resolver">The Tenant Resolver instance</param> /// <param name="callback">The callback method</param> /// <returns>AppBuilder with TenantCore</returns> /// <exception cref="ArgumentNullException"></exception> public static IAppBuilder UseTenantCore(this IAppBuilder app, ITenantResolver resolver, Func <ITenant, bool> callback = null) { if (app == null) { throw new ArgumentNullException(nameof(app)); } if (resolver == null) { throw new ArgumentNullException(nameof(resolver)); } return(app.Use(typeof(TenantCoreMiddleware), resolver, callback)); }
public async Task Invoke(HttpContext ctx, ITenantResolver tenantResolver, DatabaseContext db) { var host = ctx.Request.GetTypedHeaders().Host.Value; var tenant = await tenantResolver.Resolve(host); if (tenant == null) { throw new Exception("Tenant not found"); } else { db.SetActiveTenant(tenant); await Next(ctx); } }
/// <summary> /// Initializes a new instance of <see cref="CommandCoordinator"/> /// </summary> /// <param name="commandCoordinator">The underlying <see cref="ICommandCoordinator"/> </param> /// <param name="executionContextConfigurator"><see cref="IExecutionContextConfigurator"/> for configuring the <see cref="Dolittle.Execution.ExecutionContext"/></param> /// <param name="tenantResolver"></param> /// <param name="serializer"><see cref="ISerializer"/> for serialization purposes</param> /// <param name="commands">Instances of <see cref="ICommand"/></param> /// <param name="logger"></param> public CommandCoordinator( ICommandCoordinator commandCoordinator, IExecutionContextConfigurator executionContextConfigurator, ITenantResolver tenantResolver, ISerializer serializer, IInstancesOf <ICommand> commands, ILogger logger ) { _commandCoordinator = commandCoordinator; _commands = commands; _serializer = serializer; _executionContextConfigurator = executionContextConfigurator; _tenantResolver = tenantResolver; _logger = logger; }
public ContactFormProcessor( ViewRenderer viewRenderer, ITenantResolver tenantResolver, IEmailSenderResolver emailSenderResolver, IContactFormResolver contactFormResolver, IOptions <ContactFormMessageOptions> messageProcessorOptionsAccessor, ILogger <ContactFormProcessor> logger ) { _viewRenderer = viewRenderer; _tenantResolver = tenantResolver; _emailSenderResolver = emailSenderResolver; _contactFormResolver = contactFormResolver; _messageProcessorOptions = messageProcessorOptionsAccessor.Value; _log = logger; }
public MultiTenantTwitterHandler( HttpClient httpClient, //ISiteResolver siteResolver, IHttpContextAccessor contextAccessor, ITenantResolver <SiteSettings> siteResolver, ISiteRepository siteRepository, MultiTenantOptions multiTenantOptions, ILoggerFactory loggerFactory) { _httpClient = httpClient; log = loggerFactory.CreateLogger <MultiTenantTwitterHandler>(); this.contextAccessor = contextAccessor; this.siteResolver = siteResolver; this.multiTenantOptions = multiTenantOptions; siteRepo = siteRepository; }
#pragma warning disable UseAsyncSuffix // Use Async suffix public async Task Invoke(HttpContext httpContext, ITenantResolver tenantResolver, ITenantProvider tenantProvider) #pragma warning restore UseAsyncSuffix // Use Async suffix { var tenant = tenantResolver.ResolveTenant(httpContext); if (string.IsNullOrEmpty(tenant)) { // Call the next middleware delegate in the pipeline await _next.Invoke(httpContext); } else { using (tenantProvider.BeginScope(tenant)) { await _next.Invoke(httpContext); } } }
public async Task Invoke(HttpContext context, ITenantResolver tenantResolver) { if (context.Request.RouteValues.ContainsKey(RouteValueKey)) { var tenant = tenantResolver.Resolve(); var user = context.User; if (!UserHasPermissionForTenant(tenant, user)) { context.Response.StatusCode = 401; await context.Response.WriteAsync($"You do not have permission to access '{tenant}'."); return; } } await _next.Invoke(context); }
public async Task Invoke(HttpContext context, ITenantResolver <TTenant> tenantResolver) { log.LogDebug("Resolving TenantContext using {loggerType}.", tenantResolver.GetType().Name); var tenantContext = await tenantResolver.Resolve(context); if (tenantContext != null) { log.LogDebug("TenantContext Resolved. Adding to HttpContext."); context.SetTenantContext(tenantContext); } else { log.LogDebug("TenantContext Not Resolved."); } await next.Invoke(context); }
/// <summary> /// Initializes a new instance of <see cref="QueryCoordinator"/> /// </summary> /// <param name="typeFinder"></param> /// <param name="container"></param> /// <param name="queryCoordinator">The underlying <see cref="IQueryCoordinator"/> </param> /// <param name="executionContextConfigurator"></param> /// <param name="tenantResolver"></param> /// <param name="queries"></param> /// <param name="serializer"></param> /// <param name="logger"></param> public QueryCoordinator( ITypeFinder typeFinder, IContainer container, IQueryCoordinator queryCoordinator, IExecutionContextConfigurator executionContextConfigurator, ITenantResolver tenantResolver, IInstancesOf <IQuery> queries, ISerializer serializer, ILogger logger) { _typeFinder = typeFinder; _container = container; _queryCoordinator = queryCoordinator; _executionContextConfigurator = executionContextConfigurator; _tenantResolver = tenantResolver; _queries = queries; _serializer = serializer; _logger = logger; }
public MultiTenantMicrosoftAccountHandler( HttpClient httpClient, //ISiteResolver siteResolver, IHttpContextAccessor contextAccessor, ITenantResolver <SiteSettings> siteResolver, ISiteRepository siteRepository, MultiTenantOptions multiTenantOptions, ILoggerFactory loggerFactory) : base( httpClient, loggerFactory, new MultiTenantOAuthOptionsResolver(contextAccessor, siteResolver, multiTenantOptions) ) { log = loggerFactory.CreateLogger <MultiTenantMicrosoftAccountHandler>(); this.contextAccessor = contextAccessor; this.siteResolver = siteResolver; this.multiTenantOptions = multiTenantOptions; siteRepo = siteRepository; }
public async Task Invoke(HttpContext context, ITenantResolver tenantResolver) { logger.LogDebug("Resolving TenantContext using {loggerType}.", tenantResolver.GetType().Name); var tenantContext = await tenantResolver.ResolveAsync(context); if (tenantContext != null) { logger.LogDebug("TenantContext resolved successful. Adding to HttpContext."); context.SetTenantContext(tenantContext); } else if (tenantsConfig.UnresolvedRedirect.HasValue()) { logger.LogDebug("TenantContext resolved failure. Now redreact to unresolved url."); Redirect(context, tenantsConfig.UnresolvedRedirect, tenantsConfig.RedirectPermanent); return; } await next.Invoke(context); }
public async Task Invoke(HttpContext context, ITenantResolver <TTenant> tenantResolver) { Ensure.Argument.NotNull(context, nameof(context)); Ensure.Argument.NotNull(tenantResolver, nameof(tenantResolver)); log.LogDebug("Resolving TenantContext using {loggerType}.", tenantResolver.GetType().Name); var tenantContext = await tenantResolver.ResolveAsync(context); if (tenantContext != null) { log.LogVerbose("TenantContext Resolved. Adding to HttpContext."); context.SetTenantContext(tenantContext); } else { log.LogDebug("TenantContext Not Resolved."); } await next.Invoke(context); }
/// <summary> /// creates a httpcontxt with an authenticated user /// </summary> /// <param name="userName"></param> /// <returns></returns> public ControllerContext BuildHttpContext(string userName) { if (!app.Started) { throw new System.InvalidOperationException("The test environmnet has not been started yet. call app.Start(...) before calling this method."); } var httpCtxMock = new Mock <HttpContextBase>(); ITenantResolver tenantResolver = IoCFactory.Container.Resolve <ITenantResolver>(); var tenant = tenantResolver.DefaultTenant; // setting the landing page for the current session GeneralSettings generalSettings = IoCFactory.Container.Resolve <GeneralSettings>(); var landingPage = generalSettings.GetEntryValue("landingPage").ToString(); tenant.LandingPage = landingPage; // checks and sets var httpSessionMock = new Mock <HttpSessionStateBase>(); httpSessionMock.Setup(x => x["CurrentTenant"]).Returns(tenant); httpCtxMock.Setup(ctx => ctx.Session).Returns(httpSessionMock.Object); if (!string.IsNullOrWhiteSpace(userName)) { var validPrincipal = new ClaimsPrincipal( new[] { new ClaimsIdentity( new[] { new Claim(ClaimTypes.NameIdentifier, userName) }) }); httpCtxMock.Setup(ctx => ctx.User).Returns(validPrincipal); } ControllerContext controllerCtx = new ControllerContext(); controllerCtx.HttpContext = httpCtxMock.Object; return(controllerCtx); }
/// <summary> /// Initializes a new <see cref="GoogleAuthenticationMiddleware"/>. /// </summary> /// <param name="next">The next middleware in the HTTP pipeline to invoke.</param> /// <param name="dataProtectionProvider"></param> /// <param name="loggerFactory"></param> /// <param name="encoder"></param> /// <param name="sharedOptions"></param> /// <param name="options">Configuration options for the middleware.</param> /// <param name="configureOptions"></param> public MultiTenantGoogleMiddleware( RequestDelegate next, IDataProtectionProvider dataProtectionProvider, ILoggerFactory loggerFactory, IHttpContextAccessor contextAccessor, ITenantResolver <SiteSettings> siteResolver, ISiteRepository siteRepository, IOptions <MultiTenantOptions> multiTenantOptionsAccesor, IUrlEncoder encoder, IOptions <SharedAuthenticationOptions> sharedOptions, GoogleOptions options) : base( next, dataProtectionProvider, contextAccessor, loggerFactory, encoder, siteResolver, multiTenantOptionsAccesor, sharedOptions, options) { if (Options.Scope.Count == 0) { // Google OAuth 2.0 asks for non-empty scope. If user didn't set it, set default scope to // "openid profile email" to get basic user information. // TODO: Should we just add these by default when we create the Options? Options.Scope.Add("openid"); Options.Scope.Add("profile"); Options.Scope.Add("email"); } this.loggerFactory = loggerFactory; this.contextAccessor = contextAccessor; this.siteResolver = siteResolver; multiTenantOptions = multiTenantOptionsAccesor.Value; siteRepo = siteRepository; }
public StatefulControllerDependencies(IZoneMapper zoneMapper, ITenantResolver tenantResolver, IUserResolver userResolver, //IModuleDefinitionRepository moduleDefinitionRepository, IModuleRepository moduleRepository, //ISettingRepository settingRepository, //OqtaneContainer oqtaneContainer, OqtTempInstanceContext oqtTempInstanceContext, IServiceProvider serviceProvider, IContextResolver ctxResolver ) { ServiceProvider = serviceProvider; CtxResolver = ctxResolver; ZoneMapper = zoneMapper; TenantResolver = tenantResolver; UserResolver = userResolver; //ModuleDefinitionRepository = moduleDefinitionRepository; ModuleRepository = moduleRepository; //SettingRepository = settingRepository; //_oqtaneContainer = oqtaneContainer; OqtTempInstanceContext = oqtTempInstanceContext; }
public async Task Invoke( HttpContext httpContext, ILog <TenantResolutionMiddleware <TTenant> > logger, ITenantResolver <TTenant> tenantResolver) { logger?.Debug($"Resolving TenantContext using {tenantResolver.GetType().Name}."); TenantContext <TTenant> tenantContext = await tenantResolver.ResolveAsync(httpContext).ConfigureAwait(false); if (tenantContext != null) { logger?.Debug("TenantContext Resolved. Adding to HttpContext."); httpContext?.SetTenantContext(tenantContext); } else { logger?.Warn("TenantContext Not Resolved."); } //using (logger.Info($"Tenant:{httpContext.GetTenant<TTenant>()}")) { await next.Invoke(httpContext).ConfigureAwait(false); } }
#pragma warning disable UseAsyncSuffix // Use Async suffix public async Task Invoke(HttpContext httpContext, ITenantResolver tenantResolver, ITenantProvider tenantProvider) #pragma warning restore UseAsyncSuffix // Use Async suffix { var tenant = tenantResolver.ResolveTenant(httpContext); if (string.IsNullOrEmpty(tenant)) { // Call the next middleware delegate in the pipeline await _next.Invoke(httpContext); } else { var tenantContainerProvider = (ITenantContainerProvider)httpContext.RequestServices.GetService(typeof(ITenantContainerProvider)); var tenantContainer = tenantContainerProvider.GetTenantContainer(tenant); using (var scopedConatiner = tenantContainer.OpenScope(Reuse.WebRequestScopeName)) { // replace the RequestScope container by the tenant request scope httpContext.RequestServices = scopedConatiner.Resolve <IServiceProvider>(); // Call the next middleware delegate in the pipeline await _next.Invoke(httpContext); } } }
public async Task Invoke(HttpContext context, ITenantResolver resolver, IConfiguration configuration, IServiceProvider provider) { Guard.ArgumentNotNull(context, nameof(context)); Guard.ArgumentNotNull(resolver, nameof(resolver)); Guard.ArgumentNotNull(configuration, nameof(configuration)); _logger.LogDebug("Resolving Tenant using {loggerType}.", resolver.GetType().Name); var tenant = await resolver.ResolveAsync(context); if (tenant != null) { _logger.LogDebug("Tenant Resolved. Adding to HttpContext."); context.SetTenantContext(new TenantContext(tenant)); } else { _logger.LogDebug("Tenant Not Resolved."); } await _next.Invoke(context); }
protected void Application_Start() { IoCFactory.StartContainer(Path.Combine(AppConfiguration.AppRoot, "IoC.config"), "DefaultContainer", HttpContext.Current); // use AppConfig to access the app root folder //loadModules(); IPersistenceManager pManager = PersistenceFactory.GetPersistenceManager(); // just to prepare data access environment pManager.Configure(AppConfiguration.DefaultApplicationConnection.ConnectionString, AppConfiguration.DatabaseDialect); //, AppConfiguration.DefaultApplicationConnection.ConnectionString); if (AppConfiguration.CreateDatabase) { pManager.ExportSchema(); } pManager.Start(); AreaRegistration.RegisterAllAreas(); RegisterGlobalFilters(GlobalFilters.Filters); RegisterRoutes(RouteTable.Routes); ITenantResolver tenantResolver = IoCFactory.Container.Resolve <ITenantResolver>(); ITenantPathProvider pathProvider = new DefaultTenantPathProvider(); // should be instantiated by the IoC. client app should provide the Path Ptovider based on its file and tenant structure tenantResolver.Load(pathProvider); var x = tenantResolver.Manifest; }
public MultiTenantFacebookMiddleware( RequestDelegate next, IDataProtectionProvider dataProtectionProvider, ILoggerFactory loggerFactory, //ISiteResolver siteResolver, IHttpContextAccessor contextAccessor, ITenantResolver <SiteSettings> siteResolver, ISiteRepository siteRepository, IOptions <MultiTenantOptions> multiTenantOptionsAccesor, IUrlEncoder encoder, IOptions <SharedAuthenticationOptions> sharedOptions, FacebookOptions options) : base(next, dataProtectionProvider, contextAccessor, loggerFactory, encoder, siteResolver, multiTenantOptionsAccesor, sharedOptions, options) { //if (string.IsNullOrEmpty(Options.AppId)) //{ // throw new ArgumentException(string.Format(CultureInfo.CurrentCulture, Resources.Exception_OptionMustBeProvided, nameof(Options.AppId))); //} //if (string.IsNullOrEmpty(Options.AppSecret)) //{ // throw new ArgumentException(string.Format(CultureInfo.CurrentCulture, Resources.Exception_OptionMustBeProvided, nameof(Options.AppSecret))); //} this.loggerFactory = loggerFactory; this.contextAccessor = contextAccessor; this.siteResolver = siteResolver; multiTenantOptions = multiTenantOptionsAccesor.Value; siteRepo = siteRepository; }
public ReportViewerContext(ITenantResolver tenantResolver, IHttpContextAccessor accessor) : base(tenantResolver, accessor) { // ContextBase handles multi-tenant database connections }
public HtmlTextContext(ITenantResolver TenantResolver, IHttpContextAccessor accessor) : base(TenantResolver, accessor) { // ContextBase handles multi-tenant database connections }
public CronusContextFactory(CronusContext context, IOptionsMonitor <TenantsOptions> tenantsOptions, ITenantResolver tenantResolver) { this.context = context; this.tenantResolver = tenantResolver; this.tenants = tenantsOptions.CurrentValue; }
public FileController(IWebHostEnvironment environment, IFileRepository files, IFolderRepository folders, IUserPermissions userPermissions, ITenantResolver tenants, ILogManager logger) { _environment = environment; _files = files; _folders = folders; _userPermissions = userPermissions; _tenants = tenants; _logger = logger; }
public PageModuleController(IPageModuleRepository pageModules, IUserPermissions userPermissions, ITenantResolver tenants, ISyncManager syncManager, ILogManager logger) { _pageModules = pageModules; _userPermissions = userPermissions; _tenants = tenants; _syncManager = syncManager; _logger = logger; }
public ModuleController(IModuleRepository modules, IPageModuleRepository pageModules, IPageRepository pages, IModuleDefinitionRepository moduleDefinitions, ISettingRepository settings, IUserPermissions userPermissions, ITenantResolver tenants, ISyncManager syncManager, ILogManager logger) { _modules = modules; _pageModules = pageModules; _pages = pages; _moduleDefinitions = moduleDefinitions; _settings = settings; _userPermissions = userPermissions; _tenants = tenants; _syncManager = syncManager; _logger = logger; }
public UsuarioController(UsuarioApp app, UserManager <ApplicationUser> userManager, ITenantResolver tenantResolver) { _app = app; _userManager = userManager; _tenantId = tenantResolver.GetTenantId(); }
/// <summary> /// Initialize the Middleware with a Tenant's resolver /// </summary> /// <param name="next">The next Middleware</param> /// <param name="resolver">The Tenant's resolver</param> /// <param name="callback">The Callback action</param> public TenantCoreMiddleware(OwinMiddleware next, ITenantResolver resolver, Func<ITenant, bool> callback = null) : base(next) { Resolver = resolver; Callback = callback; }