Startup- Multi-Tenant Claim Based Identity for ASP.NET Core - Part 6 of 10

---

This part 5 of 10 part series which outlines my implementation of Multi-Tenant Claim Based Identity. For more details please see my index post.

http://www.spaprogrammer.com/2015/11/multi-tenant-claim-based-identity.html

---

As you know Startup is used for configure the request pipeline that handles all requests made to the application. I am using this Startup to configure the following:

•  Configure Identity Framework
• Dependency Injection of Identity classes and my classes
• Automapper configuration (optional)

Here are the different sections of Startup. I have included only relevant code.

Startup Constructor

This is standard code. In this I am saving the connection string in a global variable so that I can later use it.

public Startup(IHostingEnvironment env)

{

    // Set up configuration sources.

    var builder = new ConfigurationBuilder()

        .SetBasePath(env.ContentRootPath)

        .AddJsonFile("appsettings.json")

        .AddJsonFile($"appsettings.{env.EnvironmentName}.json", optional: true);

    builder.AddEnvironmentVariables();

    this.Configuration = builder.Build();

    // saving the site connection string

    SiteSettings.ConnectionString = this.Configuration.GetConnectionString("MegaMine");

}

ConfigureServices

In this method I am configuring the following services

• Configuring Entity Framework
•  Configure ASP.NET Identity system
• Configure MVC
• Configure our Authorization filter
• Dependency injection configuration for classes related to security
• Automapper configuration for classes related to security

Here is the relevant code in this method

public void ConfigureServices(IServiceCollection services)

{

    // configuring Entity Framework

    services.AddEntityFrameworkSqlServer()

    .AddDbContext<SecurityDbContext>(options =>

    {

        options.UseSqlServer(SiteSettings.ConnectionString);

    });

   

    // Configuring ASP.NET Identity

    services.AddIdentity<ApplicationUser, ApplicationRole>()

    .AddEntityFrameworkStores<SecurityDbContext>()

    .AddDefaultTokenProviders();

    services.AddMvc()

    .AddMvcOptions(options =>

    {

        options.Filters.Add(new NTAuthorizeFilter()); // Adding our Authorization filter

    })

    .AddJsonOptions(options =>

    {

        options.SerializerSettings.ContractResolver = new CamelCasePropertyNamesContractResolver();

        options.SerializerSettings.DateTimeZoneHandling = DateTimeZoneHandling.Local;

        options.SerializerSettings.DateFormatHandling = DateFormatHandling.IsoDateFormat;

    });

    // dependency injection

    services.AddScoped<SignInManager<ApplicationUser>, ApplicationSignInManager>();

    services.AddTransient<AccountDomain>();

    services.AddTransient<SecurityRepository>();

    // Automapper configurations

    Mapper.Initialize(x =>

    {

        x.AddProfile<SecurityMappingProfile>();

    });

}

Configure

In this Configure method, apart from standard request processing configuration, I added the following configurations:

• Enable ASP.NET Identity
• Enable my own middleware which stores User information in a custom request context

Here is the code for this configure method

public void Configure(IApplicationBuilder app, IHostingEnvironment env)

{

    // Middleware for storing context for the request

    app.UseContextMiddleware();

    // To enable deliverying static content

    app.UseStaticFiles();

    // Enabling ASP.NET Identity

    app.UseIdentity();

    // Custom middleware to store user details

    app.UseProfileMiddleware();

    // Enabling MVC

    app.UseMvc(routes =>

    {

        routes.MapRoute(

            name: "webapi",

            template: "api/{controller}/{action}/{id?}",

            defaults: new { controller = "Home", action = "Index" });

        routes.MapRoute(

            name: "error",

            template: "Error",

            defaults: new { controller = "Home", action = "Error" });

        routes.MapRoute(

            name: "default",

            template: "{controller}/{action}",

            defaults: new { controller = "Home", action = "Index" });

    });

}

With the above Configurations in the Startup class, the application is configure to utilize Multi-Tenant Claim Based Identity.