public static void ReplaceServiceTenanted <TDbContext>(this DbContextOptionsBuilder dbOptions,
TenantSettings <TDbContext> settings)
where TDbContext : DbContext, ITenantDbContext
{
if (Constants.specialConnectionTypes.Contains(settings.ConnectionType))
{
dbOptions.ReplaceService <IModelCacheKeyFactory, TenantModelCacheKeyFactory <TDbContext> >();
}
}
public static IServiceCollection AddDbPerSchema <TDbContext>(this IServiceCollection services)
where TDbContext : DbContext, ITenantDbContext
{
var settings = new TenantSettings <TDbContext>()
{
ConnectionType = ConnectionResolverType.BySchema
};
return(services.AddTenantedDatabase(settings));
}
/// <summary>
/// For the given URL all configured tenants are checked.
/// </summary>
/// <param name="url"></param>
/// <returns></returns>
public static TenantSettings GetTenant(string url)
{
TenantSettings tenant = _tenantList.FirstOrDefault(t => url.StartsWith(t.PrimaryUrl));
if (null == tenant)
{
tenant = new TenantSettings();
}
return(tenant);
}
public TenantSettings Get()
{
if (_cachedTenantSettings == null)
{
_cachedTenantSettings = _dbContext.Query <TenantSettingsEntity>()
.ProjectTo <TenantSettings>(_mapper.ConfigurationProvider)
.FirstOrDefault();
}
return(_cachedTenantSettings);
}
public static IServiceCollection AddDbPerTable <TDbContext>(this IServiceCollection services,
Action <TenantSettings <TDbContext> > setupAction = null)
where TDbContext : DbContext, ITenantDbContext
{
var settings = new TenantSettings <TDbContext>()
{
ConnectionType = ConnectionResolverType.ByTable
};
return(services.AddTenantedDatabase(settings, setupAction));
}
public TenantService(IOptions <TenantSettings> options, IHttpContextAccessor contextAccessor)
{
tenantSettings = options.Value;
httpContext = contextAccessor.HttpContext;
if (httpContext.Request.Cookies.TryGetValue("tenant-code", out string site) && tenantSettings.Sites.ContainsKey(site))
{
tenantCode = site;
tenant = tenantSettings.Sites[site];
}
}
internal static IServiceCollection InitSettings <TDbContext>(this IServiceCollection services,
TenantSettings <TDbContext> settings, Action <TenantSettings <TDbContext> > setupAction)
where TDbContext : DbContext, ITenantDbContext
{
services.AddSingleton((sp) =>
{
var rct = settings ?? new TenantSettings <TDbContext>();
setupAction?.Invoke(rct);
return(rct);
});
return(services);
}
void setupDb(TenantSettings <StoreDbContext> settings)
{
settings.ConnectionPrefix = "mysql_";
settings.DbContextSetup = (serviceProvider, connectionString, optionsBuilder) =>
{
var tenant = serviceProvider.GetService <TenantInfo>();
optionsBuilder.UseMySql(connectionString, builder =>
{
// not necessary, if you are not using the table or schema
builder.TenantBuilderSetup(serviceProvider, settings, tenant);
});
};
}
private static IClashExposureCountService CreateEffectiveClashExposureCountService(
IRepositoryScope scope)
{
TenantSettings tenantSettings = GetTenantSettings(scope);
if (String.IsNullOrWhiteSpace(tenantSettings.PeakStartTime))
{
return(ClashExposureCountService.Create());
}
return(ClashExposureCountService.Create(
(tenantSettings.PeakStartTime, tenantSettings.PeakEndTime)
));
}
public TenantService(IOptions <TenantSettings> tenantSettings, IHttpContextAccessor contextAccessor)
{
_tenantSettings = tenantSettings.Value;
_httpContext = contextAccessor.HttpContext;
if (_httpContext is not null)
{
if (!_httpContext.Request.Headers.TryGetValue("tenant", out var tenantId))
{
throw new Exception("Invalid Tenant!");
}
SetTenant(tenantId);
}
}
public static IServiceCollection AddTenantedDatabase <TDbContext>(this IServiceCollection services,
TenantSettings <TDbContext> settings)
where TDbContext : DbContext, ITenantDbContext
{
services.AddSingleton(settings);
services.AddScoped <TenantInfo>();
services.AddScoped <TenantOption>();
services.TryAddScoped <ITenantInfoGenerator, SimpleHeaderTenantInfoGenerator>();
services.TryAddScoped <ITenantConnectionResolver <TDbContext>, TenantConnectionResolver <TDbContext> >();
services.TryAddScoped <ITenantEntityBuilder <TDbContext>, TenantEntityBuilder <TDbContext> >();
services.TryAddScoped <IEntityScaner <TDbContext>, SimpleEntityScaner <TDbContext> >();
services.AddScoped <NamedConnectionGenerator>();
return(services);
}
public static IServiceCollection AddDbPerSchema <TDbContext>(this IServiceCollection services,
DbIntegrationType dbType, string key = "default",
string connectionName = "tenantConnection",
Action <DbContextOptionsBuilder> optionAction = null)
where TDbContext : DbContext, ITenantDbContext
{
var settings = new TenantSettings <TDbContext>()
{
Key = key,
DbType = dbType,
ConnectionName = connectionName,
ConnectionType = ConnectionResolverType.BySchema,
DbContextOptionAction = optionAction
};
return(services.AddTenantedDatabase <TDbContext>(settings));
}
/// <summary>
/// Quick and dirty simulation of physically isolated databases for tenants
/// </summary>
/// <param name="settings"></param>
private void SeedTestData(TenantSettings settings)
{
RemoveAllWidgets();
switch (settings.TenantId)
{
case "tenant1":
_context.Widgets.AddRange(new List <Widget>()
{
new Widget {
Id = Guid.NewGuid(), Color = "Yellow", Shape = "Square"
},
new Widget {
Id = Guid.NewGuid(), Color = "Blue", Shape = "Round"
},
});
break;
case "tenant2":
_context.Widgets.AddRange(new List <Widget>()
{
new Widget {
Id = Guid.NewGuid(), Color = "Green", Shape = "Cube"
},
new Widget {
Id = Guid.NewGuid(), Color = "Purple", Shape = "Polyhedron"
},
});
break;
default:
_context.Widgets.AddRange(new List <Widget>()
{
new Widget {
Id = Guid.NewGuid(), Color = "Brown", Shape = "Tube"
},
new Widget {
Id = Guid.NewGuid(), Color = "Black", Shape = "Knob"
},
});
break;
}
_context.SaveChanges();
}
private DbContextOptions <WidgetDbContext> CreateDbContextOptionsBuilder(TenantSettings settings)
{
// build a DbContext for this tenant
var service = new CatalogService(settings);
var cn = service.GetConnectionString().Result;
// -------------------------------------------------------------------
// This would be production code with a real backend database
// -------------------------------------------------------------------
// var optionsBuilder = new DbContextOptionsBuilder<WidgetDbContext>()
// .UseSqlServer(cn);
// returning an in-memory db instead just for illustration purposes
var optionsBuilder = new DbContextOptionsBuilder <WidgetDbContext>()
.UseInMemoryDatabase(databaseName: settings.TenantId);
return(optionsBuilder.Options);
}
public WidgetController(IConfiguration configuration, IHttpContextAccessor httpContextAccessor)
{
var tenantId = httpContextAccessor.HttpContext.User.Identity.Name;
var settings = new TenantSettings
{
TenantId = tenantId,
// get default cn from appsettings.json
DefaultConnectionString = configuration.GetConnectionString("DefaultConnection")
};
// build a DbContext specifically for this tenant
var options = CreateDbContextOptionsBuilder(settings);
_context = new WidgetDbContext(options);
// seed data for the tenant
SeedTestData(settings);
}
public void Init()
{
_dummyScenarioList = RunsValidationsDummyData.GetScenarios();
_dummyScenario = RunsValidationsDummyData.GetScenario();
_dummyCampaignPassPriorityList = RunsValidationsDummyData.GetCampaignPassPriorities();
_dummyPassReferenceList = RunsValidationsDummyData.GetPassReferences();
_dummyTenantSettings = RunsValidationsDummyData.GetTenantSettings();
_dummyPassSalesAreaPriorityAllTrue = RunsValidationsDummyData.GetPassSalesAreaPriorityWithFlagsTrue();
_dummyPassSalesAreaPriorityAllFalse = RunsValidationsDummyData.GetPassSalesAreaPriorityWithFlagsFalse();
_dummyRun = RunsValidationsDummyData.GetRun();
_dummyPass = RunsValidationsDummyData.GetPass();
_dummyRunSalesAreasPriority = RunsValidationsDummyData.GetRunSalesAreaPriorities();
_dummySalesAreas = RunsValidationsDummyData.GetSalesAreas();
_dummyNotExcludedSalesAreas = _dummyRunSalesAreasPriority
.Where(o => o.Priority != SalesAreaPriorityType.Exclude)
.Select(o => o.SalesArea)
.ToList();
}
public async Task ShouldUpdateTenantSettings()
{
var tenantId = Guid.NewGuid();
var tenantSettings = new TenantSettings()
{
TenantId = tenantId
};
var expected = new TenantSettingsDTO();
var tenantSettingsDTO = new TenantSettingsDTO();
var tenantSettingsList = new List <TenantSettings>()
{
tenantSettings,
new TenantSettings()
{
TenantId = Guid.NewGuid(),
}
};
_mock.Mock <IInventContext>()
.Setup(context => context.TenantSettings)
.ReturnsAsDbSet(tenantSettingsList);
_mock.Mock <IMapper>()
.Setup(mapper => mapper.Map(tenantSettingsDTO, tenantSettings))
.Returns(tenantSettings);
_mock.Mock <IMapper>()
.Setup(mapper => mapper.Map <TenantSettingsDTO>(tenantSettings))
.Returns(expected);
var actual = await _service.UpdateAsync(tenantSettingsDTO, tenantId);
_mock.Mock <IInventContext>()
.Verify(context => context.Update(tenantSettings));
_mock.Mock <IInventContext>()
.Verify(context => context.SaveChangesAsync(default(CancellationToken)));
ContentAssert.AreEqual(expected, actual);
}
public static IServiceCollection AddDbPerConnection <TDbContext>(this IServiceCollection services,
DbIntegrationType dbType, string key = "default",
string connectionPrefix = "tenanted",
Action <DbContextOptionsBuilder> optionAction = null,
Action <IServiceProvider, string, DbContextOptionsBuilder> dbContextSetup = null)
where TDbContext : DbContext, ITenantDbContext
{
var settings = new TenantSettings <TDbContext>()
{
Key = key,
DbType = dbType,
ConnectionPrefix = connectionPrefix,
ConnectionType = ConnectionResolverType.ByDatabase,
DbContextOptionAction = optionAction,
DbContextSetup = dbContextSetup
};
return(services.AddTenantedDatabase <TDbContext>(settings));
}
public void AddOrUpdate(TenantSettings tenantSettings)
{
var currentSettings = Get();
if (tenantSettings == currentSettings)
{
return;
}
if (currentSettings != null)
{
_mapper.Map(tenantSettings, currentSettings);
_session.Store(currentSettings);
}
else
{
_session.Store(tenantSettings);
}
}
public ActionResult <string> UpdateTenant(string tenantName, [FromBody] TenantSettings tenantSettings)
{
tenantName = tenantName.ToLower().Replace(" ", string.Empty);
var isFromCli = HttpContext.Request.Headers["x-called-by"].ToString();
if (isFromCli != "")
{
_logger.LogInformation($"{isFromCli} PATCH '{HttpContext.Request.Path}' is called");
}
else
{
_logger.LogInformation($"PATCH '{HttpContext.Request.Path}' is called");
}
return(Ok(tenantName));
}
static void Main(string[] args)
{
Console.WriteLine("Enter your SharePoint Online Admin Center URL");
string adminCenterUrl = Console.ReadLine();
var authManager = new OfficeDevPnP.Core.AuthenticationManager();
ClientContext ctx = authManager.GetWebLoginClientContext(adminCenterUrl);
Console.WriteLine("\nYou are connected to " + adminCenterUrl + "\n");
Console.WriteLine("\nEnter your SharePoint App Catalog URL");
string appCatalogUrl = Console.ReadLine();
var settings = TenantSettings.GetCurrent(ctx);
settings.SetCorporateCatalog(appCatalogUrl);
ctx.ExecuteQuery();
Console.WriteLine("\nYou changed your App Catalog to " + appCatalogUrl);
}
public static TenantTimeSettings ConvertToTimeTenantSettings(this TenantSettings tenantSettings, IFeatureManager featureManager)
{
var useSystemLogicalDate = featureManager.IsEnabled(nameof(ProductFeature.UseSystemLogicalDate));
var tenantTimeSettings = new TenantTimeSettings
{
MidnightStartTime = tenantSettings.MidnightStartTime,
MidnightEndTime = tenantSettings.MidnightEndTime,
PeakStartTime = tenantSettings.PeakStartTime,
PeakEndTime = tenantSettings.PeakEndTime,
StartDayOfWeek = tenantSettings.StartDayOfWeek,
};
if (useSystemLogicalDate)
{
tenantTimeSettings.SystemLogicalDate = tenantSettings.SystemLogicalDate;
}
return(tenantTimeSettings);
}
public ActionResult <string> AddTenant(string tenantName, [FromBody] TenantSettings tenantSettings)
{
tenantName = tenantName.ToLower().Replace(" ", string.Empty);
var isFromCli = HttpContext.Request.Headers["x-called-by"].ToString();
if (isFromCli != "")
{
_logger.LogInformation($"{isFromCli} POST '{HttpContext.Request.Path}' is called");
}
else
{
_logger.LogInformation($"POST '{HttpContext.Request.Path}' is called");
}
if (_tenantService.CreateTenant(tenantName, tenantSettings) != true)
{
return(BadRequest("Couldn't add new tenant, or tenant already exists"));
}
return(Ok($"Tenant {tenantName} has been created"));
}
public void AddOrUpdate(TenantSettings tenantSettings)
{
var currentEntity = _dbContext.Query <TenantSettingsEntity>()
.Include(x => x.RunEventSettings)
.Include(x => x.Features)
.Include(x => x.WebhookSettings)
.FirstOrDefault();
if (currentEntity == null)
{
_dbContext.Add(_mapper.Map <TenantSettingsEntity>(tenantSettings),
post => post.MapTo(tenantSettings), _mapper);
}
else
{
_mapper.Map(tenantSettings, currentEntity);
_dbContext.Update(currentEntity, post => post.MapTo(tenantSettings), _mapper);
}
_cachedTenantSettings = tenantSettings;
}
public async Task <IHttpActionResult> SetDefault(Guid id)
{
if (id == Guid.Empty)
{
return(BadRequest("Invalid Id"));
}
LibrarySalesAreaPassPriority libSalesAreaPassPriority = await _librarySalesAreaPassPrioritiesRepository.GetAsync(id);
if (libSalesAreaPassPriority == null)
{
return(NotFound());
}
TenantSettings tenantSettings = _tenantSettingsRepository.Get();
if (tenantSettings != null)
{
tenantSettings.DefaultSalesAreaPassPriorityId = id;
_tenantSettingsRepository.AddOrUpdate(tenantSettings);
}
return(Ok());
}
public DocumentStoreTestConfiguration(String engineVersion = "v3", String tenantId = "tests")
{
if (engineVersion != "v3")
{
throw new NotSupportedException("Only v3 is supported with this version of NES");
}
EngineVersion = engineVersion;
IsApiServer = true;
IsWorker = false;
IsReadmodelBuilder = true;
QueueConnectionString = ConfigurationManager.ConnectionStrings["ds.queue"].ConnectionString;
LogsConnectionString = ConfigurationManager.ConnectionStrings["log"].ConnectionString;
QueueInfoList = new Core.Jobs.QueueManager.QueueInfo[] { };
QueueJobsPollInterval = 100; //poll each 100 milliseconds.
QueueStreamPollInterval = 1000;
IsQueueManager = false;
TenantSettings.Add(new TestTenantSettings(tenantId));
BucketInfo = new List <BucketInfo>()
{
new BucketInfo()
{
Slots = new[] { "*" }, BufferSize = 10
}
};
Boost = "true";
DelayedStartInMilliseconds = 1000;
ForcedGcSecondsInterval = 0;
EngineSlots = new String[] { "*" };
PollingMsInterval = 100;
AllowedFileTypes = "pdf|xls|xlsx|docx|doc|ppt|pptx|pps|ppsx|rtf|odt|ods|odp|htmlzip|eml|msg|jpeg|jpg|png|zip|txt".Split('|');
IsDeduplicationActive = true;
StorageType = StorageType.GridFs;
}
public TenantConfiguration()
{
Products = new List <ProductConfiguration>();
Settings = new TenantSettings();
}
public HomeController(ILogger <HomeController> logger, IOptions <TenantSettings> options, TenantService tenantService)
{
_logger = logger;
tenantSettings = options.Value;
this.tenantService = tenantService;
}
public CatalogService(TenantSettings tenantSettings)
{
_tenantSettings = tenantSettings ??
throw new ArgumentNullException(nameof(tenantSettings));
}
public TenantsContextInitializerDropMigrate(IServiceProvider serviceProvider, TenantSettings <TTenant> settings)
{
_serviceProvider = serviceProvider;
this.settings = settings;
}
