public async Task <IViewComponentResult> InvokeAsync()
{
var menuItems = await _queryExecutor.ExecuteAsync(new GetPermittedAdminModulesQuery());
var vm = new AdminMenuViewModel();
vm.ManageSiteModules = menuItems
.Where(m => m.MenuCategory == AdminModuleMenuCategory.ManageSite)
.SetStandardOrdering()
.ToList();
vm.SettingsModules = menuItems
.Where(m => m.MenuCategory == AdminModuleMenuCategory.Settings)
.SetStandardOrdering()
.ToList();
var selectedItem = menuItems
.Select(m => new {
Module = m,
Link = m.GetMenuLinkByPath(Request.Path)
})
.Where(m => m.Link != null)
.FirstOrDefault();
if (selectedItem != null)
{
vm.SelectedCategory = selectedItem.Module.MenuCategory;
vm.SelectedModule = selectedItem.Module;
}
var viewPath = ViewPathFormatter.View("Shared", "Components/AdminMenu");
return(View(viewPath, vm));
}
public async Task <ActionResult> ResetPassword(CompletePasswordResetViewModel vm)
{
var user = await _userContextService.GetCurrentContextAsync();
if (user.IsCofoundryUser())
{
return(await GetLoggedInDefaultRedirectActionAsync());
}
var template = new PasswordChangedTemplate();
var settings = await _queryExecutor.ExecuteAsync(new GetSettingsQuery <GeneralSiteSettings>());
template.ApplicationName = settings.ApplicationName;
await _authenticationHelper.CompletePasswordResetAsync(this, vm, template, _adminUserArea);
if (ModelState.IsValid)
{
var completeViewPath = ViewPathFormatter.View(CONTROLLER_NAME, nameof(ResetPassword) + "Complete");
return(View(completeViewPath));
}
var viewPath = ViewPathFormatter.View(CONTROLLER_NAME, nameof(ResetPassword));
return(View(viewPath, vm));
}
public async Task <ActionResult> ChangePassword(string returnUrl, ChangePasswordViewModel vm)
{
var redirectAction = await ValidateChangePasswordRouteAsync();
if (redirectAction != null)
{
return(redirectAction);
}
await _contentRepository
.WithModelState(this)
.Users()
.UpdatePasswordByCredentialsAsync(new UpdateUserPasswordByCredentialsCommand()
{
UserAreaCode = CofoundryAdminUserArea.Code,
Username = vm.Username,
NewPassword = vm.NewPassword,
OldPassword = vm.OldPassword
});
ViewBag.ReturnUrl = RedirectUrlHelper.GetAndValidateReturnUrl(this);
var viewPath = ViewPathFormatter.View(CONTROLLER_NAME, nameof(ChangePassword));
return(View(viewPath, vm));
}
public ActionResult ResetPassword(string i, string t)
{
var user = _userContextService.GetCurrentContext();
if (user.IsCofoundryUser())
{
return(GetLoggedInDefaultRedirectAction());
}
var request = _authenticationHelper.IsPasswordRequestValid(this, i, t, new CofoundryAdminUserArea());
if (!request.IsValid)
{
return(View("ResetPasswordRequestInvalid", request));
}
var vm = new CompletePasswordResetViewModel();
vm.UserPasswordResetRequestId = i;
vm.Token = t;
var viewPath = ViewPathFormatter.View(CONTROLLER_NAME, nameof(ResetPassword));
return(View(viewPath, vm));
}
public ActionResult Index()
{
var definition = RouteData.DataTokens["Definition"] as ICustomEntityDefinition;
var options = new CustomEntityModuleOptions()
{
CustomEntityDefinitionCode = definition.CustomEntityDefinitionCode,
ForceUrlSlugUniqueness = definition.ForceUrlSlugUniqueness,
HasLocale = definition.HasLocale,
AutoGenerateUrlSlug = definition.AutoGenerateUrlSlug,
AutoPublish = definition.AutoPublish,
Name = definition.NamePlural,
NameSingular = definition.Name,
Terms = definition.GetTerms()
};
if (definition is IOrderableCustomEntityDefinition)
{
options.Ordering = ((IOrderableCustomEntityDefinition)definition).Ordering;
}
var viewPath = ViewPathFormatter.View("CustomEntities", nameof(Index));
return(View(viewPath, options));
}
public async Task <ActionResult> ResetPassword(string i, string t)
{
var user = await _userContextService.GetCurrentContextAsync();
if (user.IsCofoundryUser())
{
return(await GetLoggedInDefaultRedirectActionAsync());
}
var request = await _authenticationHelper.IsPasswordRequestValidAsync(this, i, t, _adminUserArea);
if (!request.IsValid)
{
var invalidViewPath = ViewPathFormatter.View(CONTROLLER_NAME, nameof(ResetPassword) + "RequestInvalid");
return(View(invalidViewPath, request));
}
var vm = new CompletePasswordResetViewModel();
vm.UserPasswordResetRequestId = i;
vm.Token = t;
var viewPath = ViewPathFormatter.View(CONTROLLER_NAME, nameof(ResetPassword));
return(View(viewPath, vm));
}
public PartialViewResult MainMenu()
{
var menuItems = _queryExecutor.Execute(new GetPermittedAdminModulesQuery());
var vm = new AdminMenuViewModel();
vm.ManageSiteModules = menuItems
.Where(m => m.MenuCategory == AdminModuleMenuCategory.ManageSite)
.SetStandardOrdering();
vm.SettingsModules = menuItems
.Where(m => m.MenuCategory == AdminModuleMenuCategory.Settings)
.SetStandardOrdering();
var selectedItem = menuItems
.Select(m => new {
Module = m,
Link = m.GetMenuLinkByPath(Request.Url.LocalPath)
})
.Where(m => m.Link != null)
.FirstOrDefault();
if (selectedItem != null)
{
vm.SelectedCategory = selectedItem.Module.MenuCategory;
vm.SelectedModule = selectedItem.Module;
}
var viewPath = ViewPathFormatter.View("AdminMenu", "Partials/" + nameof(MainMenu));
return(PartialView(vm));
}
public ActionResult ChangePassword(string returnUrl, ChangePasswordViewModel vm)
{
var user = _userContextService.GetCurrentContext();
if (!user.IsPasswordChangeRequired)
{
return(GetLoggedInDefaultRedirectAction());
}
_accountManagementControllerHelper.ChangePassword(this, vm);
if (ModelState.IsValid)
{
if (!string.IsNullOrEmpty(returnUrl))
{
return(Redirect(returnUrl));
}
else
{
return(GetLoggedInDefaultRedirectAction());
}
}
var viewPath = ViewPathFormatter.View(CONTROLLER_NAME, nameof(ChangePassword));
return(View(viewPath, vm));
}
public async Task <ActionResult> ResetPassword(CompleteAccountRecoveryViewModel vm)
{
if (await IsLoggedInAsync())
{
return(await GetLoggedInDefaultRedirectActionAsync());
}
var token = _authorizedTaskTokenUrlHelper.ParseTokenFromQuery(Request.Query);
await _contentRepository
.WithModelState(this)
.Users()
.AccountRecovery()
.CompleteAsync(new CompleteUserAccountRecoveryViaEmailCommand()
{
UserAreaCode = CofoundryAdminUserArea.Code,
Token = token,
NewPassword = vm.NewPassword
});
if (ModelState.IsValid)
{
var completeViewPath = ViewPathFormatter.View(CONTROLLER_NAME, nameof(ResetPassword) + "Complete");
return(View(completeViewPath));
}
var viewPath = ViewPathFormatter.View(CONTROLLER_NAME, nameof(ResetPassword));
return(View(viewPath, vm));
}
public async Task <ActionResult> ResetPassword()
{
if (await IsLoggedInAsync())
{
return(await GetLoggedInDefaultRedirectActionAsync());
}
var token = _authorizedTaskTokenUrlHelper.ParseTokenFromQuery(Request.Query);
var requestValidationResult = await _contentRepository
.WithModelState(this)
.Users()
.AccountRecovery()
.Validate(new ValidateUserAccountRecoveryByEmailQuery()
{
UserAreaCode = CofoundryAdminUserArea.Code,
Token = token
})
.ExecuteAsync();
if (!ModelState.IsValid)
{
var invalidViewPath = ViewPathFormatter.View(CONTROLLER_NAME, nameof(ResetPassword) + "RequestInvalid");
return(View(invalidViewPath, requestValidationResult));
}
var vm = new CompleteAccountRecoveryViewModel();
var viewPath = ViewPathFormatter.View(CONTROLLER_NAME, nameof(ResetPassword));
return(View(viewPath, vm));
}
public async Task <ViewResult> ForgotPassword(ForgotPasswordViewModel command)
{
var template = new ResetPasswordTemplate();
await _authenticationHelper.SendPasswordResetNotificationAsync(this, command, template, new CofoundryAdminUserArea());
var viewPath = ViewPathFormatter.View(CONTROLLER_NAME, nameof(ForgotPassword));
return(View(viewPath, command));
}
public async Task <ActionResult> Login()
{
if (await IsLoggedInAsync())
{
return(await GetLoggedInDefaultRedirectActionAsync());
}
var viewPath = ViewPathFormatter.View(CONTROLLER_NAME, nameof(Login));
var vm = new SignInViewModel();
return(View(viewPath, vm));
}
public async Task <ActionResult> ForgotPassword(string email)
{
if (await IsLoggedInAsync())
{
return(await GetLoggedInDefaultRedirectActionAsync());
}
var viewPath = ViewPathFormatter.View(CONTROLLER_NAME, nameof(ForgotPassword));
return(View(viewPath, new ForgotPasswordViewModel {
Username = email
}));
}
public async Task <ViewResult> ForgotPassword(ForgotPasswordViewModel command)
{
var template = new ResetPasswordTemplate();
var settings = await _queryExecutor.ExecuteAsync(new GetSettingsQuery <GeneralSiteSettings>());
template.ApplicationName = settings.ApplicationName;
await _authenticationHelper.SendPasswordResetNotificationAsync(this, command, template, _adminUserArea);
var viewPath = ViewPathFormatter.View(CONTROLLER_NAME, nameof(ForgotPassword));
return(View(viewPath, command));
}
public async Task <ActionResult> ChangePassword(string returnUrl)
{
var redirectAction = await ValidateChangePasswordRouteAsync();
if (redirectAction != null)
{
return(redirectAction);
}
var viewPath = ViewPathFormatter.View(CONTROLLER_NAME, nameof(ChangePassword));
return(View(viewPath, new ChangePasswordViewModel()));
}
public ActionResult ChangePassword(string returnUrl)
{
var user = _userContextService.GetCurrentContext();
if (!user.IsPasswordChangeRequired)
{
return(GetLoggedInDefaultRedirectAction());
}
var viewPath = ViewPathFormatter.View(CONTROLLER_NAME, nameof(ChangePassword));
return(View(viewPath, new ChangePasswordViewModel()));
}
public async Task <IViewComponentResult> InvokeAsync()
{
var menuItems = await _queryExecutor.ExecuteAsync(new GetPermittedAdminModulesQuery());
var menuCategories = _adminModuleMenuCaterories
.OrderBy(c => c.Order)
.ToList();
var vm = new AdminMenuViewModel();
var categories = new List <AdminMenuCategoryViewModel>();
foreach (var menuCategory in menuCategories)
{
var cvm = new AdminMenuCategoryViewModel();
cvm.Category = menuCategory;
cvm.Modules = menuItems
.Where(m => m.MenuCategoryType == menuCategory.GetType())
.SetStandardOrdering()
.ToList();
// only add the category if there are items to display
if (cvm.Modules.Count() > 0)
{
categories.Add(cvm);
}
}
vm.Categories = categories;
var selectedItem = menuItems
.Select(m => new {
Module = m,
Link = m.GetMenuLinkByPath(Request.Path),
CategoryType = m.MenuCategoryType
})
.Where(m => m.Link != null)
.FirstOrDefault();
var categoryType = selectedItem.CategoryType;
if (selectedItem != null)
{
vm.SelectedCategory = menuCategories.Where(c => c.GetType() == categoryType).FirstOrDefault();
vm.SelectedModule = selectedItem.Module;
}
var viewPath = ViewPathFormatter.View("Shared", "Components/AdminMenu");
return(View(viewPath, vm));
}
public async Task <ActionResult> Login()
{
var user = await _userContextService.GetCurrentContextAsync();
if (user.IsCofoundryUser())
{
return(await GetLoggedInDefaultRedirectActionAsync());
}
var viewPath = ViewPathFormatter.View(CONTROLLER_NAME, nameof(Login));
var vm = new LoginViewModel();
return(View(viewPath, vm));
}
public ActionResult Index(IUserAreaDefinition userArea)
{
var options = new UsersModuleOptions()
{
UserAreaCode = userArea.UserAreaCode,
Name = userArea.Name,
AllowPasswordLogin = userArea.AllowPasswordLogin,
UseEmailAsUsername = userArea.UseEmailAsUsername
};
var viewPath = ViewPathFormatter.View("Users", nameof(Index));
return(View(viewPath, options));
}
public ActionResult ForgotPassword(string email)
{
var user = _userContextService.GetCurrentContext();
if (user.IsCofoundryUser())
{
return(GetLoggedInDefaultRedirectAction());
}
var viewPath = ViewPathFormatter.View(CONTROLLER_NAME, nameof(ForgotPassword));
return(View(viewPath, new ForgotPasswordViewModel {
Username = email
}));
}
public async Task <ActionResult> Index()
{
var settings = await _domainRepository.ExecuteQueryAsync(new GetSettingsQuery <InternalSettings>());
if (settings.IsSetup)
{
return(RedirectToDashboard());
}
// force sign-out - solves a rare case where you're re-initializing a db after being signed into a previous version.
await _domainRepository.ExecuteCommandAsync(new SignOutCurrentUserFromAllUserAreasCommand());
var viewPath = ViewPathFormatter.View("Setup", nameof(Index));
return(View(viewPath));
}
public ActionResult Login(string email)
{
var user = _userContextService.GetCurrentContext();
if (user.IsCofoundryUser())
{
return(GetLoggedInDefaultRedirectAction());
}
var viewPath = ViewPathFormatter.View(CONTROLLER_NAME, nameof(Login));
var vm = new LoginViewModel {
EmailAddress = email
};
return(View(viewPath, vm));
}
public async Task <ActionResult> Index()
{
var settings = await _queryExecutor.ExecuteAsync(new GetSettingsQuery <InternalSettings>());
if (settings.IsSetup)
{
return(RedirectToDashboard());
}
// force sign-out - solves a rare case where you're re-initializing a db after being signed into a previous version.
await _loginService.SignOutAllUserAreasAsync();
var viewPath = ViewPathFormatter.View("Setup", nameof(Index));
return(View(viewPath));
}
public ActionResult Index()
{
var settings = _queryExecutor.Get <InternalSettings>();
if (settings.IsSetup)
{
return(RedirectToDashboard());
}
// force sign-out - solves a rare case where you're re-initializing a db after being signed into a previous version.
_loginService.SignOut();
var viewPath = ViewPathFormatter.View("Setup", nameof(Index));
return(View(viewPath));
}
public async Task <ViewResult> ForgotPassword(ForgotPasswordViewModel command)
{
await _contentRepository
.WithModelState(this)
.Users()
.AccountRecovery()
.InitiateAsync(new InitiateUserAccountRecoveryViaEmailCommand()
{
UserAreaCode = CofoundryAdminUserArea.Code,
Username = command.Username
});
var viewPath = ViewPathFormatter.View(CONTROLLER_NAME, nameof(ForgotPassword));
return(View(viewPath, command));
}
public async Task <ActionResult> Login(string returnUrl, SignInViewModel viewModel)
{
var authResult = await _contentRepository
.WithModelState(this)
.Users()
.Authentication()
.AuthenticateCredentials(new AuthenticateUserCredentialsQuery()
{
Username = viewModel.Username,
Password = viewModel.Password,
UserAreaCode = CofoundryAdminUserArea.Code,
PropertyToValidate = nameof(viewModel.Password)
})
.ExecuteAsync();
if (!ModelState.IsValid)
{
var viewPath = ViewPathFormatter.View(CONTROLLER_NAME, nameof(Login));
return(View(viewPath, viewModel));
}
// Support redirect urls from login
var redirectUrl = RedirectUrlHelper.GetAndValidateReturnUrl(this);
if (authResult.User.RequirePasswordChange)
{
return(Redirect(_adminRouteLibrary.Auth.ChangePassword(returnUrl)));
}
// If no action required, log the user in
await _contentRepository
.Users()
.Authentication()
.SignInAuthenticatedUserAsync(new SignInAuthenticatedUserCommand()
{
UserId = authResult.User.UserId,
RememberUser = true
});
if (redirectUrl != null)
{
return(Redirect(redirectUrl));
}
return(await GetLoggedInDefaultRedirectActionAsync());
}
public ActionResult Index()
{
var userArea = RouteData.DataTokens["UserArea"] as IUserAreaDefinition;
var userAreaOptions = _userAreaDefinitionRepository.GetOptionsByCode(userArea.UserAreaCode);
var options = new UsersModuleOptions()
{
UserAreaCode = userArea.UserAreaCode,
Name = userArea.Name,
AllowPasswordSignIn = userArea.AllowPasswordSignIn,
UseEmailAsUsername = userArea.UseEmailAsUsername,
ShowDisplayName = !userAreaOptions.Username.UseAsDisplayName
};
var viewPath = ViewPathFormatter.View("Users", nameof(Index));
return(View(viewPath, options));
}
public ActionResult ResetPassword(string i, string t)
{
var request = _authenticationHelper.IsPasswordRequestValid(this, i, t, new CofoundryAdminUserArea());
if (!request.IsValid)
{
return(View("ResetPasswordRequestInvalid", request));
}
var vm = new CompletePasswordResetViewModel();
vm.UserPasswordResetRequestId = i;
vm.Token = t;
var viewPath = ViewPathFormatter.View(CONTROLLER_NAME, nameof(ResetPassword));
return(View(viewPath, vm));
}
public async Task <ActionResult> ChangePassword(string returnUrl)
{
var user = await _userContextService.GetCurrentContextAsync();
if (user.UserId.HasValue)
{
if (!user.IsPasswordChangeRequired)
{
return(await GetLoggedInDefaultRedirectActionAsync());
}
// The user shouldn't be logged in, but if so, log them out
await _authenticationHelper.LogoutAsync(_adminUserArea);
}
var viewPath = ViewPathFormatter.View(CONTROLLER_NAME, nameof(ChangePassword));
return(View(viewPath, new ChangePasswordViewModel()));
}
public async Task <ActionResult> ResetPassword(CompletePasswordResetViewModel vm)
{
var user = await _userContextService.GetCurrentContextAsync();
if (user.IsCofoundryUser())
{
return(await GetLoggedInDefaultRedirectActionAsync());
}
await _authenticationHelper.CompletePasswordResetAsync(this, vm, new PasswordChangedTemplate(), USER_AREA);
if (ModelState.IsValid)
{
var completeViewPath = ViewPathFormatter.View(CONTROLLER_NAME, nameof(ResetPassword) + "Complete");
return(View(completeViewPath));
}
var viewPath = ViewPathFormatter.View(CONTROLLER_NAME, nameof(ResetPassword));
return(View(viewPath, vm));
}
