Example explanation of using Identity instead of using dapper to store data under net core 2.0
- 2021-10-16 01:25:14
- OfStack
Preface,
I haven't written a blog for many days. In view of the fact that I want to write a blog again when I am idle and bored, I should also make a note for myself. After all these days, my writing is still so bad, so please understand a lot. Today, I will mainly share the actual situation encountered under. net core 2.0 under 1. When using webapi, identity is used for user authentication. The official document is to use EF to store data instead of dapper, but I don't want to use EF because of my personal preference. So I went tossing and turning. Instead, use dapper for data storage. So I have the following experience.
1. Using the Identity service
First find the class file Startup. cs to find the ConfigureServices method
services.AddIdentity<ApplicationUser, ApplicationRole>().AddDefaultTokenProviders();// Add Identity
services.AddTransient<IUserStore<ApplicationUser>, CustomUserStore>();
services.AddTransient<IRoleStore<ApplicationRole>, CustomRoleStore>();
string connectionString = Configuration.GetConnectionString("SqlConnectionStr");
services.AddTransient<SqlConnection>(e => new SqlConnection(connectionString));
services.AddTransient<DapperUsersTable>();Then add the following code before app. UseMvc () of the Configure method, which was app. UseIdentity () at net core 1.0 and has now been deprecated to the following method.
// Use authentication
app.UseAuthentication();Here, ApplicationUser is a user model defined by user. Specifically, IdentityUser inherits some attributes of IdentityUser
public class ApplicationUser :IdentityUser
{
public string AuthenticationType { get; set; }
public bool IsAuthenticated { get; set; }
public string Name { get; set; }
}Here, CustomUserStore is a class that provides user-defined methods for all data operations. It needs to inherit three interfaces: IUserStore, IUserPasswordStore and IUserEmailStore
IUserStore < TUser > Interface is the only interface that must be implemented in the user store. It defines methods for creating, updating, deleting, and retrieving users.
IUserPasswordStore < TUser > Interface defines methods that are implemented to hold hashed passwords. It contains methods for getting and setting a hashed password and a method for indicating whether the user has set a password.
IUserEmailStore < TUser > Interface defines a method implemented to store a user's e-mail address. It contains methods for getting and setting the e-mail address and whether to confirm the e-mail.
This is a little different from the implementation interface of. net core 1.0. You need to implement IUserEmailStore more than once to avoid reporting errors
The specific code is as follows. For your reference.
CustomUserStore
using Microsoft.AspNetCore.Identity;
using System;
using System.Threading.Tasks;
using System.Threading;
namespace YepMarsCRM.Web.CustomProvider
{
/// <summary>
/// This store is only partially implemented. It supports user creation and find methods.
/// </summary>
public class CustomUserStore : IUserStore<ApplicationUser>,
IUserPasswordStore<ApplicationUser>,
IUserEmailStore<ApplicationUser>
{
private readonly DapperUsersTable _usersTable;
public CustomUserStore(DapperUsersTable usersTable)
{
_usersTable = usersTable;
}
#region createuser
public async Task<IdentityResult> CreateAsync(ApplicationUser user,
CancellationToken cancellationToken = default(CancellationToken))
{
cancellationToken.ThrowIfCancellationRequested();
if (user == null) throw new ArgumentNullException(nameof(user));
return await _usersTable.CreateAsync(user);
}
#endregion
public async Task<IdentityResult> DeleteAsync(ApplicationUser user,
CancellationToken cancellationToken = default(CancellationToken))
{
cancellationToken.ThrowIfCancellationRequested();
if (user == null) throw new ArgumentNullException(nameof(user));
return await _usersTable.DeleteAsync(user);
}
public void Dispose()
{
}
public Task<ApplicationUser> FindByEmailAsync(string normalizedEmail, CancellationToken cancellationToken)
{
throw new NotImplementedException();
}
public async Task<ApplicationUser> FindByIdAsync(string userId,
CancellationToken cancellationToken = default(CancellationToken))
{
cancellationToken.ThrowIfCancellationRequested();
if (userId == null) throw new ArgumentNullException(nameof(userId));
Guid idGuid;
if (!Guid.TryParse(userId, out idGuid))
{
throw new ArgumentException("Not a valid Guid id", nameof(userId));
}
return await _usersTable.FindByIdAsync(idGuid);
}
public async Task<ApplicationUser> FindByNameAsync(string userName,
CancellationToken cancellationToken = default(CancellationToken))
{
cancellationToken.ThrowIfCancellationRequested();
if (userName == null) throw new ArgumentNullException(nameof(userName));
return await _usersTable.FindByNameAsync(userName);
}
public Task<string> GetEmailAsync(ApplicationUser user, CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
if (user == null) throw new ArgumentNullException(nameof(user));
return Task.FromResult(user.Email);
}
public Task<bool> GetEmailConfirmedAsync(ApplicationUser user, CancellationToken cancellationToken)
{
throw new NotImplementedException();
}
public Task<string> GetNormalizedEmailAsync(ApplicationUser user, CancellationToken cancellationToken)
{
throw new NotImplementedException();
}
public Task<string> GetNormalizedUserNameAsync(ApplicationUser user, CancellationToken cancellationToken)
{
throw new NotImplementedException();
}
public Task<string> GetPasswordHashAsync(ApplicationUser user, CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
if (user == null) throw new ArgumentNullException(nameof(user));
return Task.FromResult(user.PasswordHash);
}
public Task<string> GetUserIdAsync(ApplicationUser user, CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
if (user == null) throw new ArgumentNullException(nameof(user));
return Task.FromResult(user.Id.ToString());
}
public Task<string> GetUserNameAsync(ApplicationUser user, CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
if (user == null) throw new ArgumentNullException(nameof(user));
return Task.FromResult(user.UserName);
}
public Task<bool> HasPasswordAsync(ApplicationUser user, CancellationToken cancellationToken)
{
throw new NotImplementedException();
}
public Task SetEmailAsync(ApplicationUser user, string email, CancellationToken cancellationToken)
{
throw new NotImplementedException();
}
public Task SetEmailConfirmedAsync(ApplicationUser user, bool confirmed, CancellationToken cancellationToken)
{
throw new NotImplementedException();
}
public Task SetNormalizedEmailAsync(ApplicationUser user, string normalizedEmail, CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
if (user == null) throw new ArgumentNullException(nameof(user));
if (normalizedEmail == null) throw new ArgumentNullException(nameof(normalizedEmail));
user.NormalizedEmail = normalizedEmail;
return Task.FromResult<object>(null);
}
public Task SetNormalizedUserNameAsync(ApplicationUser user, string normalizedName, CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
if (user == null) throw new ArgumentNullException(nameof(user));
if (normalizedName == null) throw new ArgumentNullException(nameof(normalizedName));
user.NormalizedUserName = normalizedName;
return Task.FromResult<object>(null);
}
public Task SetPasswordHashAsync(ApplicationUser user, string passwordHash, CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
if (user == null) throw new ArgumentNullException(nameof(user));
if (passwordHash == null) throw new ArgumentNullException(nameof(passwordHash));
user.PasswordHash = passwordHash;
return Task.FromResult<object>(null);
}
public Task SetUserNameAsync(ApplicationUser user, string userName, CancellationToken cancellationToken)
{
throw new NotImplementedException();
}
public Task<IdentityResult> UpdateAsync(ApplicationUser user, CancellationToken cancellationToken)
{
return _usersTable.UpdateAsync(user);
}
}
}
2. Use dapper for data storage
Then use dapper for data storage. The methods of this class are all called through CustomUserStore to operate the database. The specific code is as follows. According to the actual user table to operate dapper.
DapperUsersTable
using Microsoft.AspNetCore.Identity;
using System.Threading.Tasks;
using System.Threading;
using System.Data.SqlClient;
using System;
using Dapper;
using YepMarsCRM.Enterprise.DataBase.Model;
using YepMarsCRM.Enterprise.DataBase.Data;
namespace YepMarsCRM.Web.CustomProvider
{
public class DapperUsersTable
{
private readonly SqlConnection _connection;
private readonly Sys_AccountData _sys_AccountData;
public DapperUsersTable(SqlConnection connection)
{
_connection = connection;
_sys_AccountData = new Sys_AccountData();
}
private Sys_Account ApplicationUserToAccount(ApplicationUser user)
{
return new Sys_Account
{
Id = user.Id,
UserName = user.UserName,
PasswordHash = user.PasswordHash,
Email = user.Email,
EmailConfirmed = user.EmailConfirmed,
PhoneNumber = user.PhoneNumber,
PhoneNumberConfirmed = user.PhoneNumberConfirmed,
LockoutEnd = user.LockoutEnd?.DateTime,
LockoutEnabled = user.LockoutEnabled,
AccessFailedCount = user.AccessFailedCount,
};
}
#region createuser
public async Task<IdentityResult> CreateAsync(ApplicationUser user)
{
int rows = await _sys_AccountData.InsertAsync(ApplicationUserToAccount(user));
if (rows > 0)
{
return IdentityResult.Success;
}
return IdentityResult.Failed(new IdentityError { Description = $"Could not insert user {user.Email}." });
}
#endregion
public async Task<IdentityResult> DeleteAsync(ApplicationUser user)
{
//string sql = "DELETE FROM Sys_Account WHERE Id = @Id";
//int rows = await _connection.ExecuteAsync(sql, new { user.Id });
int rows = await _sys_AccountData.DeleteForPKAsync(ApplicationUserToAccount(user));
if (rows > 0)
{
return IdentityResult.Success;
}
return IdentityResult.Failed(new IdentityError { Description = $"Could not delete user {user.Email}." });
}
public async Task<ApplicationUser> FindByIdAsync(Guid userId)
{
string sql = "SELECT * FROM Sys_Account WHERE Id = @Id;";
return await _connection.QuerySingleOrDefaultAsync<ApplicationUser>(sql, new
{
Id = userId
});
}
public async Task<ApplicationUser> FindByNameAsync(string userName)
{
string sql = "SELECT * FROM Sys_Account WHERE UserName = @UserName;";
return await _connection.QuerySingleOrDefaultAsync<ApplicationUser>(sql, new
{
UserName = userName
});
//var user = new ApplicationUser() { UserName = userName, Email = userName, EmailConfirmed = false };
//user.PasswordHash = new PasswordHasher<ApplicationUser>().HashPassword(user, "test");
//return await Task.FromResult(user);
}
public async Task<IdentityResult> UpdateAsync(ApplicationUser applicationUser)
{
var user = ApplicationUserToAccount(applicationUser);
var result = await _sys_AccountData.UpdateForPKAsync(user);
if (result > 0)
{
return IdentityResult.Success;
}
return IdentityResult.Failed(new IdentityError { Description = $"Could not update user {user.Email}." });
}
}
}
3. Use UserManager, SignInManager to validate actions
Create a new AccountController controller and get the dependency injection objects UserManager and SignInManager in the constructor as follows:
[Authorize]
public class AccountController : Controller
{
private readonly UserManager<ApplicationUser> _userManager;
private readonly SignInManager<ApplicationUser> _signInManager;
private readonly ILogger _logger;
public AccountController(UserManager<ApplicationUser> userManager,
SignInManager<ApplicationUser> signInManager,
ILoggerFactory loggerFactory)
{
_userManager = userManager;
_signInManager = signInManager;
_logger = loggerFactory.CreateLogger<AccountController>();
}
}SignInManager is an API that provides user login and logout, and UserManager is an API that provides user management.
Next to achieve a simple login and logout.
/// <summary>
/// Login
/// </summary>
[HttpPost]
[AllowAnonymous]
public async Task<IActionResult> Login(ReqLoginModel req)
{
var json = new JsonResultModel<object>();
if (ModelState.IsValid)
{
var result = await _signInManager.PasswordSignInAsync(req.UserName, req.Password, isPersistent: true, lockoutOnFailure: false);
if (result.Succeeded)
{
json.code = "200";
json.message = " Login Successful ";
}
else
{
json.code = "400";
json.message = " Login failed ";
}
if (result.IsLockedOut)
{
json.code = "401";
json.message = " The account password has been incorrect 3 Time, the account is locked, please 30 Try again in minutes ";
}
}
else
{
var errorMessges = ModelState.GetErrorMessage();
json.code = "403";
json.message = string.Join(" , ", errorMessges);
}
return json.ToJsonResult();
}
/// <summary>
/// Logout
/// </summary>
/// <returns></returns>
[HttpPost]
public async Task<IActionResult> LogOut()
{await _signInManager.SignOutAsync();
var json = new JsonResultModel<object>()
{
code = "200",
data = null,
message = " Logout Successful ",
remark = string.Empty
};
return json.ToJsonResult();
}4. Use Identity configuration
Add to the ConfigureServices method
services.Configure<IdentityOptions>(options =>
{
// Password configuration
options.Password.RequireDigit = false;// Do you need numbers (0-9).
options.Password.RequiredLength = 6;// Set the password length to a minimum of 6
options.Password.RequireNonAlphanumeric = false;// Whether it contains non-alphanumeric characters.
options.Password.RequireUppercase = false;// Do you need capital letters (A-Z).
options.Password.RequireLowercase = false;// Do you need lowercase letters (a-z).
//options.Password.RequiredUniqueChars = 6;
// Locking settings
options.Lockout.DefaultLockoutTimeSpan = TimeSpan.FromMinutes(30);// Account lockout duration 30 Minutes
options.Lockout.MaxFailedAccessAttempts = 3;//10 Failed attempt to lock the account
//options.Lockout.AllowedForNewUsers = true;
// User settings
options.User.RequireUniqueEmail = false; // Whether or not Email Address must be only 1
});
services.ConfigureApplicationCookie(options =>
{
// Cookie settings
options.Cookie.HttpOnly = true;
//options.Cookie.Expiration = TimeSpan.FromMinutes(30);//30 Minutes
options.Cookie.Expiration = TimeSpan.FromHours(12);//12 Hours
options.LoginPath = "/api/Account/NotLogin"; // If the LoginPath is not set here, ASP.NET Core will default to /Account/Login
//options.LogoutPath = "/api/Account/Logout"; // If the LogoutPath is not set here, ASP.NET Core will default to /Account/Logout
//options.AccessDeniedPath = "/Account/AccessDenied"; // If the AccessDeniedPath is not set here, ASP.NET Core will default to /Account/AccessDenied
options.SlidingExpiration = true;
});5. Others
In the process of implementation, I encountered 1 minor situation. For example, Identity does not take effect. Because it was not used before app. UseMvc (). If you are not logged in, it will cause a jump. Later, after looking at the source code of. net core Identity, I found that if it is ajax, it will not jump back to the status code page of 401.
Then the password encryption of Idenetity is encrypted by PasswordHasher. If you want to use your own encryption method. You can only change the original way by inheriting the interface. And then roughly talk about this. Think of it as taking notes for yourself. If you don't do well, please give more advice. A lot of understanding. Thank you