public async Task <ICommandResult <TUser> > CreateAsync(TUser model, string password)
{
if (model == null)
{
throw new ArgumentNullException(nameof(model));
}
var result = new CommandResult <TUser>();
// Validate
// -------------------------
if (String.IsNullOrEmpty(model.UserName) || String.IsNullOrWhiteSpace(model.UserName))
{
return(result.Failed(new CommandError("UserName", T["A username is required"])));
}
if (String.IsNullOrEmpty(model.Email) || String.IsNullOrWhiteSpace(model.Email))
{
return(result.Failed(new CommandError("Email", T["A email is required"])));
}
if (string.IsNullOrWhiteSpace(password) || String.IsNullOrWhiteSpace(password))
{
return(result.Failed(new CommandError("Password", T["A password is required"])));
}
// Check Uniqueness
// -------------------------
// Is this a unique email?
if (await _userManager.FindByEmailAsync(model.Email) != null)
{
return(result.Failed(new CommandError("Email", T["The email already exists"])));
}
// Is this a unique username?
if (await _userManager.FindByNameAsync(model.UserName.Normalize()) != null)
{
return(result.Failed(new CommandError("UserName", T["The username already exists"])));
}
// -------------------------
// Get site settings to populate some user defaults
var settings = await _siteSettingsStore.GetAsync();
if (settings != null)
{
model.TimeZone = settings.TimeZone;
}
model.PhotoColor = _userColorProvider.GetColor();
model.SignatureHtml = await ParseSignatureHtml(model.Signature);
if (String.IsNullOrEmpty(model.IpV4Address))
{
model.IpV4Address = _clientIpAddress.GetIpV4Address();
}
if (String.IsNullOrEmpty(model.IpV6Address))
{
model.IpV6Address = _clientIpAddress.GetIpV6Address();
}
// Add security stamp
await _securityStampStore.SetSecurityStampAsync(model, System.Guid.NewGuid().ToString(), new CancellationToken());
// Invoke UserCreating subscriptions
foreach (var handler in _broker.Pub <TUser>(this, "UserCreating"))
{
model = await handler.Invoke(new Message <TUser>(model, this));
}
// Persist the user
var identityResult = await _userManager.CreateAsync(model, password);
if (identityResult.Succeeded)
{
// Get newly created user
var updatedOrNewUser = await _userManager.FindByEmailAsync(model.Email);
// Add roles from model
if (updatedOrNewUser != null)
{
if (model.RoleNames != null)
{
foreach (var role in model.RoleNames)
{
if (!await _userManager.IsInRoleAsync(updatedOrNewUser, role))
{
await _userManager.AddToRoleAsync(updatedOrNewUser, role);
}
}
}
}
// Invoke UserCreated subscriptions
foreach (var handler in _broker.Pub <TUser>(this, "UserCreated"))
{
updatedOrNewUser = await handler.Invoke(new Message <TUser>(updatedOrNewUser, this));
}
// Return success
return(result.Success(updatedOrNewUser));
}
// User could not be created, accumulate errors
var errors = new List <CommandError>();
foreach (var error in identityResult.Errors)
{
errors.Add(new CommandError(error.Code, T[error.Description]));
}
return(result.Failed(errors.ToArray()));
}
// ------------
// Ban User
// ------------
public async Task <IActionResult> BanUser(string id)
{
// Ensure we have permission
if (!await _authorizationService.AuthorizeAsync(User,
Permissions.UserToBanned))
{
return(Unauthorized());
}
// Get current user
var user = await _contextFacade.GetAuthenticatedUserAsync();
if (user == null)
{
return(Unauthorized());
}
// Get user we are editing
var currentUser = await _userManager.FindByIdAsync(id);
if (currentUser == null)
{
return(NotFound());
}
// Reset staff status
currentUser.IsStaff = false;
currentUser.IsStaffUpdatedUserId = 0;
currentUser.IsStaffUpdatedDate = null;
// Reset verified status
currentUser.IsVerified = false;
currentUser.IsVerifiedUpdatedUserId = 0;
currentUser.IsVerifiedUpdatedDate = null;
// Reset spam status
currentUser.IsSpam = false;
currentUser.IsSpamUpdatedUserId = 0;
currentUser.IsSpamUpdatedDate = null;
// Update banned status
currentUser.IsBanned = true;
currentUser.IsBannedUpdatedUserId = user.Id;
currentUser.IsBannedUpdatedDate = DateTimeOffset.UtcNow;
// Invalidate security stamp to force sign-out banned users
await _securityStampStore.SetSecurityStampAsync(currentUser, Guid.NewGuid().ToString(), new CancellationToken());
// Update user
var result = await _userManager.UpdateAsync(currentUser);
if (result.Succeeded)
{
// Add confirmation
_alerter.Success(T["User Banned Successfully!"]);
}
else
{
foreach (var error in result.Errors)
{
_alerter.Danger(T[error.Description]);
}
}
// Redirect back to edit user
return(RedirectToAction(nameof(Edit), new RouteValueDictionary()
{
["id"] = id
}));
}
public async Task <IActionResult> SeedData(SetupModel model)
{
if (!ModelState.IsValid)
{
return(View());
}
if (_setupProvider.HasDataSeeded())
{
return(RedirectToAction(nameof(Index), "Home"));
}
if (!_setupProvider.HasDatabaseSetup())
{
return(RedirectToAction(nameof(StartSetup)));
}
try
{
var settings = _setupProvider.LoadSettings();
var initialUser = new ApplicationUser()
{
DisplayName = $"{model.Lastname} {model.Firstname}",
Email = model.AdminEmail,
Firstname = model.Firstname,
Lastname = model.Lastname,
StatusId = (byte)UserStatus.Actived,
UserName = model.AdminEmail,
};
initialUser.PasswordHash = _passwordHasher.HashPassword(initialUser, model.AdminPassword);
await _userSecurityStampStore.SetSecurityStampAsync(initialUser, _userManager.NewSecurityStamp(), default);
// Get initial data in josn
var indentityJson = _setupProvider.LoadFileText(settings.SeedDataJsonFilePath);
var setupRequest = JsonConvert.DeserializeObject <SetupRequest>(indentityJson);
setupRequest.InitualUser = new UserModifyRequest
{
BirthDate = initialUser.BirthDate,
Address = initialUser.Address,
CountryId = initialUser.CountryId,
Email = initialUser.Email,
Firstname = initialUser.Firstname,
Lastname = initialUser.Lastname,
PasswordHash = initialUser.PasswordHash,
SecurityStamp = initialUser.SecurityStamp,
UserName = initialUser.UserName,
DisplayName = initialUser.DisplayName,
};
// Initialize database
await _dataSeedService.SeedDataAsync(setupRequest);
_setupProvider.SetDataHasBeenSeeded();
return(RedirectToAction(nameof(Succeed)));
}
catch (Exception)
{
_setupProvider.DeleteSetupSettings();
return(View());
}
}
