/// <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);
}
