public async Task AddEnabledTwoStepAuthenticationAsync(int userId, string auth)
{
using (UserDefinitionDataProvider userDP = new UserDefinitionDataProvider()) {
UserDefinition user = await userDP.GetItemByUserIdAsync(userId);
if (user == null)
{
throw new InternalError($"Unexpected error in {nameof(AddEnabledTwoStepAuthenticationAsync)} - no user found");
}
TwoStepDefinition authDef = new DataProvider.TwoStepDefinition {
Name = auth
};
if (!user.EnabledTwoStepAuthentications.Contains(authDef, new TwoStepDefinitionComparer()))
{
user.EnabledTwoStepAuthentications.Add(authDef);
UpdateStatusEnum status = await userDP.UpdateItemAsync(user);
if (status != UpdateStatusEnum.OK)
{
throw new InternalError($"Unexpected status {status} updating user account in {nameof(AddEnabledTwoStepAuthenticationAsync)}");
}
Manager.Need2FAState = null;//reevaluate now that user has enabled a two-step authentication
}
}
}
public async Task <ActionResult> EntryEdit_Partial(EditModel model)
{
if (!ModelState.IsValid)
{
return(PartialView(model));
}
using (BlogEntryDataProvider dataProvider = new BlogEntryDataProvider()) {
BlogEntry data = await dataProvider.GetItemAsync(model.Identity);
if (data == null)
{
throw new Error(this.__ResStr("notFound", "Blog entry with id {0} not found"), model.Identity);
}
// save updated item
data = model.GetData(data); // merge new data into original
model.SetData(data); // and all the data back into model for final display
UpdateStatusEnum status = await dataProvider.UpdateItemAsync(data);
if (status != UpdateStatusEnum.OK)
{
throw new Error(this.__ResStr("errSaving", "An unexpected error occurred saving the blog entry - {0}", status));
}
return(FormProcessed(model, this.__ResStr("okSaved", "Blog entry saved")));
}
}
public async Task SetUserStatusAsync(int userId, UserStatusEnum userStatus)
{
using (UserDefinitionDataProvider userDP = new UserDefinitionDataProvider()) {
UserDefinition user = await userDP.GetItemByUserIdAsync(userId);
if (user == null)
{
throw new InternalError($"Unknown user (user id {userId})");
}
if (user.UserStatus != userStatus)
{
user.UserStatus = userStatus;
if (userStatus == UserStatusEnum.Approved)
{
user.LoginFailures = 0;
}
UpdateStatusEnum status = await userDP.UpdateItemAsync(user);
if (status != UpdateStatusEnum.OK)
{
throw new InternalError($"Unexpected status {status} updating user account in {nameof(SetUserStatusAsync)}");
}
}
}
}
public async Task RemoveRoleFromUserAsync(int userId, string roleName)
{
int roleId;
// get the role id for roleName
using (RoleDefinitionDataProvider roleDP = new RoleDefinitionDataProvider()) {
RoleDefinition role = await roleDP.GetItemAsync(roleName);
if (role == null)
{
throw new InternalError("Unexpected error in AddRoleToUser - expected role {0} not found", roleName);
}
roleId = role.RoleId;
}
// remove the role from the user
using (UserDefinitionDataProvider userDP = new UserDefinitionDataProvider()) {
UserDefinition user = await userDP.GetItemByUserIdAsync(userId);
if (user != null)
{
Role role = (from Role r in user.RolesList where r.RoleId == roleId select r).FirstOrDefault();
if (role != null)
{
user.RolesList.Remove(role);
UpdateStatusEnum status = await userDP.UpdateItemAsync(user);
if (status != UpdateStatusEnum.OK)
{
throw new InternalError("Unexpected status {0} updating user account in RemoveRoleFromUser", status);
}
}
}
}
}
public async Task UpdateItemAsync(UserData data)
{
if (Manager.HaveUser)
{
data.Key = Manager.UserId;
UpdateStatusEnum status = await DataProvider.UpdateAsync(data.Key, data.Key, data);
if (status == UpdateStatusEnum.RecordDeleted)
{
if (!await DataProvider.AddAsync(data))
{
throw new InternalError("Unexpected failure saving user settings", status);
}
}
else if (status != UpdateStatusEnum.OK)
{
throw new InternalError("Unexpected status {0} updating user settings", status);
}
}
else
{
Manager.SessionSettings.SiteSettings.SetValue <UserData>(KEY, data);
Manager.SessionSettings.SiteSettings.Save();
}
}
public async Task <ActionResult> Suspend(string userName)
{
using (UserDefinitionDataProvider dataProvider = new UserDefinitionDataProvider()) {
UserDefinition user = await GetUserAsync(userName, dataProvider);
if (user.UserStatus != UserStatusEnum.Suspended)
{
user.UserStatus = UserStatusEnum.Suspended;
UpdateStatusEnum status = await dataProvider.UpdateItemAsync(user);
switch (status)
{
default:
case UpdateStatusEnum.NewKeyExists:
throw new InternalError("Unexpected status {0}", status);
case UpdateStatusEnum.RecordDeleted:
throw new Error(this.__ResStr("rejectUserNotFound", "The user account for user {0} no longer exists.", userName));
case UpdateStatusEnum.OK:
break;
}
}
Emails emails = new Emails();
await emails.SendSuspendedAsync(user);
return(Reload(null, Reload: ReloadEnum.ModuleParts, PopupText: this.__ResStr("userSuspended", "The user account for user {0} has been marked as suspended. An email has been sent to the user.", userName)));
}
}
// IINSTALLABLEMODEL
// IINSTALLABLEMODEL
// IINSTALLABLEMODEL
public new async Task LocalizeModelAsync(string language, Func <string, bool> isHtml, Func <List <string>, Task <List <string> > > translateStringsAsync, Func <string, Task <string> > translateComplexStringAsync)
{
const int RECORDS = 20;
for (int offset = 0; ;)
{
DataProviderGetRecords <MenuInfo> data = await DataProvider.GetRecordsAsync(offset, RECORDS, null, null);
if (data.Data.Count == 0)
{
break;
}
bool changed = false;
foreach (MenuInfo menu in data.Data)
{
changed = await TranslateMenuListAsync(menu.Menu, language, (s) => false, translateStringsAsync, translateComplexStringAsync);
if (changed)
{
UpdateStatusEnum status = await UpdateItemAsync(menu);
if (status != UpdateStatusEnum.OK)
{
throw new InternalError($"Update failed for type {typeof(MenuInfo).FullName} ({status})");
}
}
}
offset += data.Data.Count;
if (offset >= data.Total)
{
break;
}
}
}
public async Task <UpdateStatusEnum> UpdateItemAsync(UnifiedSetData unifiedSet)
{
UnifiedSetData origData = Auditing.Active ? await GetItemAsync(unifiedSet.UnifiedSetGuid) : null;
unifiedSet.Updated = DateTime.UtcNow;
if (unifiedSet.UnifiedMode == PageDefinition.UnifiedModeEnum.SkinDynamicContent)
{
unifiedSet.PageList = new List <string>();
}
else
{
unifiedSet.PageSkin = new SkinDefinition();
}
unifiedSet.PageGuids = await UpdatePageGuidsAsync(unifiedSet.UnifiedSetGuid, unifiedSet.PageList);
UpdateStatusEnum status = await DataProvider.UpdateAsync(unifiedSet.UnifiedSetGuid, unifiedSet.UnifiedSetGuid, unifiedSet);
if (status != UpdateStatusEnum.OK)
{
return(status);
}
await Auditing.AddAuditAsync($"{nameof(UnifiedSetDataProvider)}.{nameof(UpdateItemAsync)}", Dataset, Guid.Empty,
$"Update UPS {unifiedSet.Name}",
DataBefore : origData,
DataAfter : unifiedSet
);
return(status);
}
public async Task AddTwoStepLoginFailureAsync()
{
int userId = Manager.SessionSettings.SiteSettings.GetValue <int>(LoginTwoStepController.IDENTITY_TWOSTEP_USERID);
if (userId == 0)
{
throw new InternalError("No user id available in AddTwoStepLoginFailure");
}
using (UserDefinitionDataProvider userDP = new UserDefinitionDataProvider()) {
UserDefinition user = await userDP.GetItemByUserIdAsync(userId);
if (user == null)
{
throw new InternalError("Unexpected error in AddTwoStepLoginFailure - no user found");
}
LoginConfigData config = await LoginConfigDataProvider.GetConfigAsync();
user.LoginFailures = user.LoginFailures + 1;
if (config.MaxLoginFailures != 0 && user.LoginFailures >= config.MaxLoginFailures)
{
if (user.UserStatus != UserStatusEnum.Suspended)
{
user.UserStatus = UserStatusEnum.Suspended;
}
}
UpdateStatusEnum status = await userDP.UpdateItemAsync(user);
if (status != UpdateStatusEnum.OK)
{
throw new InternalError("Unexpected status {0} updating user account in AddTwoStepLoginFailure", status);
}
}
}
// SCHEDULER
// SCHEDULER
// SCHEDULER
/// <summary>
/// Run a scheduler item.
/// </summary>
/// <param name="name"></param>
private async Task RunItemAsync(string name)
{
using (SchedulerDataProvider schedDP = new SchedulerDataProvider()) {
using (ILockObject lockObject = await YetaWF.Core.IO.Caching.LockProvider.LockResourceAsync($"{AreaRegistration.CurrentPackage.AreaName}_RunItem_{name}")) {
SchedulerItemData evnt = await schedDP.GetItemAsync(name);
if (evnt == null)
{
throw new Error(this.__ResStr("errItemNotFound", "Scheduler item '{0}' does not exist."), name);
}
if (evnt.RunOnce)
{
evnt.Enabled = true;
}
if (!evnt.Enabled)
{
throw new Error(this.__ResStr("errItemDisabled", "Scheduler item '{0}' is currently disabled and cannot be scheduled."), evnt.Name);
}
evnt.Next = DateTime.UtcNow.AddSeconds(-1);
evnt.Errors = null;
UpdateStatusEnum status = await schedDP.UpdateItemAsync(evnt);
await lockObject.UnlockAsync();
if (status != UpdateStatusEnum.OK)
{
throw new Error(this.__ResStr("errItemUpdFail", "Scheduler item '{0}' couldn't be updated."), evnt.Name);
}
Dispatch();// run the scheduler now
}
}
}
public async Task <UpdateStatusEnum> UpdateItemAsync(Authorization data)
{
Authorization origData = Auditing.Active ? await GetItemAsync(data.ResourceName) : null;
CleanupUsersAndRoles(data);
if (data.AllowedUsers.Count > Info.MAX_USERS_IN_RESOURCE)
{
throw new Error(this.__ResStr("maxUsers", "Only up to {0} users can be authorized for a resource. Consider creating a role instead, and add all users to that role. There is no limit to the number of users that can be added to a role."));
}
UpdateStatusEnum status = await DataProvider.UpdateAsync(data.ResourceName, data.ResourceName, data);
if (status == UpdateStatusEnum.RecordDeleted)
{
if (!await DataProvider.AddAsync(data))
{
throw new Error(this.__ResStr("addFail", "Unexpected error adding new record - {0}", status));
}
status = UpdateStatusEnum.OK;
}
if (status != UpdateStatusEnum.OK)
{
throw new Error(this.__ResStr("updFail", "Unexpected error updating record - {0}", status));
}
await Auditing.AddAuditAsync($"{nameof(AuthorizationDataProvider)}.{nameof(UpdateItemAsync)}", data.ResourceName, Guid.Empty,
"Add/Update Authorization",
DataBefore : origData,
DataAfter : data,
ExpensiveMultiInstance : true
);
return(status);
}
public async Task <UpdateStatusEnum> UpdateItemAsync(string originalRole, RoleDefinition data)
{
if (data.RoleId == RoleDefinitionDataProvider.SuperUserId || data.Name == Globals.Role_Superuser)
{
throw new Error(this.__ResStr("cantUpdateSuper", "Can't update built-in superuser role"));
}
if (originalRole != data.Name && IsPredefinedRole(originalRole))
{
throw new Error(this.__ResStr("cantUpdateUser", "The {0} role can't be updated", originalRole));
}
if (YetaWF.Core.Support.Startup.MultiInstance)
{
throw new InternalError("Changing roles is not possible when distributed caching is enabled");
}
RoleDefinition origRole = Auditing.Active ? await GetItemAsync(originalRole) : null;
UpdateStatusEnum status = await DataProvider.UpdateAsync(originalRole, data.Name, data);
if (status == UpdateStatusEnum.OK)
{
GetAllUserRoles(true);
}
await Auditing.AddAuditAsync($"{nameof(RoleDefinitionDataProvider)}.{nameof(UpdateItemAsync)}", originalRole, Guid.Empty,
"Update Role",
DataBefore : origRole,
DataAfter : data,
ExpensiveMultiInstance : true
);
return(status);
}
public async Task <bool> AddItemsAsync(List <SearchData> list, string pageUrl, PageDefinition.PageSecurityType pageSecurity, string pageDescription, string pageSummary, DateTime pageCreated, DateTime?pageUpdated, DateTime searchStarted, string customData)
{
if (!IsUsable)
{
return(false);
}
bool status = false;
using (ILockObject lockObject = await YetaWF.Core.IO.Caching.LockProvider.LockResourceAsync($"{AreaRegistration.CurrentPackage.AreaName}_{nameof(SearchDataProvider)}")) {
if (pageUpdated != null && (DateTime)pageUpdated < pageCreated)
{
pageCreated = (DateTime)pageUpdated;
}
using (SearchDataUrlDataProvider searchUrlDP = new SearchDataUrlDataProvider()) {
SearchDataUrl searchUrl = await searchUrlDP.GetItemByUrlAsync(pageUrl);
if (searchUrl == null)
{
searchUrl = new SearchDataUrl {
DatePageCreated = pageCreated,
DatePageUpdated = pageUpdated,
PageTitle = pageDescription.Truncate(SearchDataUrl.MaxTitle),
PageUrl = pageUrl,
PageSecurity = pageSecurity,
PageSummary = pageSummary.Truncate(SearchDataUrl.MaxSummary),
CustomData = customData,
};
if (!await searchUrlDP.AddItemAsync(searchUrl))
{
throw new InternalError("Unexpected error adding SearchDataUrl for url {0}", pageUrl);
}
}
else
{
searchUrl.PageTitle = pageDescription.Truncate(SearchDataUrl.MaxTitle);
searchUrl.PageSummary = pageSummary.Truncate(SearchDataUrl.MaxSummary);
searchUrl.DatePageCreated = pageCreated;
searchUrl.DatePageUpdated = pageUpdated ?? pageCreated;
searchUrl.PageSecurity = pageSecurity;
searchUrl.CustomData = customData;
UpdateStatusEnum updStatus = await searchUrlDP.UpdateItemAsync(searchUrl);
if (updStatus != UpdateStatusEnum.OK)
{
throw new InternalError("Unexpected error updating SearchDataUrl for url {0} - {1}", pageUrl, updStatus);
}
}
foreach (SearchData data in list)
{
data.SearchDataUrlId = searchUrl.SearchDataUrlId;
data.DateAdded = searchStarted;
await AddItemAsync(data);
}
}
status = true;
await lockObject.UnlockAsync();
}
return(status);
}
private async Task GenerateRecoveryCodeAsync(UserDefinitionDataProvider userDP, UserDefinition user)
{
user.RecoveryCode = Guid.NewGuid().ToString().Substring(0, 12);
UpdateStatusEnum status = await userDP.UpdateItemAsync(user);
if (status != UpdateStatusEnum.OK)
{
throw new Error(this.__ResStr("cantUpdate", "Updating user information failed - {0}", status));
}
}
public async Task <UpdateStatusEnum> UpdateItemAsync(string originalName, UserDefinition data)
{
CleanupRoles(data);
if (!Manager.HasSuperUserRole)
{
int superuserRole = Resource.ResourceAccess.GetSuperuserRoleId();
if (data.RolesList.Contains(new Role {
RoleId = superuserRole
}, new RoleComparer()))
{
// new data has super user role
// get original to make sure superuser role isn't new
UserDefinition origData = await GetItemByUserIdAsync(data.UserId);
if (!origData.RolesList.Contains(new Role {
RoleId = superuserRole
}, new RoleComparer()))
{
throw new Error(this.__ResStr("noSup", "Only a superuser can assign superuser status to another user"));
}
}
}
if (string.Compare(data.UserName, SuperuserDefinitionDataProvider.SuperUserName, true) == 0 &&
string.Compare(originalName, SuperuserDefinitionDataProvider.SuperUserName, true) != 0)
{
return(UpdateStatusEnum.NewKeyExists);
}
if (string.Compare(originalName, SuperuserDefinitionDataProvider.SuperUserName, true) == 0)
{
if (data.UserName != originalName)
{
throw new Error(this.__ResStr("cantRenameSuper", "The user \"{0}\" can't be renamed.", originalName));
}
using (SuperuserDefinitionDataProvider superDP = new SuperuserDefinitionDataProvider()) {
return(await superDP.UpdateItemAsync(data));
}
}
UserDefinition origUser = Auditing.Active ? await GetItemAsync(originalName) : null;
UpdateStatusEnum result = await DataProvider.UpdateAsync(originalName, data.UserName, data);
await Auditing.AddAuditAsync($"{nameof(UserDefinitionDataProvider)}.{nameof(UpdateItemAsync)}", originalName, Guid.Empty,
"Update User",
DataBefore : origUser,
DataAfter : data
);
return(result);
}
protected async Task <UpdateStatusEnum> UpdateItemAsync(MenuInfo data)
{
MenuInfo origMenu = Auditing.Active ? await GetItemAsync(data.ModuleGuid) : null;
UpdateStatusEnum result = await DataProvider.UpdateAsync(data.ModuleGuid, data.ModuleGuid, data);
await Auditing.AddAuditAsync($"{nameof(MenuInfoDataProvider)}.{nameof(UpdateItemAsync)}", "Menu", data.ModuleGuid,
"Update Menu",
DataBefore : origMenu,
DataAfter : data,
ExpensiveMultiInstance : true
);
return(result);
}
public async Task UpdateItemAsync(VoiceMailData data)
{
VoiceMailData origEmail = Auditing.Active ? await GetItemAsync(data.CallSid) : null;
UpdateStatusEnum status = await DataProvider.UpdateByIdentityAsync(data.Id, data);
if (status != UpdateStatusEnum.OK)
{
throw new InternalError("Unexpected error {0} updating item", status);
}
await Auditing.AddAuditAsync($"{nameof(VoiceMailDataProvider)}.{nameof(UpdateItemAsync)}", Dataset, Guid.Empty,
$"Update Voice Mail Entry {data.Id}",
DataBefore : origEmail,
DataAfter : data
);
}
public async Task UpdateConfigAsync(SearchConfigData data)
{
SearchConfigData origConfig = Auditing.Active ? await GetItemAsync() : null;
data.Id = KEY;
UpdateStatusEnum status = await DataProvider.UpdateAsync(data.Id, data.Id, data);
if (status != UpdateStatusEnum.OK)
{
throw new InternalError("Unexpected error saving settings {0}", status);
}
await Auditing.AddAuditAsync($"{nameof(SearchConfigDataProvider)}.{nameof(UpdateConfigAsync)}", "Config", Guid.Empty,
"Update Search Config",
DataBefore : origConfig,
DataAfter : data,
ExpensiveMultiInstance : true
);
}
public async Task UpdateConfigAsync(RecaptchaV2Config data)
{
RecaptchaV2Config origConfig = Auditing.Active ? await GetItemAsync() : null;
data.Key = KEY;
UpdateStatusEnum status = await DataProvider.UpdateAsync(data.Key, data.Key, data);
if (status != UpdateStatusEnum.OK)
{
throw new InternalError("Can't save captcha configuration {0}", status);
}
await Auditing.AddAuditAsync($"{nameof(RecaptchaV2ConfigDataProvider)}.{nameof(UpdateConfigAsync)}", "Config", Guid.Empty,
"Update RecaptchaV2 Config",
DataBefore : origConfig,
DataAfter : data,
ExpensiveMultiInstance : true
);
}
public async Task <ActionResult> Approve(int blogEntry, int comment)
{
using (BlogCommentDataProvider dataProvider = new BlogCommentDataProvider(blogEntry)) {
BlogComment cmt = await dataProvider.GetItemAsync(comment);
if (cmt == null)
{
throw new InternalError("Can't find comment entry {0}", comment);
}
cmt.Approved = true;
UpdateStatusEnum status = await dataProvider.UpdateItemAsync(cmt);
if (status != UpdateStatusEnum.OK)
{
throw new InternalError("Can't update comment entry - {0}", status);
}
return(Reload(null, Reload: ReloadEnum.Page));
}
}
public async Task <UpdateStatusEnum> UpdateItemAsync(UserInfo userInfo)
{
UserInfo origUserInfo = Auditing.Active ? await GetItemAsync(userInfo.UserId) : null;
userInfo.Updated = DateTime.UtcNow;
if (string.IsNullOrWhiteSpace(userInfo.Country))
{
userInfo.Country = Globals.DefaultCountry;
}
UpdateStatusEnum result = await DataProvider.UpdateAsync(userInfo.UserId, userInfo.UserId, userInfo);
await Auditing.AddAuditAsync($"{nameof(UserInfoDataProvider)}.{nameof(UpdateItemAsync)}", userInfo.UserId.ToString(), Guid.Empty,
"Update UserInfo",
DataBefore : origUserInfo,
DataAfter : userInfo
);
return(result);
}
public async Task <IdentityResult> UpdateAsync(RoleDefinition role, CancellationToken cancellationToken)
{
RoleDefinitionDataProvider dataProvider = new RoleDefinitionDataProvider(this.CurrentSiteIdentity);
UpdateStatusEnum status = await dataProvider.UpdateItemAsync(role);
switch (status)
{
default:
case UpdateStatusEnum.RecordDeleted:
throw new Error(this.__ResStr("alreadyDeleted", "The role named \"{0}\" has been removed and can no longer be updated.", role.Name));
case UpdateStatusEnum.NewKeyExists:
throw new Error(this.__ResStr("alreadyExists", "A role named \"{0}\" already exists.", role.Name));
case UpdateStatusEnum.OK:
break;
}
return(IdentityResult.Success);
}
public async Task <UpdateStatusEnum> UpdateItemAsync(HolidayEntry data)
{
HolidayEntry origData = Auditing.Active ? await GetItemByIdentityAsync(data.Id) : null;
UpdateStatusEnum status = await DataProvider.UpdateByIdentityAsync(data.Id, data);
if (status != UpdateStatusEnum.OK)
{
return(status);
}
await Auditing.AddAuditAsync($"{nameof(HolidayEntryDataProvider)}.{nameof(UpdateItemAsync)}", Dataset, Guid.Empty,
$"Update Holiday Entry {data.Id}",
DataBefore : origData,
DataAfter : data
);
return(UpdateStatusEnum.OK);
}
public async Task UpdateConfigAsync(BlogConfigData data)
{
BlogConfigData origConfig = Auditing.Active ? await GetItemAsync() : null;
data.Id = KEY;
await SaveImagesAsync(ModuleDefinition.GetPermanentGuid(typeof(BlogConfigModule)), data);
UpdateStatusEnum status = await DataProvider.UpdateAsync(data.Id, data.Id, data);
if (status != UpdateStatusEnum.OK)
{
throw new InternalError("Unexpected error saving settings {0}", status);
}
await Auditing.AddAuditAsync($"{nameof(BlogConfigDataProvider)}.{nameof(UpdateConfigAsync)}", "Config", Guid.Empty,
"Update Blog Config",
DataBefore : origConfig,
DataAfter : data,
ExpensiveMultiInstance : true
);
}
public async Task <IdentityResult> UpdateAsync(UserDefinition user, CancellationToken cancellationToken)
{
using (UserDefinitionDataProvider dataProvider = new UserDefinitionDataProvider(this.CurrentSiteIdentity)) {
UpdateStatusEnum status = await dataProvider.UpdateItemAsync(user);
switch (status)
{
default:
case UpdateStatusEnum.NewKeyExists:
throw new InternalError("Unexpected update status");
case UpdateStatusEnum.RecordDeleted:
throw new Error(this.__ResStr("userDeleted", "User {0} not found.", user.UserName));
case UpdateStatusEnum.OK:
break;
}
return(IdentityResult.Success);
}
}
public async Task <UpdateStatusEnum> UpdateItemAsync(BlockedNumberEntry data)
{
BlockedNumberEntry origData = Auditing.Active ? await GetItemByIdentityAsync(data.Id) : null;
data.Updated = DateTime.UtcNow;
data.Number = PhoneNumberAttribute.GetE164(data.Number);
UpdateStatusEnum status = await DataProvider.UpdateByIdentityAsync(data.Id, data);
if (status != UpdateStatusEnum.OK)
{
return(status);
}
await Auditing.AddAuditAsync($"{nameof(BlockedNumberDataProvider)}.{nameof(UpdateItemAsync)}", Dataset, Guid.Empty,
$"Update Blocked Number {data.Id}",
DataBefore : origData,
DataAfter : data
);
return(UpdateStatusEnum.OK);
}
public async Task RehashAllPasswordsAsync()
{
LoginConfigData config = await LoginConfigDataProvider.GetConfigAsync();
if (!config.SavePlainTextPassword)
{
throw new InternalError("Rehashing all passwords is only available if plain text passwords are saved");
}
UserManager <UserDefinition> userManager = Managers.GetUserManager();
const int TAKE = 10;
for (int skip = 0; ; skip += TAKE)
{
DataProviderGetRecords <UserDefinition> list = await GetItemsAsync(skip, TAKE, null, null);
if (list.Data.Count == 0)
{
break;
}
foreach (UserDefinition user in list.Data)
{
if (!string.IsNullOrWhiteSpace(user.PasswordPlainText))
{
#if MVC6
IPasswordHasher <UserDefinition> passwordHasher = (IPasswordHasher <UserDefinition>)YetaWFManager.ServiceProvider.GetService(typeof(IPasswordHasher <UserDefinition>));
user.PasswordHash = passwordHasher.HashPassword(user, user.PasswordPlainText);
#else
user.PasswordHash = userManager.PasswordHasher.HashPassword(user.PasswordPlainText);
#endif
UpdateStatusEnum status = await UpdateItemAsync(user);
if (status != UpdateStatusEnum.OK)
{
throw new InternalError("Update failed - status {0} user id {1}", status, user.Id);
}
}
}
}
}
// Change a user password
private async Task ChangePasswordAsync(string userName, string newPassword)
{
using (UserDefinitionDataProvider dataProvider = new UserDefinitionDataProvider()) {
UserDefinition user = await dataProvider.GetItemAsync(userName);
if (user == null)
{
throw new Error(this.__ResStr("notFound", "User {0} not found", userName));
}
UserManager <UserDefinition> userManager = Managers.GetUserManager();
string hashedNewPassword;
#if MVC6
IPasswordHasher <UserDefinition> passwordHasher = (IPasswordHasher <UserDefinition>)YetaWFManager.ServiceProvider.GetService(typeof(IPasswordHasher <UserDefinition>));
hashedNewPassword = passwordHasher.HashPassword(user, newPassword);
#else
hashedNewPassword = userManager.PasswordHasher.HashPassword(newPassword);
#endif
//ModuleDefinition.GetPermanentGuid(typeof(RegisterModule))
LoginConfigData config = await LoginConfigDataProvider.GetConfigAsync();
user.PasswordPlainText = config.SavePlainTextPassword ? newPassword : null;
user.PasswordHash = hashedNewPassword;
UpdateStatusEnum status = await dataProvider.UpdateItemAsync(user);
switch (status)
{
default:
case UpdateStatusEnum.NewKeyExists:
throw new InternalError("Unexpected status {0}", status);
case UpdateStatusEnum.RecordDeleted:
throw new Error(this.__ResStr("changeUserNotFound", "The user account for user {0} no longer exists.", userName));
case UpdateStatusEnum.OK:
break;
}
}
}
public async Task RemoveEnabledTwoStepAuthenticationAsync(int userId, string auth)
{
using (UserDefinitionDataProvider userDP = new UserDefinitionDataProvider()) {
UserDefinition user = await userDP.GetItemByUserIdAsync(userId);
if (user == null)
{
throw new InternalError("Unexpected error in RemoveEnabledTwoStepAuthentication - no user found");
}
TwoStepDefinition authDef = user.EnabledTwoStepAuthentications.Find(m => m.Name == auth);
if (authDef != null)
{
user.EnabledTwoStepAuthentications.Remove(authDef);
UpdateStatusEnum status = await userDP.UpdateItemAsync(user);
if (status != UpdateStatusEnum.OK)
{
throw new InternalError("Unexpected status {0} updating user account in RemoveEnabledTwoStepAuthentication", status);
}
Manager.Need2FAState = null;//reevaluate now that user has removed a two-step authentication
}
}
}
// IUserLoginStore
// IUserLoginStore
// IUserLoginStore
public async Task AddLoginAsync(UserDefinition user, UserLoginInfo login, CancellationToken cancellationToken)
{
using (UserLoginInfoDataProvider logInfoDP = new DataProvider.UserLoginInfoDataProvider(CurrentSiteIdentity)) {
await logInfoDP.AddItemAsync(user.UserId, login.LoginProvider, login.ProviderKey);
}
using (UserDefinitionDataProvider dataProvider = new UserDefinitionDataProvider(this.CurrentSiteIdentity)) {
UpdateStatusEnum status = await dataProvider.UpdateItemAsync(user);
switch (status)
{
case UpdateStatusEnum.RecordDeleted:
throw new Error(this.__ResStr("delUser", "Can't update user {0}, because the user has been deleted.", user.UserName));
default:
case UpdateStatusEnum.NewKeyExists:
throw new InternalError("Unexpected update status");
case UpdateStatusEnum.OK:
break;
}
}
}
