public void AssertJsonSerializer()
{
string connectionString = "AccountEndpoint=https://localtestcosmos.documents.azure.com:443/;AccountKey=425Mcv8CXQqzRNCgFNjIhT424GK99CKJvASowTnq15Vt8LeahXTcN5wt3342vQ==;";
var configuration = new CosmosConfiguration(connectionString);
Assert.IsInstanceOfType(configuration.CosmosJsonSerializer, typeof(CosmosJsonSerializerWrapper));
}
public async Task TestCustomJsonSerializer()
{
int toStreamCount = 0;
int fromStreamCount = 0;
Mock <CosmosJsonSerializer> mockJsonSerializer = new Mock <CosmosJsonSerializer>();
//The item object will be serialized with the custom json serializer.
ToDoActivity testItem = CreateRandomToDoActivity();
mockJsonSerializer.Setup(x => x.ToStream <ToDoActivity>(It.IsAny <ToDoActivity>())).Callback(() => toStreamCount++).Returns(this.jsonSerializer.ToStream <ToDoActivity>(testItem));
mockJsonSerializer.Setup(x => x.FromStream <ToDoActivity>(It.IsAny <Stream>())).Callback <Stream>(x => { x.Dispose(); fromStreamCount++; }).Returns(testItem);
//Create a new cosmos client with the mocked cosmos json serializer
CosmosConfiguration configuration = TestCommon.GetDefaultConfiguration();
configuration.UseCustomJsonSerializer(mockJsonSerializer.Object);
CosmosClient mockClient = TestCommon.CreateCosmosClient(configuration);
CosmosContainer mockContainer = mockClient.Databases[this.database.Id].Containers[this.container.Id];
//Validate that the custom json serializer is used for creating the item
CosmosItemResponse <ToDoActivity> response = await mockContainer.Items.CreateItemAsync <ToDoActivity>(partitionKey : testItem.status, item : testItem);
Assert.IsNotNull(response);
Assert.AreEqual(HttpStatusCode.Created, response.StatusCode);
Assert.AreEqual(1, toStreamCount);
Assert.AreEqual(1, fromStreamCount);
await mockContainer.Items.DeleteItemAsync <ToDoActivity>(testItem.status, testItem.id);
}
public async Task TestCustomPropertyWithHandler()
{
CustomHandler testHandler = new CustomHandler();
// Add the random guid to the property
Guid randomGuid = Guid.NewGuid();
string propertyKey = "Test";
testHandler.UpdateRequestMessage = x => x.Properties[propertyKey] = randomGuid;
CosmosConfiguration configuration = TestCommon.GetDefaultConfiguration()
.AddCustomHandlers(testHandler);
CosmosClient customClient = TestCommon.CreateCosmosClient(configuration);
ToDoActivity testItem = CreateRandomToDoActivity();
using (CosmosResponseMessage response = await customClient.Databases[this.database.Id].Containers[this.Container.Id].Items.CreateItemStreamAsync(
partitionKey: testItem.status,
streamPayload: this.jsonSerializer.ToStream(testItem)))
{
Assert.IsNotNull(response);
Assert.IsNotNull(response.RequestMessage);
Assert.IsNotNull(response.RequestMessage.Properties);
Assert.AreEqual(randomGuid, response.RequestMessage.Properties[propertyKey]);
}
}
/// <summary>
/// Initialize a static instance of the <see cref="CosmosClient"/>.
/// </summary>
/// <returns></returns>
private static CosmosClient InitializeCosmosClient()
{
string endpoint = configuration["EndPointUrl"];
if (string.IsNullOrEmpty(endpoint))
{
throw new ArgumentNullException("Please specify a valid endpoint in the appSettings.json");
}
string authKey = configuration["AuthorizationKey"];
if (string.IsNullOrEmpty(authKey) || string.Equals(authKey, "Super secret key"))
{
throw new ArgumentException("Please specify a valid AuthorizationKey in the appSettings.json");
}
var cosmosConfiguration = new CosmosConfiguration(endpoint,
authKey);
// Customize client configuration
var cosmosClient = new CosmosClient(cosmosConfiguration);
// Optional. Initialize container
CosmosDatabaseResponse databaseResponse = cosmosClient.Databases.CreateDatabaseIfNotExistsAsync("mydb").Result;
CosmosDatabase database = databaseResponse.Database;
var containerResponse = database.Containers.CreateContainerIfNotExistsAsync("mycoll", "/id").Result;
return(cosmosClient);
}
private CosmosConfiguration BuildCosmosConfiguration()
{
var config = BuildConfig();
var batch = new CosmosConfiguration();
config.GetSection("documents").Bind(batch);
return(batch);
}
public CosmosClientFactory(CosmosConfiguration configuration)
{
_client = new CosmosClient(
configuration.EndpointUrl,
configuration.PrimaryKey
);
_databaseName = configuration.DatabaseName;
}
/// <summary>
/// Initializes a new instance of the <see cref="CosmosUserRepository{T}"/> class.
/// </summary>
/// <param name="cosmosConfiguration">Configuration to create connection with an Azure Cosmos DB Database</param>
/// <param name="loggerFactory">Logger factory to create a logger</param>
public CosmosUserRepository(CosmosConfiguration cosmosConfiguration, ILoggerFactory loggerFactory)
: base(cosmosConfiguration, loggerFactory)
{
this.Logger.LogTrace("Beginning construction of Cosmos User Repository");
this.container = this.CosmosClient.GetContainer(this.DatabaseId, UserBase.ContainerId);
this.Logger.LogTrace("Construction of Cosmos User Repository complete");
}
protected override void ConfigureTransportAndPersistence(IBusConfigurator cfg)
{
var mongoCfg = new CosmosConfiguration(_fixture.ConnectionString,
_fixture.DbName,
CosmosSagaStateRepositoryOptions.Default,
CosmosOutboxRepositoryOptions.Default);
cfg.UseInMemoryTransport()
.UseCosmosPersistence(mongoCfg);
}
/// <summary>
/// Initialize the db
/// </summary>
/// <returns></returns>
public static async Task InitDbConnection()
{
CosmosConfiguration config = new CosmosConfiguration(Endpoint, PrimaryKey);
client = new CosmosClient(config);
CosmosDatabase database = await client.Databases.CreateDatabaseIfNotExistsAsync(DatabaseId);
CosmosContainer container = await database.Containers.CreateContainerIfNotExistsAsync(ContainerId, "/CategoryName");
items = container.Items;
}
public static CosmosClient CreateMockCosmosClient(CosmosRequestHandler preProcessingHandler = null, CosmosConfiguration configuration = null)
{
DocumentClient documentClient = new MockDocumentClient();
CosmosConfiguration cosmosConfiguration =
configuration?.AddCustomHandlers(preProcessingHandler)
?? new CosmosConfiguration("http://localhost", Guid.NewGuid().ToString())
.AddCustomHandlers(preProcessingHandler);
return(new CosmosClient(
cosmosConfiguration,
documentClient));
}
private static CosmosClient InitializeCosmosClient()
{
var connectionString =
Environment.GetEnvironmentVariable("CosmosDB:ConnectionString");
var cosmosConfiguration =
new CosmosConfiguration(connectionString);
var cosmosClient =
new CosmosClient(cosmosConfiguration);
return(cosmosClient);
}
/// <summary>
/// Initializes a new instance of the <see cref="SearchService"/> class.
/// </summary>
/// <param name="loggerFactory">Logger factory for this service</param>
/// <param name="configuration">Application configuration</param>
public SearchService(ILoggerFactory loggerFactory, IConfiguration configuration)
: base(loggerFactory, configuration)
{
this.Logger.LogTrace("Construction of Search Service beginning");
// Build configurations
var cosmosConfiguration = CosmosConfiguration.BuildFromConfiguration(this.Configuration);
var searchConfiguration = AzureSearchConfiguration.BuildFromConfiguration(this.Configuration);
this.userRepository = new CosmosUserRepository <ReadByAllUser>(cosmosConfiguration, loggerFactory);
this.searchRepository = new AzureSearchRepository(searchConfiguration, loggerFactory);
this.Logger.LogTrace("Construction of Search Service complete");
}
/// <summary>
/// Initializes a new instance of the <see cref="ServiceBase"/> class.
/// </summary>
/// <param name="loggerFactory">Logger factory for this service</param>
/// <param name="configurationMaybeNull">Application configuration</param>
public ServiceBase(ILoggerFactory loggerFactory, IConfiguration?configurationMaybeNull)
{
this.Configuration = Ensure.IsNotNull(() => configurationMaybeNull);
loggerFactory = Ensure.IsNotNull(() => loggerFactory);
this.Logger = loggerFactory.CreateLogger <ServiceBase>();
// Build cosmos configuration
var cosmosConfiguration = CosmosConfiguration.BuildFromConfiguration(this.Configuration);
this.userRepository = new CosmosUserRepository <AdminUser>(cosmosConfiguration, loggerFactory);
this.Logger.LogTrace("Construction of ServiceBase complete");
}
private CosmosConfiguration BuildCosmosConfiguration()
{
var configuration = new CosmosConfiguration(_endPoint, _authKey)
{
UserAgentSuffix = _userAgent,
ConnectionMode = ConnectionMode.Direct
};
if (_region != null)
{
configuration = configuration.UseCurrentRegion(_region);
}
return(configuration);
}
protected override void ConfigureTransportAndPersistence(IBusConfigurator cfg)
{
var(_, dbName) = _cosmosFixture.CreateDbContext();
var mongoCfg = new CosmosConfiguration(_cosmosFixture.ConnectionString,
dbName,
CosmosSagaStateRepositoryOptions.Default,
CosmosOutboxRepositoryOptions.Default);
cfg.UseAzureServiceBusTransport(_sbFixture.Configuration, builder =>
{
builder.UseMessageNamingPolicy <StartSimpleSaga>(() =>
new QueueReferences(_topicName, _subscriptionName));
})
.UseCosmosPersistence(mongoCfg);
}
/// <summary>
/// Initializes a new instance of the <see cref="Entrypoint"/> class.
/// </summary>
public Entrypoint()
{
var builder = new ConfigurationBuilder();
// Tell the builder to look for the appsettings.json file
builder.AddJsonFile("Properties/appsettings.json", optional: false, reloadOnChange: true);
// Add user secrets
builder.AddUserSecrets <Entrypoint>();
// Build configuration
var configuration = builder.Build();
// Build and validate Cosmos Configuration
this.cosmosConfiguration = CosmosConfiguration.BuildFromConfiguration(configuration);
}
public async Task SetUpAsync()
{
_configuration = new CosmosConfiguration()
{
EndpointUrl = TestContext.Parameters["EndpointUrl"],
AuthorizationKey = TestContext.Parameters["AuthorizationKey"],
RecipeDatabaseName = TestContext.Parameters["RecipeDatabaseName"],
RecipeContainerName = $"integrationtest-{Guid.NewGuid()}"
};
var cosmosclient = new CosmosClient(_configuration.EndpointUrl, _configuration.AuthorizationKey);
var database = cosmosclient.GetDatabase(_configuration.RecipeDatabaseName);
var containerResponse = await database.CreateContainerIfNotExistsAsync(_configuration.RecipeContainerName, "/id");
_container = containerResponse.Container;
}
public void ConfigureServices()
{
var services = new ServiceCollection();
services.AddMemoryCache();
services.AddOptions();
services.Configure <SearchConfiguration>(options =>
{
Configuration.GetSection("search").Bind(options);
SearchConfiguration.Validate(options);
});
services.Configure <CosmosConfiguration>(options =>
{
Configuration.GetSection("documents").Bind(options);
CosmosConfiguration.Validate(options);
});
services.Configure <StorageConfiguration>((config) =>
{
Configuration.GetSection("storage").Bind(config);
StorageConfiguration.Validate(config);
});
services.Configure <BatchConfiguration>((config) =>
{
Configuration.GetSection("batch").Bind(config);
BatchConfiguration.Validate(config);
});
var armTemplatesMap = new ArmTemplatesMap();
services.AddSingleton(armTemplatesMap);
var staticAssetsMap = new StaticAssetsMap();
services.AddSingleton(staticAssetsMap);
services.AddSingleton <ApplicationJobs>();
services.AddSingleton <DatasetStorageService>();
services.AddSingleton <DatasetOwnersService>();
services.AddSingleton <DatasetEditStorageService>();
services.AddSingleton <UserDataStorageService>();
services.AddSingleton <SasTokenService>();
services.AddSingleton <ValidationService>();
services.AddSingleton <DatasetSearchService>();
services.AddSingleton <FileSearchService>();
ServiceProvider = services.BuildServiceProvider();
}
/// <summary>
/// Initializes a new instance of the <see cref="UserService"/> class.
/// </summary>
/// <param name="loggerFactory">Logger factory for this service</param>
/// <param name="configuration">Application configuration</param>
public UserService(ILoggerFactory loggerFactory, IConfiguration configuration)
: base(loggerFactory, configuration)
{
this.Logger.LogTrace("Construction of User Service beginning");
// Build user repository
var cosmosConfiguration = CosmosConfiguration.BuildFromConfiguration(this.Configuration);
this.userRepository = new CosmosUserRepository <AdminUser>(cosmosConfiguration, loggerFactory);
// Build AAD Repository
var azureActiveDirectoryConfiguration = AzureActiveDirectoryConfiguration.BuildFromConfiguration(this.Configuration);
this.azureActiveDirectoryRepository = new AzureActiveDirectoryRepository(loggerFactory, azureActiveDirectoryConfiguration);
this.Logger.LogTrace("Construction of User Service complete");
}
/// <summary>
/// Initializes a new instance of the <see cref="CosmosRepositoryBase"/> class.
/// </summary>
/// <param name="cosmosConfiguration">Configuration to create connection with an Azure Cosmos DB Database</param>
/// <param name="loggerFactory">Logger factory to create a logger</param>
public CosmosRepositoryBase(CosmosConfiguration cosmosConfiguration, ILoggerFactory loggerFactory)
: base(loggerFactory)
{
this.Logger.LogTrace("Construction of Cosmos Repository Base starting");
// Validate input arguments
cosmosConfiguration = Ensure.IsNotNull(() => cosmosConfiguration);
cosmosConfiguration.Validate();
// Set database id
this.DatabaseId = Ensure.IsNotNullOrWhitespace(() => cosmosConfiguration.DatabaseId);
this.CosmosClient = CosmosRepositoryBase
.CosmosClientFactory
.GetCosmosClient(Ensure.IsNotNullOrWhitespace(() => cosmosConfiguration.ConnectionString));
this.Logger.LogTrace("Construction of Cosmos Repository Base complete");
}
public static async Task Initialize(IConfiguration configuration)
{
databaseId = configuration.GetSection("CosmosDb").GetSection("Database").Value ?? "Tasks";
containerId = configuration.GetSection("CosmosDb").GetSection("Container").Value ?? "Items";
endpoint = configuration.GetSection("CosmosDb").GetSection("Endpoint").Value;
primaryKey = configuration.GetSection("CosmosDb").GetSection("PrimaryKey").Value;
var config = new CosmosConfiguration(endpoint, primaryKey);
client = new CosmosClient(config);
CosmosDatabase database = await client.Databases.CreateDatabaseIfNotExistsAsync(databaseId);
CosmosContainer container =
await database.Containers.CreateContainerIfNotExistsAsync(containerId, "/category");
items = container.Items;
}
public void ThenTheTenantCalledShouldContainCosmosConfigurationForACosmosContainerDefinitionWithDatabaseNameAndContainerName(
string tenantName,
string databaseName,
string containerName)
{
InMemoryTenantProvider tenantProvider =
ContainerBindings.GetServiceProvider(this.scenarioContext).GetRequiredService <InMemoryTenantProvider>();
ITenant tenant = tenantProvider.GetTenantByName(tenantName)
?? throw new TenantNotFoundException($"Could not find tenant with name '{tenantName}'");
var containerDefinition = new CosmosContainerDefinition(databaseName, containerName, null);
CosmosConfiguration tenantConfigItem = tenant.GetCosmosConfiguration(containerDefinition);
// GetCosmosStorageConfiguration would have thrown an exception if the config didn't exist, but we'll do a
// not null assertion anyway...
Assert.IsNotNull(tenantConfigItem);
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
var cosmosConfiguration = new CosmosConfiguration();
Configuration.GetSection("Cosmos").Bind(cosmosConfiguration);
var testConfiguration = new TestConfiguration();
Configuration.GetSection("TestData").Bind(testConfiguration);
services.AddSingleton(testConfiguration);
services.AddControllers();
var cosmosClient = InitializeCosmosDb(cosmosConfiguration).GetAwaiter().GetResult();
services.AddSingleton(new UserPartitionRepository(cosmosClient, cosmosConfiguration.Database, DataConstants.USER_CONTAINER));
services.AddSingleton(new UserInstitutionPartitionRepository(cosmosClient, cosmosConfiguration.Database, DataConstants.USER_INSTITUTION_CONTAINER));
services.AddSingleton(new FinancialAccountPartitionRepository(cosmosClient, cosmosConfiguration.Database, DataConstants.FINANCIAL_ACCOUNT_CONTAINER));
services.AddHostedService <StartupService>();
}
private static EnrollmentConfigurationItem[] GetWorkflowConfig(FeatureContext featureContext)
{
IConfiguration configuration = ContainerBindings
.GetServiceProvider(featureContext)
.GetRequiredService <IConfiguration>();
// Note: this next part is using configuration types from the old (v2) Corvus.Tenancy
// libraries. Unfortunately, this is currently unavoidable because the current version
// of Marain.TenantManagement.Abstractions defines enrollment mechanism in terms of
// those older types.
// Load the config items we need:
CosmosConfiguration cosmosConfiguration =
configuration.GetSection("TestCosmosConfiguration").Get <CosmosConfiguration>()
?? new CosmosConfiguration();
cosmosConfiguration.DatabaseName = "endjinspecssharedthroughput";
BlobStorageConfiguration storageConfiguration =
configuration.GetSection("TestBlobStorageConfiguration").Get <BlobStorageConfiguration>()
?? new BlobStorageConfiguration();
return(new EnrollmentConfigurationItem[]
{
new EnrollmentBlobStorageConfigurationItem
{
Key = "workflowStore",
Configuration = storageConfiguration,
},
new EnrollmentCosmosConfigurationItem
{
Key = "workflowInstanceStore",
Configuration = cosmosConfiguration,
},
new EnrollmentBlobStorageConfigurationItem
{
Key = "operationsStore",
Configuration = storageConfiguration,
},
});
}
public static async Task SetupCosmosContainerForRootTenant(FeatureContext featureContext)
{
IServiceProvider serviceProvider = ContainerBindings.GetServiceProvider(featureContext);
ITenantCosmosContainerFactory factory = serviceProvider.GetRequiredService <ITenantCosmosContainerFactory>();
ITenantProvider tenantProvider = serviceProvider.GetRequiredService <ITenantProvider>();
string containerBase = Guid.NewGuid().ToString();
CosmosConfiguration config = tenantProvider.Root.GetDefaultCosmosConfiguration();
config.DatabaseName = "endjinspecssharedthroughput";
config.DisableTenantIdPrefix = true;
tenantProvider.Root.SetDefaultCosmosConfiguration(config);
Container contentManagementSpecsContainer = await factory.GetContainerForTenantAsync(
tenantProvider.Root,
new CosmosContainerDefinition("endjinspecssharedthroughput", $"{containerBase}contentmanagementspecs", Content.PartitionKeyPath, databaseThroughput : 400)).ConfigureAwait(false);
featureContext.Set(contentManagementSpecsContainer, ContentManagementSpecsContainer);
featureContext.Set <IContentStore>(new CosmosContentStore(contentManagementSpecsContainer), ContentManagementSpecsContentStore);
}
protected override void ConfigureTransportAndPersistence(IBusConfigurator cfg)
{
var(_, dbName) = _cosmosFixture.CreateDbContext();
var cosmosCfg = new CosmosConfiguration(_cosmosFixture.ConnectionString,
dbName,
CosmosSagaStateRepositoryOptions.Default,
CosmosOutboxRepositoryOptions.Default);
cfg.UseAzureServiceBusTransport(_sbFixture.Configuration, builder =>
{
QueueReferencesPolicy <DummyEvent> policy = () =>
{
var sp = cfg.Services.BuildServiceProvider();
var sysInfo = sp.GetService <SystemInfo>();
var subscriptionName = sysInfo.ClientGroup;
return(new QueueReferences(_topicName, subscriptionName));
};
builder.UseMessageNamingPolicy(policy);
})
.UseCosmosPersistence(cosmosCfg);
}
public void Initialize()
{
var builder = new ConfigurationBuilder()
.SetBasePath(Directory.GetCurrentDirectory())
.AddJsonFile("appsettings.json", optional: false, reloadOnChange: true)
.AddEnvironmentVariables();
IConfigurationRoot configuration = builder.Build();
var cosmosConfiguration = new CosmosConfiguration();
configuration.GetSection("CosmosConfiguration").Bind(cosmosConfiguration);
var serviceCollection = new ServiceCollection();
serviceCollection.AddOptions();
serviceCollection.Configure <CosmosConfiguration>(c =>
{
configuration.GetSection("CosmosConfiguration").Bind(c);
});
//serviceCollection.AddSingleton<IUserRepository, UserRepository>();
//serviceCollection.AddSingleton<IRoleRepository, RoleRepository>();
serviceCollection.AddScoped <IUserRepository, UserRepository>();
serviceCollection.AddScoped <IUserStore <User>, UserRepository>();
serviceCollection.AddScoped <IRoleRepository, RoleRepository>();
serviceCollection.AddScoped <IRoleStore <Role>, RoleRepository>();
serviceCollection.AddScoped <IPasswordHasher <User>, ApplicationPasswordHasher>();
serviceCollection.AddScoped <UserManager <User>, ApplicationUserManager>();
serviceCollection.AddScoped <RoleManager <Role>, ApplicationRoleManager>();
serviceCollection.AddScoped <SignInManager <User>, ApplicationSignInManager>();
_serviceProvider = serviceCollection.BuildServiceProvider();
}
public static async Task SetupTransientTenant(FeatureContext context)
{
// This needs to run after the ServiceProvider has been constructed
IServiceProvider provider = ContainerBindings.GetServiceProvider(context);
ITenantProvider tenantProvider = provider.GetRequiredService <ITenantProvider>();
// In order to ensure the Cosmos aspects of the Tenancy setup are fully configured, we need to resolve
// the ITenantCosmosContainerFactory, which triggers setting default config to the root tenant.
// HACK: This is a hack until we can come up with a better way of handling deferred initialisation.
provider.GetRequiredService <ITenantCosmosContainerFactory>();
ITenant rootTenant = tenantProvider.Root;
ITenant transientTenant = await tenantProvider.CreateChildTenantAsync(rootTenant.Id).ConfigureAwait(false);
CosmosConfiguration config = rootTenant.GetDefaultCosmosConfiguration() ?? new CosmosConfiguration();
config.DatabaseName = "endjinspecssharedthroughput";
config.DisableTenantIdPrefix = true;
transientTenant.SetDefaultCosmosConfiguration(config);
await tenantProvider.UpdateTenantAsync(transientTenant).ConfigureAwait(false);
context.Set(transientTenant);
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.AddApplicationInsightsTelemetry();
services.AddSingleton <IHttpContextAccessor, HttpContextAccessor>();
services.AddSingleton <IConfiguration>(Configuration);
services.AddOptions();
services.Configure <IdentityProviderConfiguration>(options =>
{
Configuration.GetSection("azuread").Bind(options);
IdentityProviderConfiguration.Validate(options);
});
services.Configure <SearchConfiguration>(options =>
{
Configuration.GetSection("search").Bind(options);
SearchConfiguration.Validate(options);
});
services.Configure <CosmosConfiguration>(options =>
{
Configuration.GetSection("documents").Bind(options);
CosmosConfiguration.Validate(options);
});
services.Configure <StorageConfiguration>((config) =>
{
Configuration.GetSection("storage").Bind(config);
StorageConfiguration.Validate(config);
});
services.Configure <BatchConfiguration>((config) =>
{
Configuration.GetSection("batch").Bind(config);
BatchConfiguration.Validate(config);
});
services.Configure <AppInsightsConfiguration>((config) =>
{
Configuration.GetSection("applicationinsights").Bind(config);
AppInsightsConfiguration.Validate(config);
});
var armTemplatesMap = new ArmTemplatesMap();
services.AddSingleton(armTemplatesMap);
var staticAssetsMap = new StaticAssetsMap();
services.AddSingleton(staticAssetsMap);
services.AddMemoryCache();
//services
// .AddAuthentication(options =>
// {
// options.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme;
// options.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme;
// })
// .AddJwtBearer(options =>
// {
// options.Audience = Configuration["azureADConfig:clientId"];
// options.Authority = Configuration["azureADConfig:authority"];
// options.Events = new JwtBearerEvents
// {
// OnMessageReceived = FetchAuthTokenFromCookie,
// OnTokenValidated = async context =>
// {
// var principal = context.Principal;
// var ODREmailList = Configuration["ODRAdminList"].Split(";");
// }
// };
// });
//services
// .AddAuthentication(options =>
// {
// options.DefaultScheme = JwtBearerDefaults.AuthenticationScheme;
// })
// .AddJwtBearer(options =>
// {
// options.Audience = Configuration["azureADConfig:clientId"];
// options.Authority = Configuration["azureADConfig:authority"];
// options.TokenValidationParameters = new Microsoft.IdentityModel.Tokens.TokenValidationParameters
// {
// ValidAudience = Configuration["azureADConfig:clientId"],
// ValidIssuer = $"https://login.microsoftonline.com/" + Configuration["azureADConfig:tenantId"] + "/v2.0"
// };
// options.Events = new JwtBearerEvents
// {
// OnMessageReceived = FetchAuthTokenFromCookie,
// //OnTokenValidated = async context =>
// //{
// // var principal = context.Principal;
// // if (Configuration.GetChildren().Any(item => item.Key == "ODRAdminList") && principal.Claims.Any(c => c.Type == "preferred_username"))
// // {
// // var ODRAdminsList = Configuration["ODRAdminList"].Split(";").ToList();
// // var testSubject = principal.Claims.FirstOrDefault(c => c.Type == "preferred_username").Value;
// // if (ODRAdminsList.Contains(testSubject))
// // {
// // var claims = new List<Claim>
// // {
// // new Claim(ClaimTypes.Role, "ODRAdmin")
// // };
// // var appIdentity = new ClaimsIdentity(claims);
// // principal.AddIdentity(appIdentity);
// // }
// // }
// //}
// };
// });
services
.AddAuthentication(options =>
{
options.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme;
options.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme;
})
.AddJwtBearer(options =>
{
var tenantName = Configuration["AzureAD:Tenant"].Split('.').First();
var policyName = Configuration["AzureAD:Policy"];
var audience = Configuration["AzureAD:Audience"];
options.MetadataAddress = $"https://{tenantName}.b2clogin.com/{tenantName}.onmicrosoft.com/{policyName}/v2.0/.well-known/openid-configuration";
options.Audience = audience;
options.Events = new JwtBearerEvents
{
OnMessageReceived = FetchAuthTokenFromCookie,
OnAuthenticationFailed = context =>
{
var ctx = context;
return(Task.FromResult(0));
},
};
});
services.AddMvc();
services
.AddAuthorization(options =>
{
options.AddPolicy(PolicyNames.MustBeInAdminGroup, policy =>
{
var authorizedAdminUsers = Configuration["AuthorizedAdminUsers"];
policy.Requirements.Add(new AzureActiveDirectoryGroupRequirement(authorizedAdminUsers));
});
});
services.AddSingleton <IAuthorizationHandler, AzureActiveDirectoryGroupHandler>();
//if (CurrentEnvironment.IsDevelopment())
//{
// services.AddSingleton<IAuthorizationHandler, DevelopmentOnlyNoAuthDirectoryGroupHandler>();
//}
//else
//{
// services.AddSingleton<IAuthorizationHandler, AzureActiveDirectoryGroupHandler>();
//}
services.AddScoped <DatasetSearchService>();
services.AddScoped <UserDataSearchService>();
services.AddScoped <DatasetStorageService>();
services.AddScoped <AppInsightsService>();
services.AddScoped <UserDataStorageService>();
services.AddScoped <LicenseStorageService>();
services.AddScoped <SasTokenService>();
services.AddScoped <ValidationService>();
services.AddScoped <ApplicationJobs>();
// In production, the Angular files will be served from this directory
services.AddSpaStaticFiles(configuration =>
{
configuration.RootPath = "ui-app";
});
// Add Swagger generator
if (Configuration.GetValue <bool>("Application:EnableSwagger"))
{
services.AddSwaggerGen(c =>
{
c.SwaggerDoc("v1", new Swashbuckle.AspNetCore.Swagger.Info
{
Title = "MSR ODR Admin API",
Version = "v1"
});
});
}
}
/// <summary>
/// Adds the runtime services to the instance.
/// </summary>
/// <param name="services">The services.</param>
public void ConfigureServices(IServiceCollection services)
{
services.AddSingleton <IHttpContextAccessor, HttpContextAccessor>();
services.AddSingleton <IConfiguration>(this.Configuration);
services.AddSingleton <ITelemetryInitializer, TelemetryUserAndSessionContext>();
services.AddApplicationInsightsTelemetry();
services.AddOptions();
services.Configure <IdentityProviderConfiguration>(options =>
{
Configuration.GetSection("azuread").Bind(options);
IdentityProviderConfiguration.Validate(options);
});
services.Configure <SearchConfiguration>(options =>
{
Configuration.GetSection("search").Bind(options);
SearchConfiguration.Validate(options);
});
services.Configure <CosmosConfiguration>(options =>
{
Configuration.GetSection("documents").Bind(options);
CosmosConfiguration.Validate(options);
});
services.Configure <StorageConfiguration>((config) =>
{
Configuration.GetSection("storage").Bind(config);
StorageConfiguration.Validate(config);
});
services.Configure <WebServerConfiguration>(options =>
{
Configuration.GetSection("webserver").Bind(options);
WebServerConfiguration.Validate(options);
});
services.Configure <BatchConfiguration>((config) =>
{
Configuration.GetSection("batch").Bind(config);
BatchConfiguration.Validate(config);
});
var armTemplatesMap = Configuration.GetSection("armTemplates").Get <ArmTemplatesMap>();
services.AddSingleton(armTemplatesMap);
var staticAssetsMap = Configuration.GetSection("staticAssets").Get <StaticAssetsMap>();
services.AddSingleton(staticAssetsMap);
services.AddMemoryCache();
services.AddCors(options =>
{
options.AddPolicy("DefaultPolicy",
builder => builder.AllowAnyOrigin()
.WithMethods("GET", "POST", "PUT", "DELETE")
.AllowAnyHeader()
.AllowCredentials());
});
services.AddResponseCompression(opt =>
{
opt.EnableForHttps = true;
});
services.AddMvc()
.AddMvcOptions(options =>
{
options.Filters.Add(new TelemetryExceptionFilter(new LoggerFactory()));
})
.AddJsonOptions(options =>
{
options.SerializerSettings.Converters.Add(new StringEnumConverter
{
CamelCaseText = true
});
});
services.AddScoped <DatasetSearchService>();
services.AddScoped <FileSearchService>();
services.AddScoped <DatasetStorageService>();
services.AddScoped <DatasetOwnersService>();
services.AddScoped <DatasetEditStorageService>();
services.AddScoped <UserDataStorageService>();
services.AddScoped <FileStorageService>();
services.AddScoped <LicenseStorageService>();
services.AddScoped <ValidationService>();
services.AddScoped <SasTokenService>();
services.AddScoped <GenerateFilePreview>();
services.AddScoped <CurrentUserService>();
services.AddScoped <ApplicationJobs>();
if (this.UseSwagger)
{
services.UseSwagger(this.Configuration);
}
services
.AddAuthentication(options =>
{
options.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme;
options.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme;
})
.AddJwtBearer(options =>
{
var tenantName = Configuration["AzureAD:Tenant"].Split('.').First();
var policyName = Configuration["AzureAD:Policy"];
var audience = Configuration["AzureAD:Audience"];
options.MetadataAddress = $"https://{tenantName}.b2clogin.com/{tenantName}.onmicrosoft.com/{policyName}/v2.0/.well-known/openid-configuration";
options.Audience = audience;
options.Events = new JwtBearerEvents
{
OnAuthenticationFailed = context =>
{
var ctx = context;
return(Task.FromResult(0));
},
};
});
}
