/// <summary>
/// 将种子数据初始化到数据库
/// </summary>
protected override void SyncToDatabase(Role[] entities, IServiceProvider provider)
{
if (entities.Length == 0)
{
return;
}
RoleManager <Role> roleManager = provider.GetService <RoleManager <Role> >();
foreach (Role role in entities)
{
if (roleManager.Roles.Any(ExistingExpression(role)))
{
continue;
}
IdentityResult result = roleManager.CreateAsync(role).Result;
if (!result.Succeeded)
{
throw new OsharpException($"进行角色种子数据“{role.Name}”同步时出错：{result.ErrorMessage()}");
}
}
}
public async Task <ActionResult> ResetPassword([FromBody] ResetPasswordVM model)
{
// This is called when the user clicks "forgot my password", and then submits an email address
if (!ModelState.IsValid)
{
return(BadRequest("There is something wrong with the request payload")); // TODO: Return friendlier validation errors
}
try
{
var user = await _userManager.FindByIdAsync(model.UserId);
if (user == null)
{
// This is only possible if the user somehow changes the password reset confirmation link before clicking
return(BadRequest("The supplied user id could not be found"));
}
// Reset the password by utilizing the injected user manager
IdentityResult result = await _userManager.ResetPasswordAsync(user, model.PasswordResetToken, model.NewPassword);
if (!result.Succeeded)
{
return(BadRequest(result.ErrorMessage("Could not reset password")));
}
else
{
// If the password reset succeeds, automatically log the user in
var tokenResponse = CreateJwtToken(user.Email);
return(Created("", tokenResponse));
}
}
catch (Exception ex)
{
_logger.LogError(ex.StackTrace);
return(BadRequest(ex.Message));
}
}
/// <summary>
/// 将种子数据初始化到数据库
/// </summary>
/// <param name="entities"></param>
protected override void SyncToDatabase(Role[] entities)
{
if (entities?.Length > 0)
{
_rootProvider.BeginUnitOfWorkTransaction(provider =>
{
RoleManager <Role> roleManager = provider.GetService <RoleManager <Role> >();
foreach (Role role in entities)
{
if (roleManager.Roles.Any(ExistingExpression(role)))
{
continue;
}
IdentityResult result = roleManager.CreateAsync(role).Result;
if (!result.Succeeded)
{
throw new OsharpException($"进行角色种子数据“{role.Name}”同步时出错：{result.ErrorMessage()}");
}
}
},
true);
}
}
public async Task <ActionResult> ChangePassword([FromBody] ChangePasswordVM model)
{
// This is called when the user presses the confirm email link that is sent to his/her inbox
if (!ModelState.IsValid)
{
return(BadRequest("There is something wrong with the request payload")); // TODO: Return friendlier validation errors
}
try
{
// Get the user
var username = User.UserName();
var user = await _userManager.FindByNameAsync(username);
if (user == null)
{
// This is only possible if the admin deletes the user while the user is logged in
return(BadRequest("Your account was deleted"));
}
// Rely on the injected user manager to validate the token and confirm the user's email
IdentityResult result = await _userManager.ChangePasswordAsync(user, model.CurrentPassword, model.NewPassword);
if (!result.Succeeded)
{
return(BadRequest(result.ErrorMessage("Could not change password")));
}
// All good
return(Ok());
}
catch (Exception ex)
{
_logger.LogError(ex.StackTrace);
return(BadRequest(ex.Message));
}
}
public async Task <ActionResult> ConfirmEmail([FromBody] ConfirmEmailVM model)
{
// This is called when the user presses the confirm email link that is sent to his/her inbox
if (!ModelState.IsValid)
{
return(BadRequest("There is something wrong with the request payload")); // TODO: Return friendlier validation errors
}
try
{
// Get the user
var user = await _userManager.FindByIdAsync(model.UserId);
if (user == null)
{
// This is only possible if the user changes the email confirmation link before clicking
return(BadRequest("The supplied user id could not be found"));
}
// Rely on the injected user manager to validate the token and confirm the user's email
IdentityResult result = await _userManager.ConfirmEmailAsync(user, model.EmailConfirmationToken);
if (!result.Succeeded)
{
return(BadRequest(result.ErrorMessage("Could not confirm email")));
}
// All good
return(Ok());
}
catch (Exception ex)
{
_logger.LogError(ex.StackTrace);
return(BadRequest(ex.Message));
}
}
public async Task <ActionResult <UserVM> > Post(UserVM model)
{
if (!ModelState.IsValid)
{
return(BadRequest("There is something wrong with the request payload")); // TODO: Return friendlier validation errors
}
try
{
if (string.IsNullOrWhiteSpace(model.Id)) // Insert logic
{
User user = new User
{
FullName = model.FullName,
UserName = model.Email,
Email = model.Email,
Role = model.Role
};
// Create the user object in the identity store
IdentityResult result = await _userManager.CreateAsync(user);
if (!result.Succeeded)
{
return(BadRequest(result.ErrorMessage("Could not create user")));
}
// Rely on the injected user manager to generate the email-confirmation and password-reset tokens
string emailConfirmationToken = await _userManager.GenerateEmailConfirmationTokenAsync(user);
string passwordResetToken = await _userManager.GeneratePasswordResetTokenAsync(user);
// In a bigger app, the API should not know where the SPA lives
// But this is fine and convenient for now
string uri = $"https://{Request.Host}/{Request.PathBase}confirm-email";
uri = QueryHelpers.AddQueryString(uri, "userId", user.Id);
uri = QueryHelpers.AddQueryString(uri, "emailConfirmationToken", emailConfirmationToken);
uri = QueryHelpers.AddQueryString(uri, "passwordResetToken", passwordResetToken);
string currentUser = User.UserName();
// Prepare the email content
string htmlEmail = Util.Util.BSharpEmailTemplate(
message: $"{currentUser} is inviting you to join! Let's start by confirming your email:",
hrefToAction: uri,
hrefLabel: "Confirm My Email");
// Send the email using injected sender
await _emailSender.SendEmail(
destinationEmailAddress : model.Email,
subject : "Invitation to join BSharp ERP",
htmlEmail : htmlEmail);
// Map the newly created User object, and return that
var resultModel = _mapper.Map <User, UserVM>(user);
var resourceUrl = $"{Url.Action(nameof(Get), nameof(UsersController))}/{resultModel.Id}"; // TODO fix this bug
return(Created(resourceUrl, resultModel));
}
else // Update logic
{
User user = await _userManager.FindByIdAsync(model.Id);
if (user == null)
{
return(NotFound($"Could not find a user with an Id of '{model.Id}'"));
}
// Here we ensure that there is at least one administrator in the system at all times
if (model.Email == User.UserName() && model.Role != Roles.Administrator)
{
return(BadRequest("You cannot remove the administrator role from yourself"));
}
// Update the updatable properties and ignore the rest
user.FullName = model.FullName;
user.Role = model.Role;
// Update in identity store using the userManager
IdentityResult result = await _userManager.UpdateAsync(user);
if (!result.Succeeded)
{
return(BadRequest(result.ErrorMessage("Could not update user")));
}
// Finally return the result
var resultModel = _mapper.Map <User, UserVM>(user);
return(Ok(resultModel));
}
}
catch (Exception ex)
{
_logger.LogError(ex.StackTrace);
return(BadRequest(ex.Message));
}
}
/// <summary>
/// 将种子数据初始化到数据库
/// </summary>
/// <param name="entities"></param>
protected override void SyncToDatabase(UserRole[] entities)
{
_rootProvider.BeginUnitOfWorkTransaction(provider =>
{
UserManager <User> userManager = provider.GetService <UserManager <User> >();
RoleManager <Role> roleManager = provider.GetService <RoleManager <Role> >();
User user = userManager.Users.OrderBy(p => p.CreatedTime).FirstOrDefault();
List <string> roles = roleManager.Roles.Select(p => p.Name).ToList();
if (user != null && roles.Any())
{
var userRoles = userManager.GetRolesAsync(user).Result;
var newRoles = roles.Except(userRoles).ToList();
if (newRoles.Any())
{
IdentityResult result = userManager.AddToRolesAsync(user, newRoles).Result;
if (!result.Succeeded)
{
throw new HybridException($"进行用户角色种子数据“{user.UserName}”同步时出错：{result.ErrorMessage()}");
}
}
}
},
true);
}
/// <summary>
/// 将种子数据初始化到数据库
/// </summary>
/// <param name="entities"></param>
protected override void SyncToDatabase(User[] entities)
{
if (entities.Any())
{
_rootProvider.BeginUnitOfWorkTransaction(provider =>
{
UserManager <User> userManager = provider.GetService <UserManager <User> >();
foreach (User user in entities)
{
if (userManager.Users.Any(ExistingExpression(user)))
{
continue;
}
IdentityResult result = userManager.CreateAsync(user).Result;
if (!result.Succeeded)
{
throw new HybridException($"进行用户种子数据“{user.UserName}”同步时出错：{result.ErrorMessage()}");
}
}
},
true);
}
}
