public async Task <ActionResult> LoginDirectGet(string name, string password, Guid security)
{
Package package = AreaRegistration.CurrentPackage;
Guid batchKey = WebConfigHelper.GetValue <Guid>(package.AreaName, "BatchKey");
if (batchKey != security)
{
return(NotAuthorized());
}
LoginConfigData config = await LoginConfigDataProvider.GetConfigAsync();
LoginModel model = new LoginModel {
AllowNewUser = config.AllowUserRegistration,
RegistrationType = config.RegistrationType,
RememberMe = true,
UserName = name,
Password = password
};
ActionResult result = await CompleteLoginAsync(model, await LoginConfigDataProvider.GetConfigAsync(), useTwoStep : false);
if (!model.Success)
{
Manager.CurrentResponse.StatusCode = 401;
}
return(new EmptyResult());
}
} // for external login only
public async Task UpdateAsync()
{
LoginConfigData config = await LoginConfigDataProvider.GetConfigAsync();
RegisterModule regMod = (RegisterModule)await ModuleDefinition.CreateUniqueModuleAsync(typeof(RegisterModule));
bool closeOnLogin;
Manager.TryGetUrlArg <bool>("CloseOnLogin", out closeOnLogin, false);
ForgotPasswordModule pswdMod = (ForgotPasswordModule)await ModuleDefinition.CreateUniqueModuleAsync(typeof(ForgotPasswordModule));
ModuleAction pswdAction = await pswdMod.GetAction_ForgotPasswordAsync(config.ForgotPasswordUrl, CloseOnLogin : closeOnLogin);
if (pswdAction != null)
{
pswdAction.AddToOriginList = false;
}
Actions.New(pswdAction);
ModuleAction registerAction = await regMod.GetAction_RegisterAsync(config.RegisterUrl, Force : true, CloseOnLogin : closeOnLogin);
if (registerAction != null)
{
registerAction.AddToOriginList = false;
}
Actions.New(registerAction);
}
public async Task <ModuleAction> GetAction_RegisterAsync(string url, bool Force = false, bool CloseOnLogin = false)
{
LoginConfigData config = await LoginConfigDataProvider.GetConfigAsync();
if (!config.AllowUserRegistration)
{
return(null);
}
if (!Force && Manager.HaveUser)
{
return(null);
}
return(new ModuleAction(this)
{
Url = string.IsNullOrWhiteSpace(url) ? ModulePermanentUrl : url,
QueryArgs = CloseOnLogin ? new { CloseOnLogin = CloseOnLogin } : null,
Image = await CustomIconAsync("Register.png"),
LinkText = this.__ResStr("regLink", "Register a new user account"),
MenuText = this.__ResStr("regText", "Register"),
Tooltip = this.__ResStr("regTooltip", "If you don't have an account on this site, click to register"),
Legend = this.__ResStr("regLegend", "Allows you to register on this site as a new user"),
Style = Manager.IsInPopup ? ModuleAction.ActionStyleEnum.ForcePopup : ModuleAction.ActionStyleEnum.Normal,
Location = ModuleAction.ActionLocationEnum.NoAuto | ModuleAction.ActionLocationEnum.InPopup | ModuleAction.ActionLocationEnum.ModuleLinks,
Category = ModuleAction.ActionCategoryEnum.Update,
Mode = ModuleAction.ActionModeEnum.Any,
SaveReturnUrl = false,
AddToOriginList = false,
});
}
public async Task <ActionResult> SetupExternalAccount()
{
// get the registration module for some defaults
LoginConfigData config = await LoginConfigDataProvider.GetConfigAsync();
bool allowNewUser = config.AllowUserRegistration;
ExtUserInfo extInfo = await GetUserInfo(config);
if (!allowNewUser && extInfo.ExistingUser == null)
{
throw new Error(this.__ResStr("noInvite", "This site allows new accounts by invitation only - According to our records there is no account on this site for your {0} credentials", extInfo.LoginProviderDisplay));
}
SetupExternalAccountModel model = new SetupExternalAccountModel {
AllowNewUser = allowNewUser,
ExistingUser = extInfo.ExistingUser != null,
UserName = extInfo.Name,
Email = extInfo.Email,
RegistrationType = config.RegistrationType,
LoginProviderDisplay = extInfo.LoginProviderDisplay,
};
return(View(model));
}
public Model()
{
YetaWFManager.Syncify(async() => { // this is needed during model validation
ConfigData = await LoginConfigDataProvider.GetConfigAsync();
});
TwoStepAuth = new SerializableList <Role>();
}
public async Task UpdateAsync()
{
LoginConfigData config = await LoginConfigDataProvider.GetConfigAsync();
RegisterModule regMod = (RegisterModule)await ModuleDefinition.CreateUniqueModuleAsync(typeof(RegisterModule));
LoginModule loginMod = (LoginModule)await ModuleDefinition.CreateUniqueModuleAsync(typeof(LoginModule));
bool closeOnLogin;
Manager.TryGetUrlArg <bool>("CloseOnLogin", out closeOnLogin, false);
ModuleAction logAction = await loginMod.GetAction_LoginAsync(config.LoginUrl, Force : true, CloseOnLogin : closeOnLogin);
if (logAction != null)
{
logAction.AddToOriginList = false;
}
Actions.New(logAction);
ModuleAction regAction = await regMod.GetAction_RegisterAsync(config.RegisterUrl, Force : true, CloseOnLogin : closeOnLogin);
if (regAction != null)
{
regAction.AddToOriginList = false;
}
Actions.New(regAction);
}
public async Task <ActionResult> Login(string name, string pswd, string v, bool closeOnLogin = false, bool __f = false)
{
// add popup support for possible 2fa
await YetaWFCoreRendering.Render.AddPopupsAddOnsAsync();
LoginConfigData config = await LoginConfigDataProvider.GetConfigAsync();
bool isPersistent = config.PersistentLogin;
LoginModel model = new LoginModel {
AllowNewUser = config.AllowUserRegistration,
RegistrationType = config.RegistrationType,
UserName = name,
Email = name,
Password = pswd,
VerificationCode = v,
Captcha = new RecaptchaV2Data(),
RememberMe = isPersistent,
CloseOnLogin = closeOnLogin,
ShowVerification = !string.IsNullOrWhiteSpace(v),
ShowCaptcha = config.Captcha && string.IsNullOrWhiteSpace(v) && !Manager.IsLocalHost,
};
if (Manager.HaveReturnToUrl)
{
model.ReturnUrl = Manager.ReturnToUrl;
}
using (LoginConfigDataProvider logConfigDP = new LoginConfigDataProvider()) {
List <LoginConfigDataProvider.LoginProviderDescription> loginProviders = await logConfigDP.GetActiveExternalLoginProvidersAsync();
if (loginProviders.Count > 0 && Manager.IsInPopup)
{
throw new InternalError("When using external login providers, the Login module cannot be used in a popup window");
}
foreach (LoginConfigDataProvider.LoginProviderDescription provider in loginProviders)
{
model.ExternalProviders.Add(new FormButton()
{
ButtonType = ButtonTypeEnum.Submit,
Name = "provider",
Text = provider.InternalName,
Title = this.__ResStr("logAccountTitle", "Log in using your {0} account", provider.DisplayName),
CssClass = "t_" + provider.InternalName.ToLower(),
});
YetaWF.Core.Packages.Package package = AreaRegistration.CurrentPackage;
string url = VersionManager.GetAddOnPackageUrl(package.AreaName);
model.Images.Add(Manager.GetCDNUrl(string.Format("{0}Icons/LoginProviders/{1}.png", url, provider.InternalName)));
}
}
if (__f)
{
Manager.CurrentResponse.StatusCode = 401;
}
await model.UpdateAsync();
return(View(model));
}
public async Task <ActionResult> UsersAdd_Partial(AddModel model)
{
if (!ModelState.IsValid)
{
return(PartialView(model));
}
using (UserDefinitionDataProvider dataProvider = new UserDefinitionDataProvider()) {
LoginConfigData config = await LoginConfigDataProvider.GetConfigAsync();
switch (config.RegistrationType)
{
default:
case RegistrationTypeEnum.NameAndEmail: { // Email == model.Email
List <DataProviderFilterInfo> filters = DataProviderFilterInfo.Join(null, new DataProviderFilterInfo {
Field = nameof(UserDefinition.Email), Operator = "==", Value = model.Email,
});
UserDefinition userExists = await dataProvider.GetItemAsync(filters);
if (userExists != null)
{
ModelState.AddModelError(nameof(model.Email), this.__ResStr("emailUsed", "An account using email address {0} already exists.", model.Email));
return(PartialView(model));
}
break;
}
case RegistrationTypeEnum.EmailOnly:
model.UserName = model.Email;
break;
case RegistrationTypeEnum.NameOnly:
model.UserName = model.Email;
break;
}
UserDefinition user = model.GetData();
string hashedNewPassword;
#if MVC6
IPasswordHasher <UserDefinition> passwordHasher = (IPasswordHasher <UserDefinition>)YetaWFManager.ServiceProvider.GetService(typeof(IPasswordHasher <UserDefinition>));
hashedNewPassword = passwordHasher.HashPassword(user, model.Password);
#else
UserManager <UserDefinition> userManager = Managers.GetUserManager();
hashedNewPassword = userManager.PasswordHasher.HashPassword(model.Password);
#endif
user.PasswordPlainText = config.SavePlainTextPassword ? model.Password : null;
user.PasswordHash = hashedNewPassword;
if (!await dataProvider.AddItemAsync(user))
{
throw new Error(this.__ResStr("alreadyExists", "A user named \"{0}\" already exists."), model.UserName);
}
return(FormProcessed(model, this.__ResStr("okSaved", "New user saved"), OnPopupClose: OnPopupCloseEnum.ReloadModule));
}
}
public async Task <ActionResult> UsersAdd()
{
LoginConfigData config = await LoginConfigDataProvider.GetConfigAsync();
AddModel model = new AddModel();
model.SetData(new UserDefinition());
model.RegistrationType = config.RegistrationType;
return(View(model));
}
public async Task <ActionResult> ForgotPassword()
{
LoginConfigData config = await LoginConfigDataProvider.GetConfigAsync();
EditModel model = new EditModel {
ShowCaptcha = config.CaptchaForgotPassword,
RegistrationType = config.RegistrationType,
};
await model.UpdateAsync();
return(View(model));
}
public async Task <ActionResult> Register(bool closeOnLogin = false)
{
LoginConfigData config = await LoginConfigDataProvider.GetConfigAsync();
if (!config.AllowUserRegistration)
{
throw new Error(this.__ResStr("cantRegister", "This site does not allow new user registration"));
}
using (LoginConfigDataProvider logConfigDP = new LoginConfigDataProvider()) {
RegisterModel model = new RegisterModel {
RegistrationType = config.RegistrationType,
ShowCaptcha = config.Captcha && !Manager.IsLocalHost,
Captcha = new RecaptchaV2Data(),
CloseOnLogin = closeOnLogin,
QueryString = Manager.RequestQueryString.ToQueryString(),
PasswordRules = Module.ShowPasswordRules ? logConfigDP.PasswordRules : null,
};
List <LoginConfigDataProvider.LoginProviderDescription> loginProviders = await logConfigDP.GetActiveExternalLoginProvidersAsync();
if (loginProviders.Count > 0 && Manager.IsInPopup)
{
throw new InternalError("When using external login providers, the Register module cannot be used in a popup window");
}
foreach (LoginConfigDataProvider.LoginProviderDescription provider in loginProviders)
{
model.ExternalProviders.Add(new FormButton()
{
ButtonType = ButtonTypeEnum.Submit,
Name = "provider",
Text = provider.InternalName,
Title = this.__ResStr("logAccountTitle", "Log in using your {0} account", provider.DisplayName),
CssClass = "t_" + provider.InternalName.ToLower(),
});
YetaWF.Core.Packages.Package package = AreaRegistration.CurrentPackage;
string url = VersionManager.GetAddOnPackageUrl(package.AreaName);
model.Images.Add(Manager.GetCDNUrl(string.Format("{0}Icons/LoginProviders/{1}.png", url, provider.InternalName)));
}
if (Manager.HaveReturnToUrl)
{
model.ReturnUrl = Manager.ReturnToUrl;
}
await model.UpdateAsync();
return(View(model));
}
}
public async Task <ModuleAction> GetAction_ForgotPasswordAsync(string url, bool CloseOnLogin = false)
{
LoginConfigData config = await LoginConfigDataProvider.GetConfigAsync();
if (config.SavePlainTextPassword)
{
return(new ModuleAction(this)
{
Url = string.IsNullOrWhiteSpace(url) ? ModulePermanentUrl : url,
QueryArgs = CloseOnLogin ? new { CloseOnLogin = CloseOnLogin } : null,
Image = "#Help",
LinkText = this.__ResStr("forgotLink", "Forgot your password?"),
MenuText = this.__ResStr("forgotText", "Forgot your password?"),
Tooltip = this.__ResStr("forgotTooltip", "If you have an account and forgot your password, click to have an email sent to you with your password"),
Legend = this.__ResStr("forgotLegend", "Used to send an email to you with your password if you have an account and forgot your password"),
Style = Manager.IsInPopup ? ModuleAction.ActionStyleEnum.ForcePopup : ModuleAction.ActionStyleEnum.Normal,
Location = ModuleAction.ActionLocationEnum.NoAuto | ModuleAction.ActionLocationEnum.InPopup | ModuleAction.ActionLocationEnum.ModuleLinks,
Category = ModuleAction.ActionCategoryEnum.Update,
Mode = ModuleAction.ActionModeEnum.Any,
SaveReturnUrl = false,
AddToOriginList = false,
});
}
else
{
return(new ModuleAction(this)
{
Url = string.IsNullOrWhiteSpace(url) ? ModulePermanentUrl : url,
QueryArgs = CloseOnLogin ? new { CloseOnLogin = CloseOnLogin } : null,
Image = "#Help",
LinkText = this.__ResStr("resetLink", "Forgot your password?"),
MenuText = this.__ResStr("resetText", "Forgot your password?"),
Tooltip = this.__ResStr("resetTooltip", "If you have an account and forgot your password, click to have an email sent to you to reset your password"),
Legend = this.__ResStr("resetLegend", "Used to send an email to you to reset your password if you have an account and forgot your password"),
Style = Manager.IsInPopup ? ModuleAction.ActionStyleEnum.ForcePopup : ModuleAction.ActionStyleEnum.Normal,
Location = ModuleAction.ActionLocationEnum.NoAuto | ModuleAction.ActionLocationEnum.InPopup | ModuleAction.ActionLocationEnum.ModuleLinks,
Category = ModuleAction.ActionCategoryEnum.Update,
Mode = ModuleAction.ActionModeEnum.Any,
SaveReturnUrl = false,
AddToOriginList = false,
});
}
}
public async Task <ActionResult> UsersEdit(string userName)
{
using (UserDefinitionDataProvider dataProvider = new UserDefinitionDataProvider()) {
LoginConfigData config = await LoginConfigDataProvider.GetConfigAsync();
EditModel model = new EditModel {
RegistrationType = config.RegistrationType,
};
UserDefinition data = await dataProvider.GetItemAsync(userName);
if (data == null)
{
throw new Error(this.__ResStr("notFound", "User \"{0}\" not found."), userName);
}
model.SetData(data);
Module.Title = this.__ResStr("modEditTitle", "User {0}", userName);
return(View(model));
}
}
public async Task <ActionResult> NeedNewPasswordDisplay()
{
if (!Manager.NeedNewPassword)
{
return(new EmptyResult());
}
if (Manager.EditMode)
{
return(new EmptyResult());
}
if (Manager.IsInPopup)
{
return(new EmptyResult());
}
using (UserLoginInfoDataProvider logInfoDP = new UserLoginInfoDataProvider()) {
if (await logInfoDP.IsExternalUserAsync(Manager.UserId))
{
return(new EmptyResult());
}
}
UserPasswordModule modNewPassword = (UserPasswordModule)await ModuleDefinition.LoadAsync(ModuleDefinition.GetPermanentGuid(typeof(UserPasswordModule)));
if (modNewPassword == null)
{
throw new InternalError($"nameof(UserPasswordModule) module not found");
}
LoginConfigData config = await LoginConfigDataProvider.GetConfigAsync();
ModuleAction actionNewPassword = modNewPassword.GetAction_UserPassword(config.ChangePasswordUrl);
if (actionNewPassword == null)
{
throw new InternalError("Change password action not found");
}
DisplayModel model = new DisplayModel {
ChangePasswordAction = actionNewPassword,
};
return(View(model));
}
public async Task <ActionResult> Login_Partial(LoginModel model)
{
await model.UpdateAsync();
LoginConfigData config = await LoginConfigDataProvider.GetConfigAsync();
model.AllowNewUser = config.AllowUserRegistration;
model.RegistrationType = config.RegistrationType;
if (model.ShowCaptcha != (config.Captcha && !model.ShowVerification && !Manager.IsLocalHost))
{
throw new InternalError("Hidden field tampering detected");
}
if (!ModelState.IsValid && config.RegistrationType == RegistrationTypeEnum.EmailOnly)
{
if (ModelState[nameof(model.Email)] != null && ModelState[nameof(model.Email)].ValidationState == Microsoft.AspNetCore.Mvc.ModelBinding.ModelValidationState.Invalid)
{
// we allow the superuser name as login in case we use email registration and the superuser name is not a valid email address
if (string.Compare(model.Email, SuperuserDefinitionDataProvider.SuperUserName, true) == 0)
{
ModelState.Remove(nameof(model.Email));
}
}
}
if (!model.ShowCaptcha && ModelState[nameof(model.Captcha)] != null)
{
ModelState[nameof(model.Captcha)].ValidationState = Microsoft.AspNetCore.Mvc.ModelBinding.ModelValidationState.Valid;
}
if (!ModelState.IsValid)
{
return(PartialView(model));
}
if (config.RegistrationType == RegistrationTypeEnum.EmailOnly)
{
model.UserName = model.Email;
}
return(await CompleteLoginAsync(model, config, useTwoStep : true));
}
/// <summary>
/// Log off
/// </summary>
public async Task <ActionResult> Logoff(string nextUrl)
{
Manager.SetSuperUserRole(false);// explicit logoff clears superuser state
await LoginModuleController.UserLogoffAsync();
LoginConfigData config = await LoginConfigDataProvider.GetConfigAsync();
string url = nextUrl;
if (string.IsNullOrWhiteSpace(url))
{
url = config.LoggedOffUrl;
}
if (string.IsNullOrWhiteSpace(url))
{
url = Manager.CurrentSite.HomePageUrl;
}
// Because this is a plain MVC controller, this Redirect really redirects (no Unified Page Set handling) which is the desired behavior
url = QueryHelper.AddRando(url); // to defeat client-side caching
return(Redirect(url));
}
// 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;
}
}
}
// User login
public static async Task UserLoginAsync(UserDefinition user, bool?rememberme = null)
{
await LoginModuleController.UserLogoffAsync();
bool isPersistent;
if (rememberme == null)
{
LoginConfigData config = await LoginConfigDataProvider.GetConfigAsync();
isPersistent = config.PersistentLogin;
}
else
{
isPersistent = (bool)rememberme;
}
SignInManager <UserDefinition> _signinManager = (SignInManager <UserDefinition>)YetaWFManager.ServiceProvider.GetService(typeof(SignInManager <UserDefinition>));
await _signinManager.SignInAsync(user, isPersistent);
// superuser
int superuserRole = Resource.ResourceAccess.GetSuperuserRoleId();
if (user.RolesList != null && user.RolesList.Contains(new Role {
RoleId = superuserRole
}, new RoleComparer()))
{
Manager.SetSuperUserRole(true);
}
// accept user
user.LastLoginDate = DateTime.UtcNow;
user.LastLoginIP = Manager.UserHostAddress;
user.LastActivityDate = DateTime.UtcNow;
user.LastActivityIP = Manager.UserHostAddress;
user.LoginFailures = 0;
await Managers.GetUserManager().UpdateAsync(user);
}
public async Task <ActionResult> UserAccount()
{
using (UserDefinitionDataProvider dataProvider = new UserDefinitionDataProvider()) {
LoginConfigData config = await LoginConfigDataProvider.GetConfigAsync();
EditModel model = new EditModel {
RegistrationType = config.RegistrationType,
};
// make sure this user exists
#if MVC6
if (!Manager.CurrentContext.User.Identity.IsAuthenticated)
#else
if (!Manager.CurrentRequest.IsAuthenticated)
#endif
{
throw new Error(this.__ResStr("noUser", "There is no logged on user."));
}
string userName = User.Identity.Name;
UserManager <UserDefinition> userManager = Managers.GetUserManager();
UserDefinition user;
#if MVC6
user = await userManager.FindByNameAsync(userName);
#else
user = userManager.FindByName(userName);
#endif
if (user == null)
{
throw new Error(this.__ResStr("notFound", "User \"{0}\" not found."), userName);
}
model.SetData(user);
model.OriginalUserName = user.UserName;
Module.Title = this.__ResStr("modEditTitle", "User Account");
return(View(model));
}
}
public async Task <ModuleAction> GetAction_ForceTwoStepSetupAsync(string url)
{
if (string.IsNullOrWhiteSpace(url))
{
LoginConfigData config = await LoginConfigDataProvider.GetConfigAsync();
url = config.TwoStepAuthUrl;
}
return(new ModuleAction(this)
{
Url = string.IsNullOrWhiteSpace(url) ? ModulePermanentUrl : url,
Image = "#Edit",
LinkText = this.__ResStr("setupLink", "Two-Step Authentication Setup"),
MenuText = this.__ResStr("setupText", "Two-Step Authentication Setup"),
Tooltip = this.__ResStr("setupTooltip", "Setup Two-Step Authentication"),
Legend = this.__ResStr("setupLegend", "Setup Two-Step Authentication"),
Style = ModuleAction.ActionStyleEnum.ForcePopup,
Category = ModuleAction.ActionCategoryEnum.Update,
Mode = ModuleAction.ActionModeEnum.Any,
Location = ModuleAction.ActionLocationEnum.NoAuto,
SaveReturnUrl = true,
AddToOriginList = true,
});
}
public async Task <ActionResult> UserAccount_Partial(EditModel model)
{
// make sure this user exists
UserManager <UserDefinition> userManager = Managers.GetUserManager();
UserDefinition user;
#if MVC6
user = await userManager.FindByNameAsync(model.OriginalUserName);
#else
user = userManager.FindByName(model.OriginalUserName);
#endif
if (user == null)
{
throw new Error(this.__ResStr("alreadyDeleted", "The user named \"{0}\" has been removed and can no longer be updated.", model.OriginalUserName));
}
if (!ModelState.IsValid)
{
return(PartialView(model));
}
// update email/user name - can't use an existing email address
// get the registration module for some defaults
LoginConfigData config = await LoginConfigDataProvider.GetConfigAsync();
switch (config.RegistrationType)
{
default:
case RegistrationTypeEnum.NameAndEmail: {
using (UserDefinitionDataProvider dataProvider = new UserDefinitionDataProvider()) {
List <DataProviderFilterInfo> filters = DataProviderFilterInfo.Join(null, new DataProviderFilterInfo {
Field = nameof(UserDefinition.Email), Operator = "==", Value = model.Email,
});
UserDefinition userExists = await dataProvider.GetItemAsync(filters);
if (userExists != null && user.UserName != userExists.UserName)
{
ModelState.AddModelError(nameof(model.Email), this.__ResStr("emailUsed", "An account using email address {0} already exists.", model.Email));
return(PartialView(model));
}
}
break;
}
case RegistrationTypeEnum.EmailOnly:
model.UserName = model.Email;
break;
case RegistrationTypeEnum.NameOnly:
model.Email = model.UserName;
break;
}
// save new user info
ObjectSupport.CopyData(model, user); // merge new data into original
model.SetData(user); // and all the data back into model for final display
if (model.OriginalUserName != user.UserName)
{
// user name changed - change data through data provider directly
using (UserDefinitionDataProvider dataProvider = new UserDefinitionDataProvider()) {
UpdateStatusEnum status = await dataProvider.UpdateItemAsync(model.OriginalUserName, user);
switch (status)
{
default:
case UpdateStatusEnum.RecordDeleted:
ModelState.AddModelError(nameof(model.UserName), this.__ResStr("alreadyDeleted", "The user named \"{0}\" has been removed and can no longer be updated.", model.OriginalUserName));
return(PartialView(model));
case UpdateStatusEnum.NewKeyExists:
ModelState.AddModelError(nameof(model.UserName), this.__ResStr("alreadyExists", "A user named \"{0}\" already exists.", model.UserName));
return(PartialView(model));
case UpdateStatusEnum.OK:
break;
}
}
// log the user off and back on so new name takes effect
//IAuthenticationManager authManager = HttpContext.GetOwinContext().Authentication;
//deleted, done in UserLogff authManager.SignOut(DefaultAuthenticationTypes.ExternalCookie, DefaultAuthenticationTypes.ApplicationCookie, DefaultAuthenticationTypes.ExternalBearer);
await LoginModuleController.UserLogoffAsync();
await LoginModuleController.UserLoginAsync(user);
}
else
{
IdentityResult result;
result = await userManager.UpdateAsync(user);
if (!result.Succeeded)
{
throw new Error(string.Join(" - ", (from e in result.Errors select e.Description)));
}
}
return(FormProcessed(model, this.__ResStr("okSaved", "Your account information has been saved"), OnClose: OnCloseEnum.ReloadPage, OnPopupClose: OnPopupCloseEnum.ReloadParentPage, ForceRedirect: true));// reload for tiny login module to refresh
}
public async Task <ActionResult> SetupExternalAccount_Partial(SetupExternalAccountModel model)
{
LoginConfigData config = await LoginConfigDataProvider.GetConfigAsync();
bool allowNewUser = config.AllowUserRegistration;
ExtUserInfo extInfo = await GetUserInfo(config);
model.AllowNewUser = allowNewUser;
model.ExistingUser = extInfo.ExistingUser != null;
model.LoginProviderDisplay = extInfo.LoginProviderDisplay;
model.RegistrationType = config.RegistrationType;
if (extInfo.ExistingUser != null)
{
model.UserName = extInfo.Name;
model.Email = extInfo.Email;
}
if (!ModelState.IsValid)
{
return(PartialView(model));
}
UserDefinition user;
if (allowNewUser && extInfo.ExistingUser == null)
{
// set new user info
user = new UserDefinition();
switch (config.RegistrationType)
{
default:
case RegistrationTypeEnum.NameAndEmail:
user.UserName = model.UserName;
user.Email = model.Email;
break;
case RegistrationTypeEnum.EmailOnly:
user.UserName = user.Email = model.Email;
break;
case RegistrationTypeEnum.NameOnly:
user.UserName = user.Email = model.UserName;
break;
}
if (config.VerifyNewUsers)
{
user.UserStatus = UserStatusEnum.NeedValidation;
}
else if (config.ApproveNewUsers)
{
user.UserStatus = UserStatusEnum.NeedApproval;
}
else
{
user.UserStatus = UserStatusEnum.Approved;
}
user.RegistrationIP = Manager.UserHostAddress;
// create new local account
var createResult = await Managers.GetUserManager().CreateAsync(user);
if (!createResult.Succeeded)
{
throw new Error(string.Join(" - ", (from e in createResult.Errors select e.Description)));
}
}
else
{
// invited user
// verify invitation
if (extInfo.ExistingUser.VerificationCode != model.InvitationCode)
{
ModelState.AddModelError(nameof(model.InvitationCode), this.__ResStr("badInvite", "The invitation code is invalid"));
return(PartialView(model));
}
user = extInfo.ExistingUser;
user.UserStatus = UserStatusEnum.Approved;
}
// add login provider info
IdentityResult result = await Managers.GetUserManager().AddLoginAsync(user, extInfo.LoginInfo);
if (!result.Succeeded)
{
throw new Error(string.Join(" - ", (from e in result.Errors select e.Description)));
}
// send appropriate email based on account status
Emails emails = new Emails();
if (user.UserStatus == UserStatusEnum.NeedValidation)
{
await emails.SendVerificationAsync(user, config.BccVerification?Manager.CurrentSite.AdminEmail : null);
string nextPage = string.IsNullOrWhiteSpace(config.VerificationPendingUrl) ? Manager.CurrentSite.HomePageUrl : config.VerificationPendingUrl;
return(FormProcessed(model, this.__ResStr("okAwaitRegistration", "An email has just been sent to your email address \"{0}\" to complete the registration. Allow a few minutes for delivery. Once received, please use the information in the email to complete the registration.", model.Email),
this.__ResStr("okRegTitle", "Welcome!"),
NextPage: nextPage));
}
else if (user.UserStatus == UserStatusEnum.NeedApproval)
{
await emails.SendApprovalNeededAsync(user);
string nextPage = string.IsNullOrWhiteSpace(config.ApprovalPendingUrl) ? Manager.CurrentSite.HomePageUrl : config.ApprovalPendingUrl;
return(FormProcessed(model, this.__ResStr("okAwaitApproval", "An email has just been sent to the site administrator for approval of your new account. Once processed and approved, you will receive an email confirming your approval."),
this.__ResStr("okRegTitle", "Welcome!"),
NextPage: nextPage));
}
else if (user.UserStatus == UserStatusEnum.Approved)
{
if (config.NotifyAdminNewUsers)
{
await emails.SendNewUserCreatedAsync(user);
}
await LoginModuleController.UserLoginAsync(user, config.PersistentLogin);
return(FormProcessed(model, this.__ResStr("okRegText", "Your new account has been successfully registered."), this.__ResStr("okRegTitle", "Welcome!"),
NextPage: Manager.ReturnToUrl, ForceRedirect: true));
}
else
{
throw new InternalError("badUserStatus", "Unexpected account status {0}", user.UserStatus);
}
}
public async Task <ActionResult> UserPassword_Partial(EditModel model)
{
// get current user we're changing
if (!Manager.CurrentContext.User.Identity.IsAuthenticated)
{
throw new Error(this.__ResStr("noUser", "There is no logged on user"));
}
string userName = User.Identity.Name;
using (UserLoginInfoDataProvider logInfoDP = new UserLoginInfoDataProvider()) {
string ext = await logInfoDP.GetExternalLoginProviderAsync(Manager.UserId);
if (ext != null)
{
throw new Error(this.__ResStr("extUserPswd", "This account can only be accessed using an external login provider"));
}
}
UserManager <UserDefinition> userManager = Managers.GetUserManager();
UserDefinition user = await userManager.FindByNameAsync(userName);
if (user == null)
{
throw new Error(this.__ResStr("notFound", "User \"{0}\" not found."), userName);
}
model.SetData(user);
if (Module.ShowPasswordRules)
{
using (LoginConfigDataProvider logConfigDP = new LoginConfigDataProvider()) {
model.PasswordRules = logConfigDP.PasswordRules;
}
}
if (!ModelState.IsValid)
{
return(PartialView(model));
}
// change the password
IPasswordValidator <UserDefinition> passVal = (IPasswordValidator <UserDefinition>)YetaWFManager.ServiceProvider.GetService(typeof(IPasswordValidator <UserDefinition>));
IdentityResult result = await passVal.ValidateAsync(userManager, user, model.NewPassword);
if (!result.Succeeded)
{
foreach (var err in result.Errors)
{
ModelState.AddModelError(nameof(model.NewPassword), err.Description);
}
return(PartialView(model));
}
result = await userManager.ChangePasswordAsync(user, model.OldPassword ?? "", model.NewPassword);
if (!result.Succeeded)
{
foreach (var err in result.Errors)
{
ModelState.AddModelError(nameof(model.OldPassword), err.Description);
}
return(PartialView(model));
}
IPasswordHasher <UserDefinition> passwordHasher = (IPasswordHasher <UserDefinition>)YetaWFManager.ServiceProvider.GetService(typeof(IPasswordHasher <UserDefinition>));
user.PasswordHash = passwordHasher.HashPassword(user, model.NewPassword);
// update user info
LoginConfigData config = await LoginConfigDataProvider.GetConfigAsync();
user.LastPasswordChangedDate = DateTime.UtcNow;
user.PasswordChangeIP = Manager.UserHostAddress;
bool forceReload = false;
if (user.NeedsNewPassword)
{
forceReload = true; // we need to reload the page to get rid of the warning from NeedPasswordDisplay
}
user.NeedsNewPassword = false;
user.PasswordPlainText = config.SavePlainTextPassword ? model.NewPassword : null;
user.ResetKey = null;
user.ResetValidUntil = null;
// finally update the user definition
result = await userManager.UpdateAsync(user);
if (!result.Succeeded)
{
throw new Error(string.Join(" - ", (from e in result.Errors select e.Description)));
}
// logoff/logon for any side effects in identity (like SecurityStamp update/cookies)
await LoginModuleController.UserLoginAsync(user);
return(FormProcessed(model, this.__ResStr("okSaved", "Your new password has been saved"), ForceRedirect: forceReload));
}
public async Task <ActionResult> Register_Partial(RegisterModel model)
{
LoginConfigData config = await LoginConfigDataProvider.GetConfigAsync();
if (!config.AllowUserRegistration)
{
throw new Error(this.__ResStr("cantRegister", "This site does not allow new user registration"));
}
if (model.ShowCaptcha != config.Captcha && !Manager.IsLocalHost)
{
throw new InternalError("Hidden field tampering detected");
}
if (!model.ShowCaptcha && ModelState[nameof(model.Captcha)] != null)
{
ModelState[nameof(model.Captcha)].ValidationState = Microsoft.AspNetCore.Mvc.ModelBinding.ModelValidationState.Valid;
}
model.RegistrationType = config.RegistrationType;// don't trust what we get from user
if (Module.ShowPasswordRules)
{
using (LoginConfigDataProvider logConfigDP = new LoginConfigDataProvider()) {
model.PasswordRules = logConfigDP.PasswordRules;
}
}
await model.UpdateAsync();
if (!ModelState.IsValid)
{
return(PartialView(model));
}
// Create a new user and save all info
UserDefinition user = new UserDefinition();
switch (config.RegistrationType)
{
default:
case RegistrationTypeEnum.NameAndEmail:
user.UserName = model.UserName;
user.Email = model.Email;
break;
case RegistrationTypeEnum.EmailOnly:
user.UserName = user.Email = model.Email;
break;
case RegistrationTypeEnum.NameOnly:
user.UserName = user.Email = model.UserName;
break;
}
user.PasswordPlainText = config.SavePlainTextPassword ? model.Password : null;
if (config.RegistrationType == RegistrationTypeEnum.NameAndEmail)
{
using (UserDefinitionDataProvider dataProvider = new UserDefinitionDataProvider()) {
// Email == user.Email
List <DataProviderFilterInfo> filters = new List <DataProviderFilterInfo> {
new DataProviderFilterInfo {
Field = nameof(UserDefinition.Email), Operator = "==", Value = user.Email,
},
};
UserDefinition userExists = await dataProvider.GetItemAsync(filters);
if (userExists != null && user.UserName != userExists.Email)
{
ModelState.AddModelError(nameof(model.Email), this.__ResStr("emailUsed", "An account with email address {0} already exists.", user.Email));
return(PartialView(model));
}
}
}
// set account status
if (config.VerifyNewUsers)
{
user.UserStatus = UserStatusEnum.NeedValidation;
}
else if (config.ApproveNewUsers)
{
user.UserStatus = UserStatusEnum.NeedApproval;
}
else
{
user.UserStatus = UserStatusEnum.Approved;
}
user.RegistrationIP = Manager.UserHostAddress;
// create user
var result = await Managers.GetUserManager().CreateAsync(user, model.Password);
if (!result.Succeeded)
{
foreach (var error in result.Errors)
{
ModelState.AddModelError(nameof(model.UserName), error.Description);
ModelState.AddModelError(nameof(model.Email), error.Description);
ModelState.AddModelError(nameof(model.Password), error.Description);
}
return(PartialView(model));
}
// send appropriate email based on account status
Emails emails = new Emails();
if (user.UserStatus == UserStatusEnum.NeedValidation)
{
await emails.SendVerificationAsync(user, config.BccVerification?Manager.CurrentSite.AdminEmail : null);
string nextPage = string.IsNullOrWhiteSpace(config.VerificationPendingUrl) ? Manager.CurrentSite.HomePageUrl : config.VerificationPendingUrl;
return(FormProcessed(model, this.__ResStr("okAwaitRegistration", "An email has just been sent to your email address \"{0}\" to complete the registration. Allow a few minutes for delivery. Once received, use the information in the email to complete the registration.", model.Email),
this.__ResStr("okRegTitle", "Welcome!"),
NextPage: nextPage));
}
else if (user.UserStatus == UserStatusEnum.NeedApproval)
{
await emails.SendApprovalNeededAsync(user);
string nextPage = string.IsNullOrWhiteSpace(config.ApprovalPendingUrl) ? Manager.CurrentSite.HomePageUrl : config.ApprovalPendingUrl;
return(FormProcessed(model, this.__ResStr("okAwaitApproval", "An email has just been sent to the site administrator for approval of your new account. Once processed and approved, you will receive an email confirming your approval."),
this.__ResStr("okRegTitle", "Welcome!"),
NextPage: nextPage));
}
else if (user.UserStatus == UserStatusEnum.Approved)
{
if (config.NotifyAdminNewUsers)
{
await emails.SendNewUserCreatedAsync(user);
}
await LoginModuleController.UserLoginAsync(user, config.PersistentLogin);
string nextUrl = null;
if (Manager.HaveReturnToUrl)
{
nextUrl = Manager.ReturnToUrl;
}
if (string.IsNullOrWhiteSpace(nextUrl) && !string.IsNullOrWhiteSpace(Module.PostRegisterUrl))
{
nextUrl = Module.PostRegisterUrl;
if (Module.PostRegisterQueryString)
{
nextUrl += model.QueryString.AddQSSeparator() + model.QueryString;
}
}
if (string.IsNullOrWhiteSpace(nextUrl))
{
nextUrl = await Resource.ResourceAccess.GetUserPostLoginUrlAsync((from u in user.RolesList select u.RoleId).ToList());
}
if (string.IsNullOrWhiteSpace(nextUrl))
{
nextUrl = Manager.CurrentSite.PostLoginUrl;
}
if (!string.IsNullOrWhiteSpace(nextUrl))
{
return(FormProcessed(model, this.__ResStr("okRegText", "Your new account has been successfully registered."), this.__ResStr("okRegTitle", "Welcome!"),
OnClose: OnCloseEnum.GotoNewPage, OnPopupClose: OnPopupCloseEnum.GotoNewPage, NextPage: nextUrl, ForceRedirect: true));
}
return(FormProcessed(model, this.__ResStr("okRegText", "Your new account has been successfully registered."), this.__ResStr("okRegTitle", "Welcome!"), ForceRedirect: true));
}
else
{
throw new InternalError("badUserStatus", "Unexpected account status {0}", user.UserStatus);
}
}
public async Task <ActionResult> ResetPassword_Partial(EditModel model)
{
UserManager <UserDefinition> userManager = Managers.GetUserManager();
UserDefinition user;
#if MVC6
user = await userManager.FindByIdAsync(model.UserId.ToString());
#else
user = userManager.FindById(model.UserId.ToString());
#endif
if (user == null)
{
throw new Error(this.__ResStr("notFound", "User account not found."));
}
using (UserLoginInfoDataProvider logInfoDP = new UserLoginInfoDataProvider()) {
if (await logInfoDP.IsExternalUserAsync(model.UserId))
{
throw new Error(this.__ResStr("extUser", "Your account uses an external login provider - The password (if available) must be set up using the external login provider."));
}
}
if (Module.ShowPasswordRules)
{
using (LoginConfigDataProvider logConfigDP = new LoginConfigDataProvider()) {
model.PasswordRules = logConfigDP.PasswordRules;
}
}
if (!ModelState.IsValid)
{
return(PartialView(model));
}
Guid?resetKey = null;
if (user.ResetKey == null || user.ResetValidUntil == null || user.ResetValidUntil < DateTime.UtcNow)
{
ModelState.AddModelError(nameof(model.ResetKey), this.__ResStr("expired", "The reset key has expired and is no longer valid"));
}
else
{
try {
resetKey = new Guid(model.ResetKey);
} catch (Exception) {
ModelState.AddModelError(nameof(model.ResetKey), this.__ResStr("invReset", "The reset key is invalid - Please make sure to copy/paste the key in its entirety"));
}
}
if (resetKey != null && user.ResetKey != (Guid)resetKey)
{
ModelState.AddModelError(nameof(model.ResetKey), this.__ResStr("invReset", "The reset key is invalid - Please make sure to copy/paste the key in its entirety"));
}
if (!ModelState.IsValid)
{
return(PartialView(model));
}
// change the password
IdentityResult result;
#if MVC6
IPasswordValidator <UserDefinition> passVal = (IPasswordValidator <UserDefinition>)YetaWFManager.ServiceProvider.GetService(typeof(IPasswordValidator <UserDefinition>));
result = await passVal.ValidateAsync(userManager, user, model.NewPassword);
#else
result = await userManager.PasswordValidator.ValidateAsync(model.NewPassword);
#endif
if (!result.Succeeded)
{
foreach (var err in result.Errors)
{
ModelState.AddModelError(nameof(model.NewPassword), err.Description);
}
return(PartialView(model));
}
#if MVC6
await userManager.RemovePasswordAsync(user);
result = await userManager.AddPasswordAsync(user, model.NewPassword);
#else
await userManager.RemovePasswordAsync(user.Id);
result = await userManager.AddPasswordAsync(user.Id, model.NewPassword);
#endif
if (!result.Succeeded)
{
foreach (var err in result.Errors)
{
#if MVC6
ModelState.AddModelError(nameof(model.NewPassword), err.Description);
#else
ModelState.AddModelError(nameof(model.NewPassword), err);
#endif
}
return(PartialView(model));
}
#if MVC6
IPasswordHasher <UserDefinition> passwordHasher = (IPasswordHasher <UserDefinition>)YetaWFManager.ServiceProvider.GetService(typeof(IPasswordHasher <UserDefinition>));
user.PasswordHash = passwordHasher.HashPassword(user, model.NewPassword);
#else
user.PasswordHash = userManager.PasswordHasher.HashPassword(model.NewPassword);
#endif
// update user info
LoginConfigData config = await LoginConfigDataProvider.GetConfigAsync();
user.LastPasswordChangedDate = DateTime.UtcNow;
user.PasswordChangeIP = Manager.UserHostAddress;
bool forceReload = false;
if (user.NeedsNewPassword)
{
forceReload = true; // we need to reload the page to get rid of the warning from NeedPasswordDisplay
}
user.NeedsNewPassword = false;
user.PasswordPlainText = config.SavePlainTextPassword ? model.NewPassword : null;
user.ResetKey = null;
user.ResetValidUntil = null;
// finally update the user definition
#if MVC6
result = await userManager.UpdateAsync(user);
#else
result = userManager.Update(user);
#endif
if (!result.Succeeded)
{
foreach (var err in result.Errors)
{
#if MVC6
ModelState.AddModelError(nameof(model.NewPassword), err.Description);
#else
ModelState.AddModelError(nameof(model.NewPassword), err);
#endif
}
return(PartialView(model));
}
// logoff/logon for any side effects in identity (like SecurityStamp update/cookies)
await LoginModuleController.UserLoginAsync(user);
return(FormProcessed(model, this.__ResStr("okSaved", "Your new password has been saved"), ForceRedirect: forceReload));
}
public async Task <ActionResult> UsersEdit_Partial(EditModel model)
{
using (UserDefinitionDataProvider dataProvider = new UserDefinitionDataProvider()) {
string originalUserName = model.OriginalUserName;
UserDefinition user = await dataProvider.GetItemAsync(originalUserName);
if (user == null)
{
throw new Error(this.__ResStr("alreadyDeleted", "The user named \"{0}\" has been removed and can no longer be updated.", originalUserName));
}
if (!ModelState.IsValid)
{
return(PartialView(model));
}
LoginConfigData config = await LoginConfigDataProvider.GetConfigAsync();
switch (config.RegistrationType)
{
case RegistrationTypeEnum.NameAndEmail: {
List <DataProviderFilterInfo> filters = DataProviderFilterInfo.Join(null, new DataProviderFilterInfo {
Field = nameof(UserDefinition.Email), Operator = "==", Value = model.Email,
});
UserDefinition userExists = await dataProvider.GetItemAsync(filters);
if (userExists != null && user.UserName != userExists.UserName)
{
ModelState.AddModelError(nameof(model.Email), this.__ResStr("emailUsed", "An account using email address {0} already exists.", model.Email));
return(PartialView(model));
}
break;
}
case RegistrationTypeEnum.EmailOnly:
model.UserName = model.Email;
break;
case RegistrationTypeEnum.NameOnly:
model.Email = model.UserName;
break;
}
user = model.GetData(user); // merge new data into original
model.SetData(user); // and all the data back into model for final display
switch (await dataProvider.UpdateItemAsync(originalUserName, user))
{
default:
case UpdateStatusEnum.RecordDeleted:
throw new Error(this.__ResStr("alreadyDeleted", "The user named \"{0}\" has been removed and can no longer be updated.", originalUserName));
case UpdateStatusEnum.NewKeyExists:
ModelState.AddModelError(nameof(model.UserName), this.__ResStr("alreadyExists", "A user named \"{0}\" already exists.", model.UserName));
return(PartialView(model));
case UpdateStatusEnum.OK:
break;
}
return(FormProcessed(model, this.__ResStr("okSaved", "User updated"), OnPopupClose: OnPopupCloseEnum.ReloadModule));
}
}
public async Task <ActionResult> ForgotPassword_Partial(EditModel model)
{
LoginConfigData config = await LoginConfigDataProvider.GetConfigAsync();
if (model.ShowCaptcha != config.CaptchaForgotPassword)
{
throw new InternalError("Hidden field tampering detected");
}
await model.UpdateAsync();
model.ShowCaptcha = config.CaptchaForgotPassword;
model.RegistrationType = config.RegistrationType;
if (!ModelState.IsValid)
{
return(PartialView(model));
}
using (UserDefinitionDataProvider userDP = new UserDefinitionDataProvider()) {
UserDefinition userDef;
switch (model.RegistrationType)
{
case RegistrationTypeEnum.NameOnly:
userDef = await userDP.GetItemAsync(model.UserName);
if (userDef == null)
{
ModelState.AddModelError(nameof(model.UserName), this.__ResStr("badName", "According to our records there is no account associated with this name"));
return(PartialView(model));
}
break;
case RegistrationTypeEnum.NameAndEmail:
userDef = await userDP.GetItemAsync(model.UserNameOrEmail);
if (userDef == null)
{
userDef = await userDP.GetItemByEmailAsync(model.UserNameOrEmail);
if (userDef == null)
{
ModelState.AddModelError(nameof(model.UserNameOrEmail), this.__ResStr("badNameEmail", "According to our records there is no account associated with this name or email address"));
return(PartialView(model));
}
}
break;
default:
case RegistrationTypeEnum.EmailOnly:
userDef = await userDP.GetItemByEmailAsync(model.Email);
if (userDef == null)
{
ModelState.AddModelError(nameof(model.Email), this.__ResStr("badEmail", "According to our records there is no account associated with this email address"));
return(PartialView(model));
}
break;
}
using (UserLoginInfoDataProvider logInfoDP = new UserLoginInfoDataProvider()) {
if (await logInfoDP.IsExternalUserAsync(userDef.UserId))
{
ModelState.AddModelError(nameof(model.Email), this.__ResStr("extEmail", "According to our records there is no account associated with this email address"));
ModelState.AddModelError(nameof(model.UserName), this.__ResStr("extName", "According to our records there is no account associated with this name"));
ModelState.AddModelError(nameof(model.UserNameOrEmail), this.__ResStr("extUser", "According to our records there is no account associated with this name or email address"));
return(PartialView(model));
}
}
switch (userDef.UserStatus)
{
case UserStatusEnum.Approved:
Emails emails = new Emails();
if (config.SavePlainTextPassword)
{
await emails.SendForgottenEmailAsync(userDef, config.BccForgottenPassword?Manager.CurrentSite.AdminEmail : null);
string from = emails.GetSendingEmailAddress();
return(FormProcessed(model, this.__ResStr("okForgot", "We just sent an email to your email address with your password information - Please allow a few minutes for delivery and make sure your spam filters allow emails from {0}", from), OnClose: OnCloseEnum.Nothing, OnPopupClose: OnPopupCloseEnum.ReloadModule));
}
else
{
if (userDef.ResetKey != null && userDef.ResetValidUntil != null && userDef.ResetValidUntil > DateTime.UtcNow)
{
// preserve existing key in case user resends
}
else
{
userDef.ResetKey = Guid.NewGuid();
userDef.ResetValidUntil = DateTime.UtcNow.Add(config.ResetTimeSpan);
if (await userDP.UpdateItemAsync(userDef) != Core.DataProvider.UpdateStatusEnum.OK) // update reset key info
{
throw new Error(this.__ResStr("resetUpdate", "User information could not be updated"));
}
}
await emails.SendPasswordResetEmailAsync(userDef, config.BccForgottenPassword?Manager.CurrentSite.AdminEmail : null);
string from = emails.GetSendingEmailAddress();
return(FormProcessed(model, this.__ResStr("okReset", "We just sent an email to your email address to reset your password - Please allow a few minutes for delivery and make sure your spam filters allow emails from {0}", from), OnClose: OnCloseEnum.Nothing, OnPopupClose: OnPopupCloseEnum.ReloadModule));
}
case UserStatusEnum.NeedApproval:
throw new Error(this.__ResStr("needApproval", "This account has not yet been approved and is awaiting approval by the site administrator"));
case UserStatusEnum.NeedValidation:
throw new Error(this.__ResStr("needValidation", "This account has not yet been verified - Please check your emails for our verification email"));
case UserStatusEnum.Rejected:
throw new Error(this.__ResStr("rejected", "This account has been rejected and is not accessible"));
case UserStatusEnum.Suspended:
throw new Error(this.__ResStr("suspended", "This account has been suspended and is not accessible"));
default:
throw new Error(this.__ResStr("unknownState", "This account is in an undefined state and is not accessible"));
}
}
}
public async Task <IActionResult> ExternalLoginCallback(string returnUrl = null, string remoteError = null)
{
if (remoteError != null)
{
throw new Error(this.__ResStr("extErr", "The external login provider reported this error: {0}", remoteError));
}
SignInManager <UserDefinition> _signinManager = (SignInManager <UserDefinition>)YetaWFManager.ServiceProvider.GetService(typeof(SignInManager <UserDefinition>));
ExternalLoginInfo loginInfo = await _signinManager.GetExternalLoginInfoAsync();
if (loginInfo == null)
{
Logging.AddErrorLog("AuthenticationManager.GetExternalLoginInfoAsync() returned null");
return(Redirect(Helper.GetSafeReturnUrl(Manager.CurrentSite.LoginUrl)));
}
using (LoginConfigDataProvider logConfigDP = new LoginConfigDataProvider()) {
List <LoginConfigDataProvider.LoginProviderDescription> loginProviders = await logConfigDP.GetActiveExternalLoginProvidersAsync();
if ((from l in loginProviders where l.InternalName == loginInfo.LoginProvider select l).FirstOrDefault() == null)
{
Logging.AddErrorLog("Callback from external login provider {0} which is not active", loginInfo.LoginProvider);
return(Redirect(Helper.GetSafeReturnUrl(Manager.CurrentSite.LoginUrl)));
}
}
// get our registration defaults
LoginConfigData config = await LoginConfigDataProvider.GetConfigAsync();
// Sign in the user with this external login provider if the user already has a login
UserDefinition user = await Managers.GetUserManager().FindByLoginAsync(loginInfo.LoginProvider, loginInfo.ProviderKey);
if (user == null)
{
// If the user does not have an account, then prompt the user to create an account
// we will go to a page where the user can set up a local account
Manager.OriginList = new List <Origin>();
if (!string.IsNullOrWhiteSpace(returnUrl))
{
Manager.OriginList.Add(new Origin()
{
Url = returnUrl
}); // where to go after setup
}
Manager.OriginList.Add(new Origin()
{
Url = Helper.GetSafeReturnUrl(Manager.CurrentSite.ExternalAccountSetupUrl)
}); // setup
return(Redirect(Manager.ReturnToUrl));
}
if (string.IsNullOrWhiteSpace(returnUrl) && Manager.HaveReturnToUrl)
{
returnUrl = Manager.ReturnToUrl;
}
if (string.IsNullOrWhiteSpace(returnUrl))
{
returnUrl = await Resource.ResourceAccess.GetUserPostLoginUrlAsync((from u in user.RolesList select u.RoleId).ToList());
}
if (string.IsNullOrWhiteSpace(returnUrl))
{
returnUrl = Manager.CurrentSite.PostLoginUrl;
}
returnUrl = Helper.GetSafeReturnUrl(returnUrl);
// determine what to do based on account status
if (user.UserStatus == UserStatusEnum.Approved)
{
await LoginModuleController.UserLoginAsync(user);
Logging.AddLog("User {0} - logged on", user.UserName);
returnUrl = QueryHelper.AddRando(returnUrl); // to defeat client-side caching
return(Redirect(returnUrl));
}
else if (user.UserStatus == UserStatusEnum.Rejected)
{
await LoginModuleController.UserLogoffAsync();
Logging.AddErrorLog("User {0} - rejected user", user.UserName);
if (string.IsNullOrWhiteSpace(config.RejectedUrl))
{
return(Redirect(MessageUrl("Your account has been rejected by the site administrator.")));
}
return(Redirect(Helper.GetSafeReturnUrl(config.RejectedUrl)));
}
else if (user.UserStatus == UserStatusEnum.Suspended)
{
await LoginModuleController.UserLogoffAsync();
Logging.AddErrorLog("User {0} - suspended user", user.UserName);
if (string.IsNullOrWhiteSpace(config.SuspendedUrl))
{
return(Redirect(MessageUrl("Your account has been suspended by the site administrator.")));
}
return(Redirect(Helper.GetSafeReturnUrl(config.SuspendedUrl)));
}
else if (user.UserStatus == UserStatusEnum.NeedValidation)
{
await LoginModuleController.UserLogoffAsync();
Logging.AddErrorLog("User {0} - not yet validated", user.UserName);
if (string.IsNullOrWhiteSpace(config.VerificationPendingUrl))
{
return(Redirect(MessageUrl(this.__ResStr("notValidated", "Your account has not yet been verified. You will receive an email with verification information. Once received, please use the information in the email to complete the registration."))));
}
return(Redirect(Helper.GetSafeReturnUrl(config.VerificationPendingUrl)));
}
else if (user.UserStatus == UserStatusEnum.NeedApproval)
{
await LoginModuleController.UserLogoffAsync();
Logging.AddErrorLog("User {0} - not yet approved", user.UserName);
if (string.IsNullOrWhiteSpace(config.ApprovalPendingUrl))
{
return(Redirect(MessageUrl(this.__ResStr("notApproved", "Your account has not yet been approved by the site administrator. You will receive an email confirmation as soon as your account is active."))));
}
return(Redirect(Helper.GetSafeReturnUrl(config.ApprovalPendingUrl)));
}
else
{
await LoginModuleController.UserLogoffAsync();
throw new InternalError("badUserStatus", "Unexpected account status {0}", user.UserStatus);
}
}