public async Task<bool> Save(ISiteUser user, CancellationToken cancellationToken = default(CancellationToken))
{
if (user == null) { return false; }
if (user.SiteId == -1) { throw new ArgumentException("user must have a siteid"); }
if (user.SiteGuid == Guid.Empty) { throw new ArgumentException("user must have a siteguid"); }
SiteUser siteUser = SiteUser.FromISiteUser(user);
if(siteUser.UserId == -1)
{
siteUser.UserId = 0; //EF needs it to be zero in order to generate
dbContext.Users.Add(siteUser);
}
else
{
bool tracking = dbContext.ChangeTracker.Entries<SiteUser>().Any(x => x.Entity.UserId == siteUser.UserId);
if (!tracking)
{
dbContext.Users.Update(siteUser);
}
}
int rowsAffected = await dbContext.SaveChangesAsync(cancellationToken);
if(user.UserId == -1)
{
user.UserId = siteUser.UserId;
user.UserGuid = siteUser.UserGuid;
}
return rowsAffected > 0;
}
public async Task Create(
ISiteUser user,
CancellationToken cancellationToken = default(CancellationToken))
{
ThrowIfDisposed();
cancellationToken.ThrowIfCancellationRequested();
if (user == null) { throw new ArgumentException("user can't be null"); }
if (user.SiteId == Guid.Empty) { throw new ArgumentException("user must have a siteid"); }
if (user.Id == Guid.Empty) { throw new ArgumentException("user must have a non empty guid for id"); }
SiteUser siteUser = SiteUser.FromISiteUser(user);
dbContext.Users.Add(siteUser);
int rowsAffected =
await dbContext.SaveChangesAsync(cancellationToken)
.ConfigureAwait(false)
;
//if (user.UserGuid == Guid.Empty)
//{
// //user.UserId = siteUser.UserId;
// user.UserGuid = siteUser.UserGuid;
//}
//return rowsAffected > 0;
}
public async Task Create(
ISiteUser user,
CancellationToken cancellationToken = default(CancellationToken))
{
cancellationToken.ThrowIfCancellationRequested();
if (user == null)
{
throw new ArgumentException("user can't be null");
}
if (user.SiteId == Guid.Empty)
{
throw new ArgumentException("user must have a siteid");
}
if (user.Id == Guid.Empty)
{
throw new ArgumentException("user must have a non empty guid for id");
}
SiteUser siteUser = SiteUser.FromISiteUser(user);
using (var dbContext = _contextFactory.CreateContext())
{
dbContext.Users.Add(siteUser);
int rowsAffected =
await dbContext.SaveChangesAsync(cancellationToken)
.ConfigureAwait(false)
;
}
}
//[Authorize(Roles = "Admins")]
public async Task <ActionResult> UserEdit(
int userId,
Guid?siteGuid
)
{
ISiteSettings selectedSite;
// only server admin site can edit other sites settings
if ((siteGuid.HasValue) && (siteGuid.Value != Guid.Empty) && (siteGuid.Value != siteManager.CurrentSite.SiteGuid) && (siteManager.CurrentSite.IsServerAdminSite))
{
selectedSite = await siteManager.Fetch(siteGuid.Value);
ViewData["Title"] = string.Format(CultureInfo.CurrentUICulture, "{0} - Manage User", selectedSite.SiteName);
}
else
{
selectedSite = siteManager.CurrentSite;
ViewData["Title"] = "Manage User";
}
EditUserViewModel model = new EditUserViewModel();
model.SiteGuid = selectedSite.SiteGuid;
ISiteUser user = await UserManager.Fetch(selectedSite.SiteId, userId);
if (user != null)
{
model.UserId = user.UserId;
model.UserGuid = user.UserGuid;
model.Email = user.Email;
model.FirstName = user.FirstName;
model.LastName = user.LastName;
model.LoginName = user.UserName;
model.DisplayName = user.DisplayName;
model.AccountApproved = user.AccountApproved;
model.Comment = user.Comment;
model.EmailConfirmed = user.EmailConfirmed;
model.IsLockedOut = user.IsLockedOut;
model.LastActivityDate = user.LastActivityDate;
model.LastLoginDate = user.LastLoginDate;
model.TimeZoneId = user.TimeZoneId;
if (user.DateOfBirth > DateTime.MinValue)
{
model.DateOfBirth = user.DateOfBirth;
}
NavigationNodeAdjuster currentCrumbAdjuster = new NavigationNodeAdjuster(Request.HttpContext);
currentCrumbAdjuster.KeyToAdjust = "UserEdit";
currentCrumbAdjuster.AdjustedText = user.DisplayName;
currentCrumbAdjuster.ViewFilterName = NamedNavigationFilters.Breadcrumbs; // this is default but showing here for readers of code
currentCrumbAdjuster.AddToContext();
}
return(View(model));
}
public async Task RemoveUserFromRole(ISiteUser user, ISiteRole role)
{
if (user == null)
{
throw new ArgumentNullException(nameof(user));
}
if (role == null)
{
throw new ArgumentNullException(nameof(role));
}
await _commands.RemoveUserFromRole(role.SiteId, role.Id, user.Id, CancellationToken);
user.RolesChanged = true;
await _commands.Update(user, CancellationToken);
foreach (var handler in _userRemovedFromRoleHandlers)
{
try
{
await handler.Handle(user, role);
}
catch (Exception ex)
{
_log.LogError($"{ex.Message}-{ex.StackTrace}");
}
}
}
//protected string projectId;
//private async Task EnsureProjectId()
//{
// if (string.IsNullOrEmpty(projectId))
// {
// projectId = await projectResolver.ResolveProjectId().ConfigureAwait(false);
// }
//}
#region User
public async Task Create(
ISiteUser user,
CancellationToken cancellationToken = default(CancellationToken))
{
if (user == null)
{
throw new ArgumentException("user cannot be null");
}
if (user.SiteId == Guid.Empty)
{
throw new ArgumentException("user must have a siteid");
}
if (user.Id == Guid.Empty)
{
throw new ArgumentException("user must have a non-empty id");
}
//await EnsureProjectId().ConfigureAwait(false);
var projectId = user.SiteId.ToString();
var siteUser = SiteUser.FromISiteUser(user);
await userCommands.CreateAsync(
projectId,
siteUser.Id.ToString(),
siteUser,
cancellationToken).ConfigureAwait(false);
}
public async Task Update(
ISiteUser user,
CancellationToken cancellationToken = default(CancellationToken))
{
ThrowIfDisposed();
cancellationToken.ThrowIfCancellationRequested();
if (user == null)
{
throw new ArgumentException("user can't be null");
}
if (user.SiteId == Guid.Empty)
{
throw new ArgumentException("user must have a siteguid");
}
if (user.Id == Guid.Empty)
{
throw new ArgumentException("user must have a non empty guid for id");
}
SiteUser siteUser = SiteUser.FromISiteUser(user);
bool tracking = dbContext.ChangeTracker.Entries <SiteUser>().Any(x => x.Entity.Id == siteUser.Id);
if (!tracking)
{
dbContext.Users.Update(siteUser);
}
int rowsAffected =
await dbContext.SaveChangesAsync(cancellationToken)
.ConfigureAwait(false)
;
}
public string GetNativeUserProperty(ISiteUser siteUser, string key)
{
switch (key)
{
case "FirstName":
return(siteUser.FirstName);
case "LastName":
return(siteUser.LastName);
case "DateOfBirth":
if (siteUser.DateOfBirth.HasValue)
{
return(siteUser.DateOfBirth.Value.ToString("d"));
}
return(null);
case "AuthorBio":
return(siteUser.AuthorBio);
case "Signature":
return(siteUser.Signature);
case "Gender":
return(siteUser.Gender);
case "AvatarUrl":
return(siteUser.AvatarUrl);
case "WebSiteUrl":
return(siteUser.WebSiteUrl);
}
return(null);
}
public async Task <bool> AddUserToRole(ISiteUser user, ISiteRole role)
{
if (user == null)
{
throw new ArgumentNullException(nameof(user));
}
if (role == null)
{
throw new ArgumentNullException(nameof(role));
}
if (role.SiteId != user.SiteId)
{
throw new ArgumentException("user and role must have the same siteid");
}
bool result = await userRepo.AddUserToRole(role.RoleId, role.RoleGuid, user.UserId, user.UserGuid);
if (result)
{
user.RolesChanged = true;
bool result2 = await userRepo.Save(user);
}
return(result);
}
public async Task<bool> Save(
ISiteUser user,
CancellationToken cancellationToken = default(CancellationToken))
{
if (user.SiteId == -1) { throw new ArgumentException("user must have a siteid"); }
if (user.SiteGuid == Guid.Empty) { throw new ArgumentException("user must have a siteguid"); }
cancellationToken.ThrowIfCancellationRequested();
if (user.UserId == -1)
{
user.UserGuid = Guid.NewGuid();
user.CreatedUtc = DateTime.UtcNow;
user.UserId = dbSiteUser.AddUser(
user.SiteGuid,
user.SiteId,
user.DisplayName,
user.UserName,
user.Email,
user.UserGuid,
user.CreatedUtc,
user.MustChangePwd,
user.FirstName,
user.LastName,
user.TimeZoneId,
user.DateOfBirth,
user.EmailConfirmed,
user.PasswordHash,
user.SecurityStamp,
user.PhoneNumber,
user.PhoneNumberConfirmed,
user.TwoFactorEnabled,
user.LockoutEndDateUtc,
user.AccountApproved,
user.IsLockedOut,
user.DisplayInMemberList,
user.WebSiteUrl,
user.Country,
user.State,
user.AvatarUrl,
user.Signature,
user.AuthorBio,
user.Comment,
user.NormalizedUserName,
user.NormalizedEmail,
user.CanAutoLockout
);
return user.UserId > -1;
}
else
{
return Update(user, cancellationToken);
}
}
public async Task <bool> Save(
ISiteUser user,
CancellationToken cancellationToken = default(CancellationToken))
{
if (user.SiteId == -1)
{
throw new ArgumentException("user must have a siteid");
}
if (user.SiteGuid == Guid.Empty)
{
throw new ArgumentException("user must have a siteguid");
}
cancellationToken.ThrowIfCancellationRequested();
if (user.UserId == -1)
{
user.UserGuid = Guid.NewGuid();
user.CreatedUtc = DateTime.UtcNow;
user.UserId = await dbSiteUser.AddUser(
user.SiteGuid,
user.SiteId,
user.DisplayName,
user.UserName,
user.Email,
user.UserGuid,
user.CreatedUtc,
user.MustChangePwd,
user.FirstName,
user.LastName,
user.TimeZoneId,
user.DateOfBirth,
user.EmailConfirmed,
user.PasswordHash,
user.SecurityStamp,
user.PhoneNumber,
user.PhoneNumberConfirmed,
user.TwoFactorEnabled,
user.LockoutEndDateUtc,
user.AccountApproved,
user.IsLockedOut,
user.DisplayInMemberList,
user.WebSiteUrl,
user.Country,
user.State,
user.AvatarUrl,
user.Signature,
user.AuthorBio,
user.Comment,
cancellationToken
);
return(user.UserId > -1);
}
else
{
return(await Update(user, cancellationToken));
}
}
public async Task AddUserToRole(ISiteUser user, ISiteRole role)
{
if (user == null)
{
throw new ArgumentNullException(nameof(user));
}
if (role == null)
{
throw new ArgumentNullException(nameof(role));
}
if (role.SiteId != user.SiteId)
{
throw new ArgumentException("user and role must have the same siteid");
}
await _commands.AddUserToRole(role.SiteId, role.Id, user.Id, CancellationToken);
user.RolesChanged = true;
await _commands.Update(user, CancellationToken);
foreach (var handler in _userAddedToRoleHandlers)
{
try
{
await handler.Handle(user, role);
}
catch (Exception ex)
{
_log.LogError($"{ex.Message}-{ex.StackTrace}");
}
}
}
public UserContext(ISiteUser user)
{
if (user == null)
{
throw new ArgumentNullException("you must pass in an implementation of ISiteUser");
}
this.user = user;
}
public static SiteUser FromISiteUser(ISiteUser user)
{
SiteUser u = new SiteUser();
u.AccountApproved = user.AccountApproved;
u.AuthorBio = user.AuthorBio;
u.AvatarUrl = user.AvatarUrl;
u.Comment = user.Comment;
u.Country = user.Country;
u.CreatedUtc = user.CreatedUtc;
u.DateOfBirth = user.DateOfBirth;
u.DisplayInMemberList = user.DisplayInMemberList;
u.DisplayName = user.DisplayName;
u.Email = user.Email;
u.EmailChangeGuid = user.EmailChangeGuid;
u.EmailConfirmed = user.EmailConfirmed;
u.FailedPasswordAnswerAttemptCount = user.FailedPasswordAnswerAttemptCount;
u.FailedPasswordAnswerAttemptWindowStart = user.FailedPasswordAnswerAttemptWindowStart;
u.FailedPasswordAttemptCount = user.FailedPasswordAttemptCount;
u.FailedPasswordAttemptWindowStart = user.FailedPasswordAttemptWindowStart;
u.FirstName = user.FirstName;
u.Gender = user.Gender;
//u.Id = user.Id;
u.IsDeleted = user.IsDeleted;
u.IsLockedOut = user.IsLockedOut;
u.LastActivityDate = user.LastActivityDate;
u.LastLockoutDate = user.LastLockoutDate;
u.LastLoginDate = user.LastLoginDate;
u.LastName = user.LastName;
u.LastPasswordChangedDate = user.LastPasswordChangedDate;
u.LockoutEndDateUtc = user.LockoutEndDateUtc;
u.LoweredEmail = user.LoweredEmail;
u.MustChangePwd = user.MustChangePwd;
u.NewEmail = user.NewEmail;
u.PasswordHash = user.PasswordHash;
u.PasswordResetGuid = user.PasswordResetGuid;
u.PhoneNumber = user.PhoneNumber;
u.PhoneNumberConfirmed = user.PhoneNumberConfirmed;
u.RegisterConfirmGuid = user.RegisterConfirmGuid;
u.RolesChanged = user.RolesChanged;
u.SecurityStamp = user.SecurityStamp;
u.Signature = user.Signature;
u.SiteGuid = user.SiteGuid;
u.SiteId = user.SiteId;
u.State = user.State;
u.TimeZoneId = user.TimeZoneId;
u.Trusted = user.Trusted;
u.TwoFactorEnabled = user.TwoFactorEnabled;
u.UserGuid = user.UserGuid;
u.UserId = user.UserId;
u.UserName = user.UserName;
u.WebSiteUrl = user.WebSiteUrl;
return(u);
}
public Task HandleUserEditPostSuccess(
ISiteContext site,
ISiteUser siteUser,
EditUserViewModel viewModel,
HttpContext httpContext,
CancellationToken cancellationToken = default(CancellationToken)
)
{
return(Task.CompletedTask);
}
public async Task <TUser> FindByNameAsync(string userName, CancellationToken cancellationToken)
{
if (debugLog)
{
log.LogInformation("FindByNameAsync");
}
cancellationToken.ThrowIfCancellationRequested();
ISiteUser siteUser = await repo.FetchByLoginName(siteSettings.SiteId, userName, true);
return((TUser)siteUser);
}
public async Task <TUser> FindByEmailAsync(string email, CancellationToken cancellationToken)
{
if (debugLog)
{
log.LogInformation("FindByEmailAsync");
}
cancellationToken.ThrowIfCancellationRequested();
ISiteUser siteUser = await repo.Fetch(siteSettings.SiteId, email);
return((TUser)siteUser);
}
public async Task<bool> Save(ISiteUser user)
{
if (user.SiteId == -1) { throw new ArgumentException("user must have a siteid"); }
if (user.SiteGuid == Guid.Empty) { throw new ArgumentException("user must have a siteguid"); }
if (user.UserId == -1)
{
user.UserGuid = Guid.NewGuid();
user.CreatedUtc = DateTime.UtcNow;
user.UserId = await dbSiteUser.AddUser(
user.SiteGuid,
user.SiteId,
user.DisplayName,
user.UserName,
user.Email,
user.UserGuid,
user.CreatedUtc,
user.MustChangePwd,
user.FirstName,
user.LastName,
user.TimeZoneId,
user.DateOfBirth,
user.EmailConfirmed,
user.PasswordHash,
user.SecurityStamp,
user.PhoneNumber,
user.PhoneNumberConfirmed,
user.TwoFactorEnabled,
user.LockoutEndDateUtc,
user.AccountApproved,
user.IsLockedOut,
user.DisplayInMemberList,
user.WebSiteUrl,
user.Country,
user.State,
user.AvatarUrl,
user.Signature,
user.AuthorBio,
user.Comment
);
}
return user.UserId > -1;
}
public async Task <TUser> FindByIdAsync(string userId, CancellationToken cancellationToken)
{
if (debugLog)
{
log.LogInformation("FindByIdAsync");
}
cancellationToken.ThrowIfCancellationRequested();
Guid userGuid = new Guid(userId);
ISiteUser siteUser = await repo.Fetch(siteSettings.SiteId, userGuid);
return((TUser)siteUser);
}
public async Task Update(
ISiteUser user,
CancellationToken cancellationToken = default(CancellationToken))
{
cancellationToken.ThrowIfCancellationRequested();
if (user == null)
{
throw new ArgumentException("user can't be null");
}
if (user.SiteId == Guid.Empty)
{
throw new ArgumentException("user must have a siteguid");
}
if (user.Id == Guid.Empty)
{
throw new ArgumentException("user must have a non empty guid for id");
}
SiteUser siteUser = SiteUser.FromISiteUser(user);
using (var dbContext = _contextFactory.CreateContext())
{
bool tracking = dbContext.ChangeTracker.Entries <SiteUser>().Any(x => x.Entity.Id == siteUser.Id);
if (!tracking)
{
dbContext.Users.Update(siteUser);
}
else
{
var tracked = dbContext.ChangeTracker.Entries <SiteUser>().FirstOrDefault(x => x.Entity.Id == siteUser.Id);
var s = tracked.State;
if (s == EntityState.Unchanged)
{
tracked.State = EntityState.Detached;
try
{
dbContext.Users.Update(siteUser);
}
catch (Exception)
{ }
}
}
int rowsAffected =
await dbContext.SaveChangesAsync(cancellationToken)
.ConfigureAwait(false)
;
}
}
//public async Task<bool> Delete(ISiteUser user)
//{
// bool result = await DeleteLoginsByUser(user.SiteId, user.Id);
// result = await DeleteClaimsByUser(user.SiteId, user.Id);
// result = await DeleteUserRoles(user.UserId);
// result = await dbSiteUser.DeleteUser(user.UserId);
// return result;
//}
public async Task <bool> Delete(int siteId, int userId, CancellationToken cancellationToken = default(CancellationToken))
{
cancellationToken.ThrowIfCancellationRequested();
ISiteUser user = await Fetch(siteId, userId);
if (user != null)
{
bool result = await DeleteLoginsByUser(user.SiteId, user.Id);
result = await DeleteClaimsByUser(user.SiteId, user.Id);
result = await DeleteUserRoles(user.UserId);
}
return(await dbSiteUser.DeleteUser(userId));
}
private async Task <bool> Update(
ISiteUser user,
CancellationToken cancellationToken = default(CancellationToken))
{
cancellationToken.ThrowIfCancellationRequested();
if (string.IsNullOrEmpty(user.LoweredEmail))
{
user.LoweredEmail = user.Email.ToLowerInvariant();
}
return(await dbSiteUser.UpdateUser(
user.UserId,
user.DisplayName,
user.UserName,
user.Email,
user.Gender,
user.AccountApproved,
user.Trusted,
user.DisplayInMemberList,
user.WebSiteUrl,
user.Country,
user.State,
user.AvatarUrl,
user.Signature,
user.LoweredEmail,
user.Comment,
user.MustChangePwd,
user.FirstName,
user.LastName,
user.TimeZoneId,
user.NewEmail,
user.EmailChangeGuid,
user.PasswordResetGuid,
user.RolesChanged,
user.AuthorBio,
user.DateOfBirth,
user.EmailConfirmed,
user.PasswordHash,
user.SecurityStamp,
user.PhoneNumber,
user.PhoneNumberConfirmed,
user.TwoFactorEnabled,
user.LockoutEndDateUtc,
user.IsLockedOut,
cancellationToken
));
}
public async Task <bool> LoginSuccess(ISiteUser siteUser)
{
SiteUser resultSiteUser;
using (var httpClient = new HttpClient())
{
using (var response = await httpClient.GetAsync(apiUrl))
{
string apiResponse = await response.Content.ReadAsStringAsync();
resultSiteUser = JsonConvert.DeserializeObject <SiteUser>(apiResponse);
}
}
return(siteUser.UserName == resultSiteUser.UserName && siteUser.Password == resultSiteUser.Password);
}
public async Task RemoveUserFromRole(ISiteUser user, ISiteRole role)
{
if (user == null)
{
throw new ArgumentNullException(nameof(user));
}
if (role == null)
{
throw new ArgumentNullException(nameof(role));
}
await commands.RemoveUserFromRole(role.Id, user.Id, CancellationToken);
user.RolesChanged = true;
await commands.Update(user, CancellationToken);
}
public void UpdateNativeUserProperty(ISiteUser siteUser, string key, string value)
{
switch (key)
{
case "FirstName":
siteUser.FirstName = value;
break;
case "LastName":
siteUser.LastName = value;
break;
case "DisplayName":
siteUser.DisplayName = value;
break;
case "DateOfBirth":
DateTime dob;
var dobParsed = DateTime.TryParse(value, out dob);
if (!dobParsed)
{
siteUser.DateOfBirth = dob.Date;
}
break;
case "AuthorBio":
siteUser.AuthorBio = value;
break;
case "Signature":
siteUser.Signature = value;
break;
case "Gender":
siteUser.Gender = value;
break;
case "AvatarUrl":
siteUser.AvatarUrl = value;
break;
case "WebSiteUrl":
siteUser.WebSiteUrl = value;
break;
}
}
public async Task <TUser> FindByEmailAsync(string email, CancellationToken cancellationToken)
{
ThrowIfDisposed();
cancellationToken.ThrowIfCancellationRequested();
log.LogDebug("FindByEmailAsync");
Guid siteGuid = siteSettings.Id;
if (multiTenantOptions.UseRelatedSitesMode)
{
siteGuid = multiTenantOptions.RelatedSiteId;
}
ISiteUser siteUser = await queries.Fetch(siteGuid, email, cancellationToken);
return((TUser)siteUser);
}
public async Task HandleUserUpdated(
ISiteUser user,
CancellationToken cancellationToken = default(CancellationToken)
)
{
foreach (var handler in updateHandlers)
{
try
{
await handler.HandleUserUpdated(user, cancellationToken).ConfigureAwait(false);
}
catch (Exception ex)
{
log.LogError(ex.Message + " " + ex.StackTrace);
}
}
}
public async Task AccountPendingApprovalAdminNotification(
ISiteSettings siteSettings,
ISiteUser user)
{
if (siteSettings.AccountApprovalEmailCsv.Length == 0)
{
return;
}
SmtpOptions smtpOptions = GetSmptOptions(siteSettings);
if (smtpOptions == null)
{
var logMessage = $"failed to send new account notifications to admins because smtp settings are not populated for site {siteSettings.SiteName}";
log.LogError(logMessage);
return;
}
string subject = "New Account Pending Approval";
string plainTextTemplate = templateService.GetPlainTextTemplate(MessagePurpose.ConfirmAccount, CultureInfo.CurrentUICulture.Name);
//string plainTextMessage = string.Format(plainTextTemplate, confirmationUrl);
//string plainTextMessage = "U"
var message = $"A new user just registered at {siteSettings.SiteName} with email address {user.Email}";
//string htmlTemplate = templateService.GetHtmlTemplate(MessagePurpose.ConfirmAccount, CultureInfo.CurrentUICulture.Name);
//string htmlMessage = string.Format(htmlTemplate, confirmationUrl);
EmailSender sender = new EmailSender();
try
{
await sender.SendMultipleEmailAsync(
smtpOptions,
siteSettings.AccountApprovalEmailCsv,
siteSettings.DefaultEmailFromAddress,
subject,
message,
string.Empty).ConfigureAwait(false);
}
catch (Exception ex)
{
log.LogError("error sending email verification email", ex);
}
}
public async Task <TUser> FindByLoginAsync(string loginProvider, string providerKey, CancellationToken cancellationToken)
{
if (debugLog)
{
log.LogInformation("FindAsync called for " + loginProvider + " with providerKey " + providerKey);
}
log.LogInformation("FindAsync called for " + loginProvider + " with providerKey " + providerKey);
cancellationToken.ThrowIfCancellationRequested();
int siteId = siteSettings.SiteId;
if (multiTenantOptions.UseRelatedSitesMode)
{
siteId = multiTenantOptions.RelatedSiteId;
}
IUserLogin userlogin = await repo.FindLogin(siteId, loginProvider, providerKey);
if (userlogin != null && userlogin.UserId.Length == 36)
{
log.LogInformation("FindAsync userLogin found for " + loginProvider + " with providerKey " + providerKey);
Guid userGuid = new Guid(userlogin.UserId);
cancellationToken.ThrowIfCancellationRequested();
ISiteUser siteUser = await repo.Fetch(siteId, userGuid);
if (siteUser != null)
{
return((TUser)siteUser);
}
else
{
log.LogInformation("FindAsync siteUser not found for " + loginProvider + " with providerKey " + providerKey);
}
}
else
{
log.LogInformation("FindAsync userLogin not found for " + loginProvider + " with providerKey " + providerKey);
}
return(default(TUser));
}
public async Task <TUser> FindByEmailAsync(string email, CancellationToken cancellationToken)
{
if (debugLog)
{
log.LogInformation("FindByEmailAsync");
}
cancellationToken.ThrowIfCancellationRequested();
int siteId = siteSettings.SiteId;
if (multiTenantOptions.UseRelatedSitesMode)
{
siteId = multiTenantOptions.RelatedSiteId;
}
ISiteUser siteUser = await repo.Fetch(siteId, email);
return((TUser)siteUser);
}
public async Task AccountPendingApprovalAdminNotification(
ISiteContext siteSettings,
ISiteUser user)
{
if (siteSettings.AccountApprovalEmailCsv.Length == 0)
{
return;
}
SmtpOptions smtpOptions = GetSmptOptions(siteSettings);
if (smtpOptions == null)
{
var logMessage = $"failed to send new account notifications to admins because smtp settings are not populated for site {siteSettings.SiteName}";
log.LogError(logMessage);
return;
}
string subject = "新用户审批";
EmailSender sender = new EmailSender();
try
{
var plainTextMessage
= await viewRenderer.RenderViewAsString <ISiteUser>("EmailTemplates/AccountPendingApprovalAdminNotificationTextEmail", user).ConfigureAwait(false);
var htmlMessage
= await viewRenderer.RenderViewAsString <ISiteUser>("EmailTemplates/AccountPendingApprovalAdminNotificationHtmlEmail", user).ConfigureAwait(false);
await sender.SendMultipleEmailAsync(
smtpOptions,
siteSettings.AccountApprovalEmailCsv,
siteSettings.DefaultEmailFromAddress,
subject,
plainTextMessage,
htmlMessage).ConfigureAwait(false);
}
catch (Exception ex)
{
log.LogError("error sending email verification email", ex);
}
}
public async Task <ActionResult> ApproveUserAccount(
Guid siteGuid,
int userId,
bool sendEmailNotification,
int returnPageNumber = 1)
{
ISiteSettings selectedSite = await siteManager.Fetch(siteGuid);
if (
(selectedSite != null) &&
(selectedSite.SiteId == siteManager.CurrentSite.SiteId || siteManager.CurrentSite.IsServerAdminSite)
)
{
ISiteUser user = await UserManager.Fetch(selectedSite.SiteId, userId);
if (user != null)
{
user.AccountApproved = true;
var result = await UserManager.Save((SiteUser)user);
if (result)
{
this.AlertSuccess(string.Format("user account for <b>{0}</b> was successfully approved.",
user.DisplayName), true);
}
if (sendEmailNotification)
{
var loginUrl = Url.Action("Login", "Account",
null,
protocol: HttpContext.Request.Scheme);
emailSender.SendAccountConfirmationEmailAsync(
selectedSite,
user.Email,
"Account Approved",
loginUrl).Forget();
}
}
}
return(RedirectToAction("Index", "UserAdmin", new { siteGuid = selectedSite.SiteGuid, pageNumber = returnPageNumber }));
}
public async Task HandleNewUserPostSuccess(
ISiteContext site,
ISiteUser siteUser,
NewUserViewModel viewModel,
HttpContext httpContext,
CancellationToken cancellationToken = default(CancellationToken)
)
{
await EnsureProps();
// we "could" re-validate here but
// the method above gets called just before this in the same postback
// so we know there were no validation errors or this method would not be invoked
//SiteUser siteUser = null;
//if (_userPropertyService.HasAnyNativeProps(_props.Properties))
//{
// siteUser = await _userPropertyService.GetUser(loginResult.User.Id.ToString());
//}
if (siteUser != null)
{
foreach (var p in _props.Properties)
{
if (p.EditableOnAdminUserEdit)
{
if (!_userPropertyService.IsNativeUserProperty(p.Key))
{
var postedValue = httpContext.Request.Form[p.Key];
// persist to kvp storage
await _userPropertyService.CreateOrUpdate(
site.Id.ToString(),
siteUser.Id.ToString(),
p.Key,
postedValue);
}
}
}
}
else
{
_log.LogError("user was null in HandleNewUserPostSuccess, unable to update user with custom data");
}
}
//protected string projectId;
//private async Task EnsureProjectId()
//{
// if (string.IsNullOrEmpty(projectId))
// {
// projectId = await projectResolver.ResolveProjectId().ConfigureAwait(false);
// }
//}
#region User
public async Task Create(
ISiteUser user,
CancellationToken cancellationToken = default(CancellationToken))
{
if (user == null) { throw new ArgumentException("user cannot be null"); }
if (user.SiteId == Guid.Empty) { throw new ArgumentException("user must have a siteid"); }
if (user.Id == Guid.Empty) { throw new ArgumentException("user must have a non-empty id"); }
//await EnsureProjectId().ConfigureAwait(false);
var projectId = user.SiteId.ToString();
var siteUser = SiteUser.FromISiteUser(user);
await userCommands.CreateAsync(
projectId,
siteUser.Id.ToString(),
siteUser,
cancellationToken).ConfigureAwait(false);
}
public async Task AddUserToRole(ISiteUser user, ISiteRole role)
{
if (user == null)
{
throw new ArgumentNullException(nameof(user));
}
if (role == null)
{
throw new ArgumentNullException(nameof(role));
}
if (role.SiteId != user.SiteId)
{
throw new ArgumentException("user and role must have the same siteid");
}
await commands.AddUserToRole(role.Id, user.Id, CancellationToken);
user.RolesChanged = true;
await commands.Update(user, CancellationToken);
}
public async Task Update(
ISiteUser user,
CancellationToken cancellationToken = default(CancellationToken))
{
ThrowIfDisposed();
cancellationToken.ThrowIfCancellationRequested();
if (user == null) { throw new ArgumentException("user can't be null"); }
if (user.SiteId == Guid.Empty) { throw new ArgumentException("user must have a siteguid"); }
if (user.Id == Guid.Empty) { throw new ArgumentException("user must have a non empty guid for id"); }
SiteUser siteUser = SiteUser.FromISiteUser(user);
bool tracking = dbContext.ChangeTracker.Entries<SiteUser>().Any(x => x.Entity.Id == siteUser.Id);
if (!tracking)
{
dbContext.Users.Update(siteUser);
}
int rowsAffected =
await dbContext.SaveChangesAsync(cancellationToken)
.ConfigureAwait(false)
;
}
public static SiteUser FromISiteUser(ISiteUser user)
{
SiteUser u = new SiteUser();
u.AccountApproved = user.AccountApproved;
u.AuthorBio = user.AuthorBio;
u.AvatarUrl = user.AvatarUrl;
u.Comment = user.Comment;
u.Country = user.Country;
u.CreatedUtc = user.CreatedUtc;
u.DateOfBirth = user.DateOfBirth;
u.DisplayInMemberList = user.DisplayInMemberList;
u.DisplayName = user.DisplayName;
u.Email = user.Email;
u.EmailChangeGuid = user.EmailChangeGuid;
u.EmailConfirmed = user.EmailConfirmed;
u.FailedPasswordAnswerAttemptCount = user.FailedPasswordAnswerAttemptCount;
u.FailedPasswordAnswerAttemptWindowStart = user.FailedPasswordAnswerAttemptWindowStart;
u.FailedPasswordAttemptCount = user.FailedPasswordAttemptCount;
u.FailedPasswordAttemptWindowStart = user.FailedPasswordAttemptWindowStart;
u.FirstName = user.FirstName;
u.Gender = user.Gender;
//u.Id = user.Id;
u.IsDeleted = user.IsDeleted;
u.IsLockedOut = user.IsLockedOut;
u.LastActivityDate = user.LastActivityDate;
u.LastLockoutDate = user.LastLockoutDate;
u.LastLoginDate = user.LastLoginDate;
u.LastName = user.LastName;
u.LastPasswordChangedDate = user.LastPasswordChangedDate;
u.LockoutEndDateUtc = user.LockoutEndDateUtc;
u.LoweredEmail = user.LoweredEmail;
u.MustChangePwd = user.MustChangePwd;
u.NewEmail = user.NewEmail;
u.PasswordHash = user.PasswordHash;
u.PasswordResetGuid = user.PasswordResetGuid;
u.PhoneNumber = user.PhoneNumber;
u.PhoneNumberConfirmed = user.PhoneNumberConfirmed;
u.RegisterConfirmGuid = user.RegisterConfirmGuid;
u.RolesChanged = user.RolesChanged;
u.SecurityStamp = user.SecurityStamp;
u.Signature = user.Signature;
u.SiteGuid = user.SiteGuid;
u.SiteId = user.SiteId;
u.State = user.State;
u.TimeZoneId = user.TimeZoneId;
u.Trusted = user.Trusted;
u.TwoFactorEnabled = user.TwoFactorEnabled;
u.UserGuid = user.UserGuid;
u.UserId = user.UserId;
u.UserName = user.UserName;
u.WebSiteUrl = user.WebSiteUrl;
return u;
}
//public string ConcurrencyStamp { get; set; } = Guid.NewGuid().ToString();
public static SiteUser FromISiteUser(ISiteUser user)
{
SiteUser u = new SiteUser();
// u.ConcurrencyStamp = user.ConcurrencyStamp;
//Guid id = user.Id;
if (user.Id != Guid.Empty) u.Id = user.Id;
//SiteUser u = new SiteUser(id);
u.AccessFailedCount = user.AccessFailedCount;
u.AccountApproved = user.AccountApproved;
u.AuthorBio = user.AuthorBio;
u.AvatarUrl = user.AvatarUrl;
u.CanAutoLockout = user.CanAutoLockout;
u.Comment = user.Comment;
//u.Country = user.Country;
u.CreatedUtc = user.CreatedUtc;
u.LastModifiedUtc = user.LastModifiedUtc;
if (user.DateOfBirth.HasValue)
{
u.DateOfBirth = user.DateOfBirth.Value;
}
u.DisplayInMemberList = user.DisplayInMemberList;
u.DisplayName = user.DisplayName;
u.Email = user.Email;
u.EmailConfirmed = user.EmailConfirmed;
u.FirstName = user.FirstName;
u.Gender = user.Gender;
u.IsDeleted = user.IsDeleted;
u.IsLockedOut = user.IsLockedOut;
if(user.LastLoginUtc.HasValue)
{
u.LastLoginUtc = user.LastLoginUtc.Value;
}
u.LastName = user.LastName;
if(user.LastPasswordChangeUtc.HasValue)
{
u.LastPasswordChangeUtc = user.LastPasswordChangeUtc.Value;
}
u.LockoutEndDateUtc = user.LockoutEndDateUtc;
u.MustChangePwd = user.MustChangePwd;
u.NormalizedEmail = user.NormalizedEmail;
u.NormalizedUserName = user.NormalizedUserName;
u.NewEmail = user.NewEmail;
u.NewEmailApproved = user.NewEmailApproved;
u.PasswordHash = user.PasswordHash;
u.PhoneNumber = user.PhoneNumber;
u.PhoneNumberConfirmed = user.PhoneNumberConfirmed;
u.RolesChanged = user.RolesChanged;
u.SecurityStamp = user.SecurityStamp;
u.Signature = user.Signature;
u.SiteId = user.SiteId;
//u.State = user.State;
u.TimeZoneId = user.TimeZoneId;
u.Trusted = user.Trusted;
u.TwoFactorEnabled = user.TwoFactorEnabled;
u.UserName = user.UserName;
u.WebSiteUrl = user.WebSiteUrl;
return u;
}
public async Task AccountPendingApprovalAdminNotification(
ISiteSettings siteSettings,
ISiteUser user)
{
if(siteSettings.AccountApprovalEmailCsv.Length == 0) { return; }
SmtpOptions smtpOptions = GetSmptOptions(siteSettings);
if (smtpOptions == null)
{
var logMessage = $"failed to send new account notifications to admins because smtp settings are not populated for site {siteSettings.SiteName}";
log.LogError(logMessage);
return;
}
string subject = "New Account Pending Approval";
string plainTextTemplate = templateService.GetPlainTextTemplate(MessagePurpose.ConfirmAccount, CultureInfo.CurrentUICulture.Name);
//string plainTextMessage = string.Format(plainTextTemplate, confirmationUrl);
//string plainTextMessage = "U"
var message = $"A new user just registered at {siteSettings.SiteName} with email address {user.Email}";
//string htmlTemplate = templateService.GetHtmlTemplate(MessagePurpose.ConfirmAccount, CultureInfo.CurrentUICulture.Name);
//string htmlMessage = string.Format(htmlTemplate, confirmationUrl);
EmailSender sender = new EmailSender();
try
{
await sender.SendMultipleEmailAsync(
smtpOptions,
siteSettings.AccountApprovalEmailCsv,
siteSettings.DefaultEmailFromAddress,
subject,
message,
string.Empty).ConfigureAwait(false);
}
catch (Exception ex)
{
log.LogError("error sending email verification email", ex);
}
}
//TODO: implement caching logic
#region User
public async Task<bool> Save(ISiteUser user)
{
return await implementation.Save(user);
}
//TODO: implement caching logic
#region User
public async Task<bool> Save(ISiteUser user, CancellationToken cancellationToken = default(CancellationToken))
{
return await implementation.Save(user, cancellationToken);
}
public Task AccountPendingApprovalAdminNotification(
ISiteContext siteSettings,
ISiteUser user)
{
return Task.FromResult(0);
}
public async Task<bool> Save(ISiteUser user)
{
if (user.SiteId == -1) { throw new ArgumentException("user must have a siteid"); }
if (user.SiteGuid == Guid.Empty) { throw new ArgumentException("user must have a siteguid"); }
if (user.UserId == -1)
{
user.UserGuid = Guid.NewGuid();
user.CreatedUtc = DateTime.UtcNow;
user.UserId = dbSiteUser.AddUser(
user.SiteGuid,
user.SiteId,
user.DisplayName,
user.UserName,
user.Email,
user.Password,
user.PasswordSalt,
user.UserGuid,
user.CreatedUtc,
user.MustChangePwd,
user.FirstName,
user.LastName,
user.TimeZoneId,
user.DateOfBirth,
user.EmailConfirmed,
user.PasswordFormat,
user.PasswordHash,
user.SecurityStamp,
user.PhoneNumber,
user.PhoneNumberConfirmed,
user.TwoFactorEnabled,
user.LockoutEndDateUtc);
//user.LoweredEmail,
//user.PasswordQuestion,
//user.PasswordAnswer,
//user.Gender,
//user.ProfileApproved,
//user.RegisterConfirmGuid,
//user.ApprovedForForums,
//user.Trusted,
//user.DisplayInMemberList,
//user.WebSiteURL,
//user.Country,
//user.State,
//user.Occupation,
//user.Interests,
//user.MSN,
//user.Yahoo,
//user.AIM,
//user.ICQ,
//user.TotalPosts,
//user.AvatarUrl,
//user.TimeOffsetHours,
//user.Signature,
//user.Skin,
//user.IsDeleted,
//user.LastActivityDate,
//user.LastLoginDate,
//user.LastPasswordChangedDate,
//user.LastLockoutDate,
//user.FailedPasswordAttemptCount,
//user.FailedPwdAttemptWindowStart,
//user.FailedPwdAnswerAttemptCount,
//user.FailedPwdAnswerWindowStart,
//user.IsLockedOut,
//user.MobilePIN,
//user.Comment,
//user.OpenIDURI,
//user.WindowsLiveID,
//user.TotalRevenue,
//user.NewEmail,
//user.EditorPreference,
//user.EmailChangeGuid,
//user.PasswordResetGuid,
//user.RolesChanged,
//user.AuthorBio
//);
// user.UserID = newId;
}
// not all properties are added on insert so update even if we just inserted
return await Update(user);
}
private async Task<bool> Update(ISiteUser user)
{
if (string.IsNullOrEmpty(user.LoweredEmail)) { user.LoweredEmail = user.Email.ToLowerInvariant(); }
return await dbSiteUser.UpdateUser(
user.UserId,
user.DisplayName,
user.UserName,
user.Email,
user.Password,
user.PasswordSalt,
user.Gender,
user.ProfileApproved,
user.ApprovedForLogin,
user.Trusted,
user.DisplayInMemberList,
user.WebSiteUrl,
user.Country,
user.State,
string.Empty, // legacy user.Occupation,
string.Empty, // legacy user.Interests,
string.Empty, // legacy user.MSN,
string.Empty, // legacy user.Yahoo,
string.Empty, // legacyuser.AIM,
string.Empty, // legacy user.ICQ,
user.AvatarUrl,
user.Signature,
user.Skin,
user.LoweredEmail,
user.PasswordQuestion,
user.PasswordAnswer,
user.Comment,
0, // legacy timeOffsetHours
user.OpenIdUri,
string.Empty, // legacy user.WindowsLiveId,
user.MustChangePwd,
user.FirstName,
user.LastName,
user.TimeZoneId,
user.EditorPreference,
user.NewEmail,
user.EmailChangeGuid,
user.PasswordResetGuid,
user.RolesChanged,
user.AuthorBio,
user.DateOfBirth,
user.EmailConfirmed,
user.PasswordFormat,
user.PasswordHash,
user.SecurityStamp,
user.PhoneNumber,
user.PhoneNumberConfirmed,
user.TwoFactorEnabled,
user.LockoutEndDateUtc);
//user.RegisterConfirmGuid,
//user.TotalPosts,
//user.TimeOffsetHours,
//user.DateCreated,
//user.UserGuid,
//user.IsDeleted,
//user.LastActivityDate,
//user.LastLoginDate,
//user.LastPasswordChangedDate,
//user.LastLockoutDate,
//user.FailedPasswordAttemptCount,
//user.FailedPwdAttemptWindowStart,
//user.FailedPwdAnswerAttemptCount,
//user.FailedPwdAnswerWindowStart,
//user.IsLockedOut,
//user.MobilePIN,
//user.SiteGuid,
//user.TotalRevenue,
}
private async Task<bool> Update(
ISiteUser user,
CancellationToken cancellationToken = default(CancellationToken))
{
cancellationToken.ThrowIfCancellationRequested();
return await dbSiteUser.UpdateUser(
user.UserId,
user.DisplayName,
user.UserName,
user.Email,
user.Gender,
user.AccountApproved,
user.Trusted,
user.DisplayInMemberList,
user.WebSiteUrl,
user.Country,
user.State,
user.AvatarUrl,
user.Signature,
user.NormalizedEmail,
user.Comment,
user.MustChangePwd,
user.FirstName,
user.LastName,
user.TimeZoneId,
user.NewEmail,
user.RolesChanged,
user.AuthorBio,
user.DateOfBirth,
user.EmailConfirmed,
user.PasswordHash,
user.SecurityStamp,
user.PhoneNumber,
user.PhoneNumberConfirmed,
user.TwoFactorEnabled,
user.LockoutEndDateUtc,
user.IsLockedOut,
user.NormalizedUserName,
user.NewEmailApproved,
user.CanAutoLockout,
user.LastPasswordChangedDate,
cancellationToken
);
}
private async Task<bool> Update(ISiteUser user)
{
if (string.IsNullOrEmpty(user.LoweredEmail)) { user.LoweredEmail = user.Email.ToLowerInvariant(); }
return await dbSiteUser.UpdateUser(
user.UserId,
user.DisplayName,
user.UserName,
user.Email,
user.Gender,
user.AccountApproved,
user.Trusted,
user.DisplayInMemberList,
user.WebSiteUrl,
user.Country,
user.State,
user.AvatarUrl,
user.Signature,
user.LoweredEmail,
user.Comment,
user.MustChangePwd,
user.FirstName,
user.LastName,
user.TimeZoneId,
user.NewEmail,
user.EmailChangeGuid,
user.PasswordResetGuid,
user.RolesChanged,
user.AuthorBio,
user.DateOfBirth,
user.EmailConfirmed,
user.PasswordHash,
user.SecurityStamp,
user.PhoneNumber,
user.PhoneNumberConfirmed,
user.TwoFactorEnabled,
user.LockoutEndDateUtc,
user.IsLockedOut
);
}
public async Task AccountPendingApprovalAdminNotification(
ISiteContext siteSettings,
ISiteUser user)
{
if (siteSettings.AccountApprovalEmailCsv.Length == 0) { return; }
SmtpOptions smtpOptions = GetSmptOptions(siteSettings);
if (smtpOptions == null)
{
var logMessage = $"failed to send new account notifications to admins because smtp settings are not populated for site {siteSettings.SiteName}";
log.LogError(logMessage);
return;
}
string subject = sr["New Account Pending Approval"];
EmailSender sender = new EmailSender();
try
{
var plainTextMessage
= await viewRenderer.RenderViewAsString<ISiteUser>("EmailTemplates/AccountPendingApprovalAdminNotificationTextEmail", user).ConfigureAwait(false);
var htmlMessage
= await viewRenderer.RenderViewAsString<ISiteUser>("EmailTemplates/AccountPendingApprovalAdminNotificationHtmlEmail", user).ConfigureAwait(false);
await sender.SendMultipleEmailAsync(
smtpOptions,
siteSettings.AccountApprovalEmailCsv,
smtpOptions.DefaultEmailFromAddress,
subject,
plainTextMessage,
htmlMessage).ConfigureAwait(false);
}
catch (Exception ex)
{
log.LogError("error sending email verification email", ex);
}
}
