Decoupling ASP.NET Identity from the Core Domain Models - Onion Architecture

|▌冷眼眸甩不掉的悲伤 提交于 2020-07-04 06:29:11

问题


I am using this sample project (https://github.com/imranbaloch/ASPNETIdentityWithOnion) as my application architecture, in this sample the core is completly decoplied from the infrastrure including the identity framework.

In this sample the author has used the adapter pattern to decouple core identity classes (IdentityUser, IdentityRole ... ) and provide classes like them in the Core layer.

Now the issue in this sample project is that the Domain model (Product, Images) are not linked with the dummy classes (AppUser, ApplicationRole, AppliationUserRoles, ...) that mimics the Identity ones.

Then I have modified the code to added the reference to AppUser

public sealed class Image : BaseEntity
{
    public Image()
    {
        Products = new HashSet<Product>();
    }

    public string Path { get; set; }

    public AppUser AppUser { get; set; } // The  Added Reference ...

    public ICollection<Product> Products { get; set; }
}

If I put the "AppUser" navigation property inside the "Image" class, the created database will have FOUR new tables other than the default FIVE tables of the identity framework.

Onion Database Problem with Identity Tables

I need to merge these tables into the default ones. how ?

EDIT:

This is the Identity Models that resides in the Data Layer (which I can not reference from the core).

public class ApplicationIdentityUser :
    IdentityUser<int, ApplicationIdentityUserLogin, ApplicationIdentityUserRole, ApplicationIdentityUserClaim>, IDomainUser {

    public ApplicationIdentityUser()
        : base() {
        Images = new HashSet<Image>();
    }

    public string Name { get; set; }
    public virtual ICollection<Image> Images { get; set; }
}


public class ApplicationIdentityRole : IdentityRole<int, ApplicationIdentityUserRole>
{
    public ApplicationIdentityRole(){}

    public ApplicationIdentityRole(string name){Name = name;}
}

public class ApplicationIdentityUserRole : IdentityUserRole<int> {}

public class ApplicationIdentityUserClaim : IdentityUserClaim<int>{}

public class ApplicationIdentityUserLogin : IdentityUserLogin<int>{}

Also this is my model builder in the OnModelCreating method:

  modelBuilder.Entity<Image>()
            .Property(e => e.Id)
            .HasDatabaseGeneratedOption(DatabaseGeneratedOption.Identity);
        modelBuilder.Entity<Image>()
            .HasMany(e => e.Products)
            .WithRequired(e => e.Image)
            .WillCascadeOnDelete(false);
        modelBuilder.Entity<ApplicationIdentityUser>()
             .Property(e => e.Id)
             .HasDatabaseGeneratedOption(DatabaseGeneratedOption.Identity);
        modelBuilder.Entity<ApplicationIdentityRole>()
            .Property(e => e.Id)
            .HasDatabaseGeneratedOption(DatabaseGeneratedOption.Identity);
        modelBuilder.Entity<ApplicationIdentityUserClaim>()
             .Property(e => e.Id)
             .HasDatabaseGeneratedOption(DatabaseGeneratedOption.Identity);

回答1:


Okay I have solved this by doing the following:

  1. Include a dependency in your Core to Microsoft.AspNet.Identity.Core
  2. Implement IUser interface on the AppUser (this interface come from Microsoft.AspNet.Identity.Core).
  3. Implement IRole interface on the ApplicationRole.
  4. Completely get rid of the IdentityDbContext and inherit only from DbContext.
  5. Implement your own version of IUserStore* providing your AppUser
  6. Implement your own version of IRoleStore providing your ApplicationRole.

I know that making a dependency on the Microsoft.AspNet.Identity.Core sounds Odd, but we only need the interface IUser which is basically considered as Core Domain Model for your application too.

The Ultimate Idea here is to GET RID OF THE Microsoft.AspNet.Identity.EntityFramework completely.

Interested devs can +1 this, so I can upload a full working sample on GitHub.




回答2:


I'm using this framework, no need to have a link in every entity To get the userID reference, i added a property UserIDBy in BaseEntity so every entity will inherit it.

public abstract class BaseEntity
{
    public int Id { get; set; }
    public string UserIDBy { get; set; }
}

Next, in the web project, there is already an extension method called GetUserId(this IIdentity identity) in IdentityExtensions.cs, so to stock the UserIDBy in every Create and Edit action result:

Create Action Result :

 // POST: /Region/Create
    [HttpPost]
    public async Task<ActionResult> Create([Bind(Include = "RegionName")] Region region)
    {
        if (ModelState.IsValid)
        {
            // TODO: Add insert logic here
            var id = User.Identity.GetUserId();
            region.UserIDBy = id.ToString(); 

            await _regionService.AddAsync(region);
            return Json(new { success = true });
        }

        return PartialView("_Create", region);
    }

Edit Action Result :

 //// POST: /Region/Edit/5
    [HttpPost]
    [ValidateAntiForgeryToken]
    public ActionResult Edit([Bind(Include = "id,RegionName")] Region region)
    {
        if (ModelState.IsValid)
        {
            var id = User.Identity.GetUserId();
            region.UserIDBy = id.ToString(); 
            _regionService.Update(region);
            return Json(new { success = true });
        }
        return PartialView("_Edit", region);
    }

Dont forget to import it :

using Myapp.Web.Extensions;



回答3:


Just stumbled upon this, having the same problem.

The problem with the marked answer is that it still references Microsoft.AspNet, which makes it rough for future .NET Core-plans.

The main problem is really with the general attempt to build in an authentication feature in the core, which defeats the purpose.

Consider letting the built in functionality for web authentication and authorization remain in the web layer, and reference a Core user object (UserProfile?) that represents the Core needs. This would also simplify switching to another authentication method (AD).

Depending on your preference, you can then reference the Core.UserProfile from your AspNetUser to avoid multiple SQL-calls, or simply make sure to have a good cache policy on the Core.UserProfile operations.

This allows you to control your authentication methods separate from your Core model.



来源:https://stackoverflow.com/questions/26580209/decoupling-asp-net-identity-from-the-core-domain-models-onion-architecture

易学教程内所有资源均来自网络或用户发布的内容,如有违反法律规定的内容欢迎反馈
该文章没有解决你所遇到的问题?点击提问,说说你的问题,让更多的人一起探讨吧!