/// <summary> /// Perform some additional command validation that we can't do using data /// annotations. /// </summary> private void ValidateCommand(AddUserCommand command, IUserAreaDefinition userArea) { // Password var isPasswordEmpty = string.IsNullOrWhiteSpace(command.Password); if (userArea.AllowPasswordLogin && isPasswordEmpty && !command.GeneratePassword) { throw new PropertyValidationException("Password field is required", "Password"); } else if (!userArea.AllowPasswordLogin && !isPasswordEmpty) { throw new PropertyValidationException("Password field should be empty because the specified user area does not use passwords", "Password"); } // Email if (userArea.UseEmailAsUsername && string.IsNullOrEmpty(command.Email)) { throw new PropertyValidationException("Email field is required.", "Email"); } // Username if (userArea.UseEmailAsUsername && !string.IsNullOrEmpty(command.Username)) { throw new PropertyValidationException("Usename field should be empty becuase the specified user area uses the email as the username.", "Password"); } else if (!userArea.UseEmailAsUsername && string.IsNullOrWhiteSpace(command.Username)) { throw new PropertyValidationException("Username field is required", "Username"); } }
private async Task ValidateIsUnique(UpdateUserCommand command, IUserAreaDefinition userArea) { var query = new IsUsernameUniqueQuery() { UserId = command.UserId, UserAreaCode = userArea.UserAreaCode }; if (userArea.UseEmailAsUsername) { query.Username = command.Email; } else { query.Username = command.Username.Trim(); } var isUnique = await _queryExecutor.ExecuteAsync(query); if (!isUnique) { if (userArea.UseEmailAsUsername) { throw new PropertyValidationException("This email is already registered", "Email"); } else { throw new PropertyValidationException("This username is already registered", "Username"); } } }
public void ValidateUserArea(IUserAreaDefinition userArea) { if (!userArea.AllowPasswordSignIn) { throw new InvalidOperationException("Cannot update the password to account in a user area that does not allow password sign in."); } }
public EmailAddressFormattingResult FormatEmailAddress(IUserAreaDefinition userAreaDefinition, string emailAddress) { var emailAddressNormalizer = CreateServiceForUserArea <IEmailAddressNormalizer>(userAreaDefinition, typeof(IEmailAddressNormalizer <>)); var normalized = emailAddressNormalizer.NormalizeAsParts(emailAddress); if (normalized == null) { return(null); } var emailAddressUniquifier = CreateServiceForUserArea <IEmailAddressUniquifier>(userAreaDefinition, typeof(IEmailAddressUniquifier <>)); var uniquified = emailAddressUniquifier.UniquifyAsParts(normalized); if (uniquified == null) { return(null); } var result = new EmailAddressFormattingResult() { NormalizedEmailAddress = normalized.ToEmailAddress(), UniqueEmailAddress = uniquified.ToEmailAddress(), Domain = uniquified.Domain, }; return(result); }
public UsernameFormattingResult FormatUsername(IUserAreaDefinition userAreaDefinition, string username) { var usernameNormalizer = CreateServiceForUserArea <IUsernameNormalizer>(userAreaDefinition, typeof(IUsernameNormalizer <>)); var usernameUniquifier = CreateServiceForUserArea <IUsernameUniquifier>(userAreaDefinition, typeof(IUsernameUniquifier <>)); if (userAreaDefinition.UseEmailAsUsername) { var emailAddressNormalizer = CreateServiceForUserArea <IEmailAddressNormalizer>(userAreaDefinition, typeof(IEmailAddressNormalizer <>)); username = emailAddressNormalizer.Normalize(username); } var result = new UsernameFormattingResult(); result.NormalizedUsername = usernameNormalizer.Normalize(username); if (result.NormalizedUsername == null) { return(null); } result.UniqueUsername = usernameUniquifier.Uniquify(username); if (result.UniqueUsername == null) { return(null); } return(result); }
private async Task ValidateIsUniqueAsync( UpdateUserCommand command, IUserAreaDefinition userArea, IExecutionContext executionContext ) { var query = new IsUsernameUniqueQuery() { UserId = command.UserId, UserAreaCode = userArea.UserAreaCode }; if (userArea.UseEmailAsUsername) { query.Username = command.Email?.Trim(); } else { query.Username = command.Username.Trim(); } var isUnique = await _queryExecutor.ExecuteAsync(query, executionContext); if (!isUnique) { if (userArea.UseEmailAsUsername) { throw ValidationErrorException.CreateWithProperties("This email is already registered", "Email"); } else { throw ValidationErrorException.CreateWithProperties("This username is already registered", "Username"); } } }
public UsernameFormattingResult FormatUsername(IUserAreaDefinition userAreaDefinition, EmailAddressFormattingResult emailAddress) { if (userAreaDefinition == null) { throw new ArgumentNullException(nameof(userAreaDefinition)); } if (!userAreaDefinition.UseEmailAsUsername) { throw new InvalidOperationException($"{nameof(FormatUsername)} can only be called with an email address if the user area supports using an email as a username."); } if (emailAddress == null) { return(null); } var usernameNormalizer = CreateServiceForUserArea <IUsernameNormalizer>(userAreaDefinition, typeof(IUsernameNormalizer <>)); var usernameUniquifier = CreateServiceForUserArea <IUsernameUniquifier>(userAreaDefinition, typeof(IUsernameUniquifier <>)); var result = new UsernameFormattingResult(); result.NormalizedUsername = usernameNormalizer.Normalize(emailAddress.NormalizedEmailAddress); if (result.NormalizedUsername == null) { return(null); } result.UniqueUsername = usernameUniquifier.Uniquify(emailAddress.NormalizedEmailAddress); if (result.UniqueUsername == null) { return(null); } return(result); }
private static void ValidateDefinitionExists(IUserAreaDefinition definition, string identifier) { if (definition == null) { throw new EntityNotFoundException <IUserAreaDefinition>($"IUserAreaDefinition '{identifier}' is not registered. but has been requested.", identifier); } }
private async Task ValidatePasswordAsync( IUserAreaDefinition userArea, User user, AddUserCommand command, IExecutionContext executionContext ) { var isPasswordEmpty = string.IsNullOrWhiteSpace(command.Password); if (userArea.AllowPasswordSignIn && isPasswordEmpty) { throw ValidationErrorException.CreateWithProperties("Password field is required", nameof(command.Password)); } else if (!userArea.AllowPasswordSignIn && !isPasswordEmpty) { throw ValidationErrorException.CreateWithProperties("Password field should be empty because the specified user area does not use passwords", nameof(command.Password)); } else if (!userArea.AllowPasswordSignIn) { return; } var context = NewPasswordValidationContext.MapFromUser(user); context.Password = command.Password; context.PropertyName = nameof(command.Password); context.ExecutionContext = executionContext; await _newPasswordValidationService.ValidateAsync(context); }
private void ValidateRoleIsInUserArea(IUserAreaDefinition userAreaDefinition, Role role) { if (role != null && role.UserAreaCode != userAreaDefinition.UserAreaCode) { throw ValidationErrorException.CreateWithProperties($"This role is not in the {userAreaDefinition.Name} user area.", nameof(role.RoleId)); } }
private string GetUserAreaRoute(IUserAreaDefinition definition, string route = null) { if (definition == null) { return(string.Empty); } return("/" + _adminSettings.DirectoryName + "/" + SlugFormatter.ToSlug(definition.Name) + "-users#/" + route); }
private static string GetUserAreaRoute(IUserAreaDefinition definition, string route = null) { if (definition == null) { return(string.Empty); } return("/" + RouteConstants.AdminAreaPrefix + "/" + SlugFormatter.ToSlug(definition.Name) + "-users#/" + route); }
private async Task OnTransactionComplete(IUserAreaDefinition userArea, User user) { await _messageAggregator.PublishAsync(new UserAddedMessage() { UserAreaCode = userArea.UserAreaCode, UserId = user.UserId }); }
public string Details(IUserAreaDefinition definition, int id) { if (definition == null) { return(string.Empty); } return(List(definition) + id.ToString()); }
public string New(IUserAreaDefinition definition) { if (definition == null) { return(string.Empty); } return(List(definition) + "new"); }
private void SetPassword(User user, AddUserCommand command, IUserAreaDefinition userArea) { if (userArea.AllowPasswordSignIn) { var hashResult = _passwordCryptographyService.CreateHash(command.Password); user.Password = hashResult.Hash; user.PasswordHashVersion = hashResult.HashVersion; } }
public Task LogoutAsync(IUserAreaDefinition userAreaToLogInTo) { if (userAreaToLogInTo == null) { throw new ArgumentNullException(nameof(userAreaToLogInTo)); } return(_loginService.SignOutAsync(userAreaToLogInTo.UserAreaCode)); }
protected IUserAreaDefinitionRepository CreateUserAreaRepository() { var areas = new IUserAreaDefinition[] { new TestUserArea1(), new TestUserArea2() }; return(new UserAreaDefinitionRepository(areas, new UsersSettings())); }
public UserAreaSchemeRegistrationOptions( IUserAreaDefinition userArea, string scheme, string cookieNamespace ) { UserArea = userArea; Scheme = scheme; CookieNamespace = cookieNamespace; }
/// <summary> /// Consructs a new instance of InvalidUserAreaDefinitionException. /// </summary> /// <param name="message">The exception message.</param> /// <param name="invalidDefinition">The user area definition that caused the exception.</param> /// <param name="allDefinitions">Optional collection of all the user area definitions when available.</param> public InvalidUserAreaDefinitionException( string message, IUserAreaDefinition invalidDefinition, IEnumerable <IUserAreaDefinition> allDefinitions = null ) : base(message) { InvalidDefinition = invalidDefinition; AllDefinitions = allDefinitions?.ToArray(); }
public void ValidatePermissions(IUserAreaDefinition userArea, IExecutionContext executionContext) { if (userArea is CofoundryAdminUserArea) { _permissionValidationService.EnforcePermission(new CofoundryUserUpdatePermission(), executionContext.UserContext); } else { _permissionValidationService.EnforcePermission(new NonCofoundryUserUpdatePermission(), executionContext.UserContext); } }
private UserArea AddUserAreaIfNotExists(IUserAreaDefinition userArea, UserArea dbUserArea) { if (dbUserArea == null) { dbUserArea = new UserArea(); dbUserArea.UserAreaCode = userArea.UserAreaCode; dbUserArea.Name = userArea.Name; _dbContext.UserAreas.Add(dbUserArea); } return(dbUserArea); }
public DomainRepositoryExecutorWithUserAreaContext( IDomainRepositoryExecutor innerDomainRepositoryExecutor, IUserAreaDefinition userArea, IUserContextService userContextService, IExecutionContextFactory executionContextFactory ) { _userContextService = userContextService; _executionContextFactory = executionContextFactory; _innerDomainRepositoryExecutor = innerDomainRepositoryExecutor; _userArea = userArea; }
public ActionResult Index(IUserAreaDefinition userArea) { var options = new UsersModuleOptions() { UserAreaCode = userArea.UserAreaCode, Name = userArea.Name, AllowPasswordLogin = userArea.AllowPasswordLogin, UseEmailAsUsername = userArea.UseEmailAsUsername }; return(View("~/Admin/Modules/Users/Mvc/Views/Index.cshtml", options)); }
public async Task ValidatePermissionsAsync(User user, IUserAreaDefinition userArea, IExecutionContext executionContext) { if (userArea is CofoundryAdminUserArea) { _permissionValidationService.EnforcePermission(new CofoundryUserUpdatePermission(), executionContext.UserContext); } else { _permissionValidationService.EnforcePermission(new NonCofoundryUserUpdatePermission(), executionContext.UserContext); } await _userCommandPermissionsHelper.ThrowIfCannotManageSuperAdminAsync(user, executionContext); }
private void ValidateIsUnique(bool isUnique, IUserAreaDefinition userArea) { if (!isUnique) { if (userArea.UseEmailAsUsername) { throw new PropertyValidationException("This email is already registered", "Email"); } else { throw new PropertyValidationException("This username is already registered", "Username"); } } }
private void ValidateCommand(UpdateUserCommand command, IUserAreaDefinition userArea) { // Email if (userArea.UseEmailAsUsername && string.IsNullOrEmpty(command.Email)) { throw ValidationErrorException.CreateWithProperties("Email field is required.", "Email"); } // Username if (!userArea.UseEmailAsUsername && string.IsNullOrWhiteSpace(command.Username)) { throw ValidationErrorException.CreateWithProperties("Username field is required", "Username"); } }
public UserAreaDefinitionRepository( IEnumerable <IUserAreaDefinition> userAreas, UsersSettings identitySettings ) { DetectInvalidDefinitions(userAreas); _userAreas = userAreas.ToDictionary(k => k.UserAreaCode); _options = ConfigureOptions(userAreas, identitySettings); _defaultUserArea = userAreas .OrderByDescending(u => u.IsDefaultAuthScheme) .ThenByDescending(u => u is CofoundryAdminUserArea) .ThenBy(u => u.Name) .FirstOrDefault(); }
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)); }
private IsUsernameUniqueQuery GetUniqueQuery(AddUserCommand command, IUserAreaDefinition userArea) { var query = new IsUsernameUniqueQuery(); if (userArea.UseEmailAsUsername) { query.Username = command.Email; } else { query.Username = command.Username.Trim(); } query.UserAreaCode = command.UserAreaCode; return(query); }