public void ValidateUserPassword(TenantUser user)
{
if (user.Password.Length < 10)
{
throw new TenantException(ExceptionCode.PasswordLenghtIncorrect.CodeToString(), ExceptionCode.PasswordLenghtIncorrect, user.TenantUId, user.Password);
}
}
public async Task <IActionResult> ExternalLoginConfirmation(ExternalLoginConfirmationViewModel model, string returnUrl = null)
{
if (ModelState.IsValid)
{
// Get the information about the user from the external login provider
var info = await _signInManager.GetExternalLoginInfoAsync();
if (info == null)
{
return(View("ExternalLoginFailure"));
}
var user = new TenantUser {
UserName = model.Email, Email = model.Email
};
var result = await _userManager.CreateAsync(user);
if (result.Succeeded)
{
result = await _userManager.AddLoginAsync(user, info);
if (result.Succeeded)
{
await _signInManager.SignInAsync(user, isPersistent : false);
_logger.LogInformation(6, "User created an account using {Name} provider.", info.LoginProvider);
return(RedirectToLocal(returnUrl));
}
}
AddErrors(result);
}
ViewData["ReturnUrl"] = returnUrl;
return(View(model));
}
public string Create(TenantUser user, TenantSettings settings, string tenantCode)
{
var key = Encoding.ASCII.GetBytes(settings.TokenSecret);
var tokenHandler = new JwtSecurityTokenHandler();
var claims = new List <Claim>
{
new Claim(JwtRegisteredClaimNames.Sub, user.UserGuid.ToString()),
new Claim(JwtRegisteredClaimNames.Jti, Guid.NewGuid().ToString()),
new Claim(JwtRegisteredClaimNames.Email, user.Email),
new Claim(CustomClaims.Name, user.DisplayName),
new Claim(CustomClaims.Avatar, user.ImageUrl),
new Claim(CustomClaims.Tenant, tenantCode),
};
var roleClaims = GetRoleClaims(user);
claims.AddRange(roleClaims);
var tokenDescriptor = new SecurityTokenDescriptor
{
Subject = new ClaimsIdentity(claims),
SigningCredentials =
new SigningCredentials(new SymmetricSecurityKey(key), SecurityAlgorithms.HmacSha256Signature),
Expires = DateTime.Now.AddMinutes(settings.TokenExpirationInMinutes),
Issuer = _tokenConfiguration.Issuer,
};
var jwt = tokenHandler.CreateJwtSecurityToken(tokenDescriptor);
jwt.Header.Add(JwtHeaderParameterNames.Kid, tenantCode);
return(tokenHandler.WriteToken(jwt));
}
public JsonRpcResponseData ChangePassword(TenantUser payload, ApiAuthorization authorization)
{
SetupAuth();
IsValidRequest(authorization.AppId, authorization.ApiKey);
var apiController = new ControllerService();
try
{
var username = apiController.ChangePassword(payload);
return(new JsonRpcResponseData
{
Message = $"Password for {username} changed",
Status = JsonRpcResponseData.OK,
Data = new
{
Username = username,
payload.Password
}
});
}
catch (System.Exception ex)
{
throw HandleException(ex);
}
}
public async Task AddAsync(TenantUser tenantUser, CancellationToken cancellationToken = default)
{
await toolShedContext.TenantUserSet
.AddAsync(tenantUser);
await toolShedContext.SaveChangesAsync(cancellationToken);
}
public async Task <IActionResult> Login(string returnUrl = null)
{
// Clear the existing external cookie to ensure a clean login process
await HttpContext.SignOutAsync(IdentityConstants.ExternalScheme);
//Add default admin if its not there
var tenant = _dbContext.Tenants.FirstOrDefault();
if (_dbContext.Users.Count() == 0)
{
var user = new TenantUser {
Email = "*****@*****.**", UserName = "******", EmailConfirmed = true, NormalizedEmail = "*****@*****.**", TenantId = tenant.TenantId
};
var result = await _userManager.CreateAsync(user, "@dminL0cked!!");
if (result.Succeeded)
{
await _userManager.AddClaimAsync(user, new Claim("tenant_id", tenant.TenantId));
await _userManager.AddClaimAsync(user, new Claim("role", "CentralAdmin"));
await _userManager.AddToRoleAsync(user, "CentralAdmin");
}
}
ViewData["ReturnUrl"] = returnUrl;
return(View());
}
public string CreateUser(TenantUser tenant)
{
var tenantNode = TenantHelper.GetCurrentTenantHome(ConnectorContext.ContentService, tenant.TenantUId.ToString());
var group = userGroupService.GetUserGroup(tenant.Group);
userGroupService.CreateUser(tenant);
return(tenant.AssignedUmbracoUserId.ToString());
}
public CreateQuestionCmd(string title, string body, string tag, int tenantId, Guid userId, TenantUser tenantUser)
{
Title = title;
Body = body;
Tag = tag;
TenantId = tenantId;
UserId = userId;
TenantUser = tenantUser;
}
public Address(
TenantUser tenantUser,
TenantChannel tenantChannel,
TenantKey tenantKey)
{
TenantUser = tenantUser;
TenantChannel = tenantChannel;
TenantKey = tenantKey;
}
public void ValidateUser(TenantUser user)
{
var u = userService.GetByUsername(user.Username);
if (user.Password.Length < 10)
{
throw new TenantException(ExceptionCode.PasswordLenghtIncorrect.CodeToString(), ExceptionCode.PasswordLenghtIncorrect, user.TenantUId, user.Password);
}
}
public async Task AddTenantAsync_Object()
{
var tenantUser = new TenantUser
{
TenantId = tenantId,
UserId = userId
};
await tenantUserRepository.AddAsync(tenantUser);
}
public QuestPublished(string title, string body, string tag, int tenantId, Guid userId, TenantUser user, bool isPublished)
{
Title = title;
Body = body;
Tag = tag;
TenantId = tenantId;
UserId = userId;
User = user;
IsPublished = isPublished;
}
public async Task DeleteTenantAsync(Guid tenantId, Guid userId, CancellationToken cancellationToken = default)
{
var tenantUser = new TenantUser
{
TenantId = tenantId,
UserId = userId
};
toolShedContext.Remove(tenantUser);
await toolShedContext.SaveChangesAsync(cancellationToken);
}
public async Task AddAsync(Guid tenantId, Guid userId, CancellationToken cancellationToken = default)
{
var tenantUser = new TenantUser
{
TenantId = tenantId,
UserId = userId
};
await toolShedContext.TenantUserSet
.AddAsync(tenantUser);
await toolShedContext.SaveChangesAsync(cancellationToken);
}
public int RenameMediaHome(TenantData tenant, TenantUser tenantUser)
{
var home = TenantHelper.GetCurrentTenantHome(ConnectorContext.ContentService, tenant.TenantUId.ToString());
if (home == null)
{
throw new TenantException(ExceptionCode.TenantNotFound.CodeToString(), ExceptionCode.TenantNotFound, tenant.TenantUId);
}
IMedia mediaHome = null;
IReadOnlyUserGroup group = null;
if (tenantUser != null)
{
var uService = ConnectorContext.UserService;
var user = uService.GetByUsername(tenantUser.Username);
group = user.Groups.ToList()[0];
mediaHome = mediaService.GetById(group.StartMediaId.Value);
}
else
{
mediaHome = mediaService.GetByLevel(1).SingleOrDefault(x => x.Name.Contains(tenant.Name));
}
if (mediaHome == null)
{
string mediaId = group?.StartMediaId.Value.ToString() ?? tenant.Name;
//string mediaId = group?.StartMediaId.Value.ToString() ?? tenant.BrandName;
throw new TenantException(ExceptionCode.MediaNodeDoesNotExist.CodeToString(), ExceptionCode.MediaNodeDoesNotExist, tenant.TenantUId, mediaId);
}
try
{
if (!mediaHome.Name.Equals(tenant.Name))
{
mediaHome.Name = tenant.Name;
//mediaHome.Name = tenant.BrandName;
mediaService.Save(mediaHome);
ConnectorContext.AuditService.Add(AuditType.Save, -1, mediaHome.Id, "Media Folder", $"Media home for {tenant.TenantUId} has been renamed");
}
return(mediaHome.Id);
}
catch (System.Exception ex)
{
logger.Error(typeof(HomeMediaNode), ex.Message);
logger.Error(typeof(HomeMediaNode), ex.StackTrace);
throw;
}
}
private async Task <ClaimsPrincipal> GetClaims(TenantUser user)
{
if (user == null)
{
throw new ArgumentNullException(nameof(user));
}
var id = new ClaimsIdentity();
id.AddClaim(new Claim(JwtClaimTypes.PreferredUserName, user.UserName));
id.AddClaims(await _tenantUserManager.GetClaimsAsync(user));
return(new ClaimsPrincipal(id));
}
public async Task GetProfileDataAsync(ProfileDataRequestContext context)
{
var userId = Guid.Parse(context.Subject.Claims.Single(x => x.Type == "sub").Value);
var user = await userManager.Users.Include(x => x.TenantUsers)
.ThenInclude(x => x.TenantUserRoles)
.Include(x => x.TenantUsers)
.ThenInclude(x => x.Tenant)
.Include(x => x.DefaultTenant)
.SingleAsync(x => x.Id == userId);
var tenantId = context.ValidatedRequest.Raw.Get(Constants.ClaimTypes.TenantId);
context.IssuedClaims.Add(new Claim(Constants.ClaimTypes.GlobalRole, user.GlobalRole.ToString()));
if (user.GlobalRole == GlobalRoleType.TenantUser)
{
TenantUser tenantUser = null;
if (string.IsNullOrEmpty(tenantId))
{
if (user.DefaultTenantId.HasValue)
{
tenantUser = user.TenantUsers.Single(x => x.TenantId == user.DefaultTenantId.Value);
}
else if (user.TenantUsers.Any())
{
tenantUser = user.TenantUsers.First();
}
context.IssuedClaims.Add(new Claim(Constants.ClaimTypes.TenantId, tenantUser.TenantId.ToString()));
context.IssuedClaims.AddRange(tenantUser.TenantUserRoles
.Select(x => new Claim(Constants.ClaimTypes.TenantRoles, x.TenantRole.ToString())));
}
else
{
var tenantIdGuid = Guid.Parse(tenantId);
tenantUser = user.TenantUsers.SingleOrDefault(x => x.TenantId == tenantIdGuid);
if (tenantUser != null)
{
context.IssuedClaims.Add(new Claim(Constants.ClaimTypes.TenantId, tenantId));
context.IssuedClaims.AddRange(tenantUser.TenantUserRoles.Select(x => new Claim(Constants.ClaimTypes.TenantRoles, x.TenantRole.ToString())));
}
}
user.DefaultTenant = tenantUser.Tenant;
await dbContext.SaveChangesAsync();
}
}
public void CreateUser(TenantUser tenantUser)
{
if (!string.IsNullOrEmpty(tenantUser.Password))
{
ValidateUserPassword(tenantUser);
}
var user = userService.GetByUsername(tenantUser.Username);
var group = userService.GetUserGroupByAlias("managers");
if (group == null)
{
throw new TenantException(ExceptionCode.GroupDoesNotExist.CodeToString(), ExceptionCode.GroupDoesNotExist, tenantUser.TenantUId, tenantUser.Name);
}
try
{
if (user == null)
{
user = userService.CreateUserWithIdentity(tenantUser.Username, tenantUser.Email);
user.Name = tenantUser.Name;
}
var startContentIds = user.StartContentIds;
Array.Resize(ref startContentIds, startContentIds.Length + 1);
startContentIds[startContentIds.GetUpperBound(0)] = tenantUser.StartContentIds[0];
user.StartContentIds = startContentIds;
var startMediaIds = user.StartMediaIds;
Array.Resize(ref startMediaIds, startMediaIds.Length + 1);
startMediaIds[startMediaIds.GetUpperBound(0)] = tenantUser.StartMediaIds[0];
user.StartMediaIds = startMediaIds;
user.AddGroup(group.ToReadOnlyGroup());
if (!string.IsNullOrEmpty(tenantUser.Password))
{
user.RawPasswordValue = (Membership.Providers["UsersMembershipProvider"] as UsersMembershipProvider)?.HashPasswordForStorage(tenantUser.Password);
}
userService.Save(user);
ConnectorContext.AuditService.Add(AuditType.New, -1, user.Id, "User", $"User for {tenantUser.Username} has been created");
tenantUser.AssignedUmbracoUserId = user.Id;
}
catch (Exception ex)
{
logger.Error(typeof(UserGroupService), ex.Message);
logger.Error(typeof(UserGroupService), ex.StackTrace);
throw;
}
}
public async Task <TenantUser> GetUserProfile()
{
TenantUser model = await _httpContext.Session.GetAsync <TenantUser>(SessionKeys.UserProfile);
if (model != null)
{
return(model);
}
model = _dbContext.Users.FirstOrDefault(u => u.UserName.Equals(LoggedInUsername));
if (model != null)
{
await _httpContext.Session.SetAsync <TenantUser>(SessionKeys.UserProfile, model);
}
return(model);
}
private IEnumerable <Claim> GetRoleClaims(TenantUser user)
{
var roleClaims = new List <Claim>
{
new Claim(ClaimsIdentity.DefaultRoleClaimType, UserRoles.User)
};
if (user.IsAdmin)
{
roleClaims.Add(new Claim(ClaimsIdentity.DefaultRoleClaimType, UserRoles.Admin));
}
if (user.IsOwner)
{
roleClaims.Add(new Claim(ClaimsIdentity.DefaultRoleClaimType, UserRoles.TenantOwner));
}
return(roleClaims);
}
/// <summary>
/// 为租户关联用户
/// </summary>
/// <param name="id">租户ID</param>
/// <param name="tenant">租户-用户关系实体数据</param>
/// <returns>Result</returns>
public Result <object> addTenantUser(string id, TenantUser tenant)
{
if (!verify())
{
return(result);
}
var data = getData(tenant.tenantId);
var user = DbHelper.find <Application>(tenant.userId);
if (data == null || user == null)
{
return(result.notFound());
}
tenant.id = Util.newId();
tenant.creatorId = userId;
tenant.createTime = DateTime.Now;
return(DbHelper.insert(tenant) ? result.success(user) : result.dataBaseError());
}
public void UpdateUser(TenantUser tenantUser)
{
var user = userService.GetByUsername(tenantUser.Username);
if (user == null)
{
throw new TenantException(ExceptionCode.UsernameDoesNotExist.CodeToString(), ExceptionCode.UsernameDoesNotExist, tenantUser.Username);
}
if (!string.IsNullOrEmpty(tenantUser.Password))
{
ValidateUserPassword(tenantUser);
}
try
{
user.Name = tenantUser.Name ?? user.Name;
user.Email = tenantUser.Email ?? user.Email;
if (!string.IsNullOrEmpty(tenantUser.Password))
{
user.RawPasswordValue = (Membership.Providers["UsersMembershipProvider"] as UsersMembershipProvider)?.HashPasswordForStorage(tenantUser.Password);
}
userService.Save(user);
if (!string.IsNullOrEmpty(tenantUser.Group) && !user.Groups.ToArray()[0].Name.Equals(tenantUser.Group))
{
AssignUserToGroup(user.Username, tenantUser.Group);
}
ConnectorContext.AuditService.Add(AuditType.Save, -1, user.Id, "User", $"User {user.Username} has been edited");
tenantUser.AssignedUmbracoUserId = user.Id;
}
catch (Exception ex)
{
logger.Error(typeof(UserGroupService), ex.Message);
logger.Error(typeof(UserGroupService), ex.StackTrace);
throw;
}
}
private async Task <TenantUser> CreateUserAsync(string userName, string password, string fullName, string email, string phoneNumber, string[] roles)
{
TenantUser applicationUser = new TenantUser
{
UserName = userName,
FullName = fullName,
Email = email,
PhoneNumber = phoneNumber,
EmailConfirmed = true,
IsEnabled = true
};
var result = await _accountManager.CreateUserAsync(applicationUser, roles, password);
if (!result.Succeeded)
{
throw new Exception($"Seeding \"{userName}\" user failed. Errors: {string.Join(Environment.NewLine, result.Errors)}");
}
return(applicationUser);
}
public JsonRpcResponseData CreateUser(TenantUser payload, ApiAuthorization authorization)
{
SetupAuth();
IsValidRequest(authorization.AppId, authorization.ApiKey);
var apiController = new ControllerService();
try
{
var assignedUmbracoUserId = apiController.CreateUser(payload);
return(new JsonRpcResponseData
{
Message = "User created",
Status = JsonRpcResponseData.OK,
TenantUid = payload.TenantUId.ToString(),
Data = assignedUmbracoUserId
});
}
catch (System.Exception ex)
{
throw HandleException(ex);
}
}
public async Task <IActionResult> Register(RegisterViewModel model, string returnUrl = null)
{
ViewData["ReturnUrl"] = returnUrl;
if (ModelState.IsValid)
{
var user = new TenantUser
{
UserName = model.Email,
Email = model.Email,
TenantId = _currentTenant.TenantId,
Status = (int)TenantSubscription.Pro,
CreatedDate = DateTime.UtcNow,
LastUpdated = DateTime.UtcNow
};
var result = await _userManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
// For more information on how to enable account confirmation and password reset please visit https://go.microsoft.com/fwlink/?LinkID=532713
// Send an email with this link
//var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);
//var callbackUrl = Url.Action(nameof(ConfirmEmail), "Account", new { userId = user.Id, code = code }, protocol: HttpContext.Request.Scheme);
//await _emailSender.SendEmailAsync(model.Email, "Confirm your account",
// $"Please confirm your account by clicking this link: <a href='{callbackUrl}'>link</a>");
await _signInManager.SignInAsync(user, isPersistent : false);
_logger.LogInformation(3, "User created a new account with password.");
return(RedirectToLocal(returnUrl));
}
AddErrors(result);
}
// If we got this far, something failed, redisplay form
return(View(model));
}
/// <summary>
/// 根据对象实体数据新增一个用户
/// </summary>
/// <param name="user">用户对象</param>
/// <returns>Result</returns>
public Result <object> addUser(User user)
{
if (!verify("newUser"))
{
return(result);
}
if (user == null)
{
return(result.badRequest());
}
if (Core.isExisted(user))
{
return(result.accountExists());
}
user.id = Util.newId();
user.password = Util.hash("123456");
user.creatorId = userId;
user.createTime = DateTime.Now;
if (!DbHelper.insert(user))
{
return(result.dataBaseError());
}
var tu = new TenantUser
{
id = Util.newId(),
tenantId = tenantId,
userId = user.id,
creatorId = userId,
createTime = DateTime.Now
};
return(DbHelper.insert(tu) ? result.created(user) : result.dataBaseError());
}
public string ChangeUserPassword(TenantUser tenantUser)
{
var user = userService.GetByUsername(tenantUser.Username);
if (user == null)
{
throw new TenantException(ExceptionCode.UsernameDoesNotExist.CodeToString(), ExceptionCode.UsernameDoesNotExist, tenantUser.Username);
}
ValidateUserPassword(tenantUser);
try
{
user.RawPasswordValue = (Membership.Providers["UsersMembershipProvider"] as UsersMembershipProvider)?.HashPasswordForStorage(tenantUser.Password);
userService.Save(user);
ConnectorContext.AuditService.Add(AuditType.Save, -1, user.Id, "User", $"Password for {user.Id} has been changed");
return(tenantUser.Username);
}
catch (Exception ex)
{
logger.Error(typeof(UserGroupService), ex.Message);
logger.Error(typeof(UserGroupService), ex.StackTrace);
throw;
}
}
public IActionResult SaveTenantUser([FromBody] TenantUser model)
{
string password = CreatePassword(6);
string url = $"{_configuration["FrontEndUrl"]}";
if (model == null)
{
return(BadRequest("Error, Make sure tenant form is complete!"));
}
ApplicationUser userChecker = _contextUsers.Users.FirstOrDefault(id => id.Email == model.Email);
if (userChecker != null)
{
return(BadRequest("Error, User with this email already exists. Contact administrator."));
}
try
{
ApplicationUser applicationUser = new ApplicationUser();
applicationUser.FirstName = model.FirstName;
applicationUser.LastName = model.LastName;
applicationUser.Email = model.Email;
applicationUser.UserName = model.Email;
applicationUser.Reference = model.Reference;
applicationUser.DateStamp = DateTime.Now;
applicationUser.TenantId = model.TenantId;
IdentityResult result = _userManager.CreateAsync(applicationUser, password).Result;
_context.SaveChanges();
_userManager.AddToRoleAsync(applicationUser, "ADMINISTRATOR");
_contextUsers.SaveChanges();
var smtp = new SmtpClient
{
Host = "smtp.gmail.com",
Port = 587,
EnableSsl = true,
DeliveryMethod = SmtpDeliveryMethod.Network,
Credentials = new NetworkCredential("*****@*****.**", "StratisQ@2020"),
Timeout = 20000
};
using (var message = new MailMessage("*****@*****.**", model.Email)
{
IsBodyHtml = true,
Subject = "StratisQ: " + _contextUsers.Tenants.FirstOrDefault(id => id.TenantId == model.TenantId).TenantKey + " Account",
Body = "<html><body>Hi " + applicationUser.FirstName + ", <br/>Your account has created sucessfully: <br/><br/>Link: " + url + "<br/><br/>Username: "******"<br/>Password: "******" <br/><br/><br/><p>StratisQ</p></body></html></body></html>"
})
{
smtp.Send(message);
}
return(Ok());
}
catch (Exception Ex)
{
return(BadRequest("Something bad happened! " + Ex.Message));
}
}
public HomeController(IOptions <TenantUser> opSettings, IOptions <AppSettings> appSettings)
{
_options = opSettings.Value;
_appSettings = appSettings.Value;
}
private async Task <RequestResult <AuthorizationData> > GetAuthorizationDataResult(TenantContext requestTenant,
TenantUser user)
{
var tenantSettings = await _tenantsRepository.GetTenantSettings(requestTenant.TenantId);
var token = _jwtTokenFactory.Create(user, tenantSettings, requestTenant.TenantCode);
return(RequestResult <AuthorizationData>
.Success(
new AuthorizationData
{
Token = token,
User = _mapper.Map <UserDto>(user),
}));
}
