Platform Integration

public class Startup
{
    ...
    public void ConfigureServices(IServiceCollection services)
    {
        if (!ConfigurationIsLocalOrDev())
        {
            var azureAdConfiguration = _configuration
                .GetSection("AzureAd")
                .Get<AzureActiveDirectoryConfiguration>();

            var policies = new Dictionary<string, string>
            {
                {PolicyNames.Default, RoleNames.Default}
            };

            services.AddAuthentication(azureAdConfiguration, policies);
        }

        services
            .AddMvc(o =>
            {
                o.Conventions.Add(new ApiExplorerGroupPerVersionConvention());
            }).SetCompatibilityVersion(CompatibilityVersion.Version_3_0)
            .AddJsonOptions(options =>
            {
                options.JsonSerializerOptions.Converters.Add(new JsonStringEnumConverter());
            });
    }
    ...
    public void Configure(IApplicationBuilder app, IWebHostEnvironment env, IIndexBuilder indexBuilder, ILogger<Startup> logger)
    {
        ...
        app.UseAuthentication();
        ...
    }
    ...
}

public class InternalApiClient<T> : ApiClient<T>, IInternalApiClient<T> where T : IInternalApiConfiguration
{
    private readonly IAzureClientCredentialHelper _azureClientCredentialHelper;

    public InternalApiClient(
        IHttpClientFactory httpClientFactory,
        T apiConfiguration,
        IWebHostEnvironment hostingEnvironment,
        IAzureClientCredentialHelper azureClientCredentialHelper) : base(httpClientFactory, apiConfiguration, hostingEnvironment)
    {
        _azureClientCredentialHelper = azureClientCredentialHelper;
    }

    protected override async Task AddAuthenticationHeader()
    {
        if (!HostingEnvironment.IsDevelopment())
        {
            var accessToken = await _azureClientCredentialHelper.GetAccessTokenAsync(Configuration.Identifier);
            HttpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", accessToken);
        }
    }
    ...
}

public AppDataContext()
{
}

public AppDataContext(DbContextOptions options) : base(options)
{
}

public AppDataContext(IOptions<AppConfiguration> config, DbContextOptions options, AzureServiceTokenProvider azureServiceTokenProvider) :base(options)
{
    _configuration = config.Value;
    _azureServiceTokenProvider = azureServiceTokenProvider;
}  

protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
{
    if (_configuration == null || _azureServiceTokenProvider == null)
    {
        return;
    }
    
    var connection = new SqlConnection
    {
        ConnectionString = _configuration.ConnectionString,
        AccessToken = _azureServiceTokenProvider.GetAccessTokenAsync(AzureResource).Result,
    };
}

public static class AddDatabaseExtension
{
    public static void AddDatabaseRegistration(this IServiceCollection services, AppConfiguration config, string environmentName)
    {
        if (environmentName.Equals("DEV", StringComparison.CurrentCultureIgnoreCase))
        {
            services.AddDbContext<AppDataContext>(options => options.UseInMemoryDatabase("SFA.DAS.App"), ServiceLifetime.Transient);
        }
        else if (environmentName.Equals("LOCAL", StringComparison.CurrentCultureIgnoreCase))
        {
            services.AddDbContext<AppDataContext>(options=>options.UseSqlServer(config.ConnectionString),ServiceLifetime.Transient);
        }
        else
        {
            services.AddSingleton(new AzureServiceTokenProvider());
            services.AddDbContext<AppDataContext>(ServiceLifetime.Transient);    
        }

        services.AddTransient<IAppDataContext, AppDataContext>(provider => provider.GetService<AppDataContext>());
        services.AddTransient(provider => new Lazy<AppDataContext>(provider.GetService<AppDataContext>()));
    }
}

private readonly IDbConnection _connection;

public AppDataContext()
{
}

public AppDataContext(IDbConnection connection, DbContextOptions<AssessorDbContext> options)
    : base(options)
{
    _connection = connection;
}

protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
{
    optionsBuilder.UseSqlServer(_connection as DbConnection, options =>
         options.EnableRetryOnFailure(3));
}

public static class DatabaseExtensions
{
    private const string AzureResource = "https://database.windows.net/";

    public static void AddDatabaseRegistration(this ConfigurationExpression config, string environment, string sqlConnectionString)
    {
        config.For<IDbConnection>().Use($"Build IDbConnection", c => {
            var azureServiceTokenProvider = new AzureServiceTokenProvider();
            return environment.Equals("LOCAL", StringComparison.CurrentCultureIgnoreCase)
                ? new SqlConnection(sqlConnectionString)
                : new SqlConnection
                {
                    ConnectionString = sqlConnectionString,
                    AccessToken = azureServiceTokenProvider.GetAccessTokenAsync(AzureResource).Result
                };
        });
            
        var option = new DbContextOptionsBuilder<AppDataContext>();
        config.For<AppDataContext>().Use(c => new AppDataContext(c.GetInstance<IDbConnection>(), option.Options));
    }
}

using Microsoft.AspNetCore.DataProtection;
using Microsoft.AspNetCore.Hosting;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using SFA.DAS.AppName.Configuration;
using StackExchange.Redis;

namespace SFA.DAS.AppName.Web.Startup
{
    public static class DataProtectionStartupExtensions
    {
        public static IServiceCollection AddDataProtection(this IServiceCollection services, IConfiguration configuration, IHostingEnvironment environment)
        {
            if (!environment.IsDevelopment())
            {
                var redisConfiguration = configuration.GetSection(ConfigurationKeys.ConnectionStrings)
                    .Get<AppNameSettings>();

                if (redisConfiguration != null)
                {
                    var redisConnectionString = redisConfiguration.RedisConnectionString;
                    var dataProtectionKeysDatabase = redisConfiguration.DataProtectionKeysDatabase;

                    var redis = ConnectionMultiplexer
                        .Connect($"{redisConnectionString},{dataProtectionKeysDatabase}");

                    services.AddDataProtection()
                        .SetApplicationName("RepositoryName")
                        .PersistKeysToStackExchangeRedis(redis, "DataProtection-Keys");
                }
            }
            return services;
        }
    }
}

public void ConfigureServices(IServiceCollection services)
{
    services.AddHealthChecks()
        //add health checks appropriate to the application here
        .AddDbContextCheck<ApplicationDataContext>();
        .AddCheck<NServiceBusHealthCheck>("Service Bus Health Check")
        .AddCheck<ApiHealthCheck>("Check the health of some API");
}

public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
    app.UseHealthChecks("/ping", new HealthCheckOptions
    {
        //By returning false to the Predicate option we ensure that none of the health checks registered in ConfigureServices are ran for this endpoint
        Predicate = (_) => false,
        ResponseWriter = (context, report) =>
        {
            context.Response.ContentType = "application/json";
            return context.Response.WriteAsync("");
        }
    });

    app.UseHealthChecks("/health", new HealthCheckOptions
    {
        //configuration for a more complex response
    });
}