/// <summary>
/// 添加系统用户
/// </summary>
/// <param name="command"></param>
public void Execute(AddUserCommand command)
{
var sysMember = new SysMember();
sysMember.Mapp(command);
var check = sysMember.ValidateUserInfo();
if (!check.success)
{
command.Result.Status = false;
command.Result.Msg = check.msg;
return;
}
//加密密码
sysMember.DesPwd();
if (memberRepository.Exist(sysMember.Account))
{
command.Result.Status = false;
command.Result.Msg = "用户登录名已存在！";
return;
}
command.RolesCmd.ForEach(r => { sysMember.AddRole(r.id, r.name); });
var rlt = memberRepository.AddMember(sysMember);
command.Result.Status = rlt.success;
command.Result.Msg = rlt.msg;
}
public void Add(AddUserCommand user)
{
if (string.IsNullOrEmpty(user.LoginName) || string.IsNullOrEmpty(user.Password))
{
throw new LogException(LogicExceptionMessage.LoginNameOrPasswordIsNull);
}
if (!IsNumAndEnCh(user.LoginName) || !IsNumAndEnCh(user.Password))
{
throw new LogException(LogicExceptionMessage.LoginNameOrPasswordIsAlphabet);
}
if (!IsLengthMoreThanSix(user.LoginName) || !IsLengthMoreThanSix(user.Password))
{
throw new LogException(LogicExceptionMessage.LoginNameOrPasswordLengthMoreThanSix);
}
var equalName = _systemUserRepository.GetAll().FirstOrDefault(x => x.LoginName == user.LoginName);
if (equalName != null)
{
throw new LogException(LogicExceptionMessage.TheSameLoginName);
}
var info = new SystemUser
{
LoginName = user.LoginName,
Password = user.Password,
CreateUser = LoginUserSection.CurrentUser.LoginName,
CreateDate = _currentTimeProvider.CurrentTime()
};
_systemUserRepository.Add(info);
}
public UserController(AddUserCommand addUserCommand
, EditUserCommand editUserCommand
, DeleteUserCommand deleteUserCommand
, GetAdminAppUserByIdQuery getAdminAppUserByIdQuery
, EditOdsInstanceRegistrationForUserCommand editOdsInstanceRegistrationForUserCommand
, EditUserRoleCommand editUserRoleCommand
, GetRoleForUserQuery getRoleForUserQuery
, IGetOdsInstanceRegistrationsByUserIdQuery getOdsInstanceRegistrationsByUserIdQuery
, IGetOdsInstanceRegistrationsQuery getOdsInstanceRegistrationsQuery
, ITabDisplayService tabDisplayService
, SignInManager <AdminAppUser> signInManager
, UserManager <AdminAppUser> userManager
)
{
_addUserCommand = addUserCommand;
_editUserCommand = editUserCommand;
_deleteUserCommand = deleteUserCommand;
_getAdminAppUserByIdQuery = getAdminAppUserByIdQuery;
_editOdsInstanceRegistrationForUserCommand = editOdsInstanceRegistrationForUserCommand;
_editUserRoleCommand = editUserRoleCommand;
_getRoleForUserQuery = getRoleForUserQuery;
_getOdsInstanceRegistrationsByUserIdQuery = getOdsInstanceRegistrationsByUserIdQuery;
_getOdsInstanceRegistrationsQuery = getOdsInstanceRegistrationsQuery;
_tabDisplayService = tabDisplayService;
SignInManager = signInManager;
UserManager = userManager;
}
public async Task ShouldUpdateUserWithEmailAlreadyExist()
{
var role = ExampleContext.Roles.FirstOrDefault(x => x.Name == new Domain.Roles.Name("rfa"));
// add user
var addUserCommand = new AddUserCommand("user", "user", "*****@*****.**", new RoleUser(role.Name.Value, role.Permissions.Value));
var userAdded1 = await _userCommandHandler.Handle(addUserCommand, default);
// add user
addUserCommand = new AddUserCommand("user", "user", "*****@*****.**", new RoleUser(role.Name.Value, role.Permissions.Value));
var userAdded2 = await _userCommandHandler.Handle(addUserCommand, default);
// add user
var updateUserCommand = new UpdateUserCommand(userAdded2.Id, "user", "user", "*****@*****.**", new RoleUser(role.Name.Value, role.Permissions.Value));
Func <Task> comparison = async() =>
{
await _userCommandHandler.Handle(updateUserCommand, default);
};
comparison.Should().Throw <EmailAlreadyAffectedException>();
ExampleContext.Users.Remove(ExampleContext.Users.Find(new UserId(userAdded2.Id)));
ExampleContext.Users.Remove(ExampleContext.Users.Find(new UserId(userAdded1.Id)));
await ExampleContext.SaveChangesAsync();
}
public async Task <ActionResult> Post(
[FromServices] DataContext context,
[FromBody] AddUserCommand command)
{
try
{
if (ModelState.IsValid == false)
{
return(BadRequest(ModelState));
}
var user = new User(
command.Name.Trim(),
command.Username.Trim().ToLower(),
command.Email.Trim().ToLower(),
command.Password.Trim(),
command.Phone.Trim(),
command.Birthday,
command.Photo.ToLower());
context.Users.Add(user);
await context.SaveChangesAsync();
return(Ok(new { user.Id }));
}
catch (Exception)
{
return(StatusCode(StatusCodes.Status500InternalServerError,
new { message = ErrorMessage.Internal }));
}
}
public void Can_Have_Other_Ctors()
{
var user = new User();
var command = new AddUserCommand(user);
Assert.AreEqual(command.NewUser, command.Creator);
}
public MainWindowViewModel()
{
#region starting view content
logHandler = LogHandler.Instance;
logHandler.MainWindowViewModel = this;
ContentHandler.StartContent();
Refresh();
#endregion
#region Commands
AddUserCommand = new AddUserCommand(this);
ViewProfilInfoCommand = new ViewProfilInfoCommand(this);
AddTelephoneCommand = new AddTelephoneCommand(this);
AddShopCommand = new AddShopCommand(this);
ChangeTelephoneCommand = new ChangeTelephoneInfoCommand(this);
DeleteTelephoneCommand = new DeleteTelephoneCommand(this);
DuplicateTelephoneCommand = new DuplicateTelephoneCommand(this);
ChangeShopCommand = new ChangeShopInfoCommand(this);
DeleteShopCommand = new DeleteShopCommand(this);
LogOutCommand = new LogOutCommand(this);
BuyTelephoneCommand = new BuyTelephoneCommand(this);
ClearCommand = new ClearCommand(this);
UndoCommand = new UndoCommand(this);
RedoCommand = new RedoCommand(this);
FilterCommand = new FilterCommand(this);
RefreshCommand = new RefreshCommand(this);
#endregion
}
public async Task <IActionResult> CreateUser(
[FromBody] UserForCreationDto userForCreation)
{
if (userForCreation == null)
{
ModelState.AddModelError("Message", "Unable to locate payload for new request");
return(BadRequest(ModelState));
}
var command = new AddUserCommand(userForCreation.FirstName, userForCreation.LastName, userForCreation.Email, userForCreation.UserName, userForCreation.Password, userForCreation.ConfirmPassword, userForCreation.Roles, userForCreation.Facilities);
_logger.LogInformation(
"----- Sending command: AddUserCommand - {userName}",
command.UserName);
var commandResult = await _mediator.Send(command);
if (commandResult == null)
{
return(BadRequest("Command not created"));
}
return(CreatedAtAction("GetUserByIdentifier",
new
{
id = commandResult.Id
}, commandResult));
}
public async Task WhenUsernameUpdated_SendsMessage()
{
var uniqueData = UNIQUE_PREFIX + "UsernameUpd_SM";
using var app = _appFactory.Create();
var contentRepository = app.Services.GetContentRepository();
var userAreaCode = UserAreaWithoutPasswordSignIn.Code;
var roleId = await app.TestData.Roles().AddAsync(uniqueData, userAreaCode);
var addCommand = new AddUserCommand()
{
Username = uniqueData,
RoleId = roleId,
UserAreaCode = userAreaCode
};
var userId = await contentRepository
.WithElevatedPermissions()
.Users()
.AddAsync(addCommand);
await contentRepository
.Users()
.Authentication()
.SignInAuthenticatedUserAsync(new SignInAuthenticatedUserCommand()
{
UserId = userId
});
var updateCommand = new UpdateCurrentUserCommand()
{
Username = addCommand.Username + "_X",
FirstName = addCommand.FirstName,
LastName = addCommand.LastName
};
await contentRepository
.Users()
.Current()
.UpdateAsync(updateCommand);
using (new AssertionScope())
{
app.Mocks
.CountMessagesPublished <UserUpdatedMessage>(m => m.UserId == addCommand.OutputUserId && m.UserAreaCode == addCommand.UserAreaCode)
.Should().Be(1);
app.Mocks
.CountMessagesPublished <UserEmailUpdatedMessage>(m => m.UserId == addCommand.OutputUserId && m.UserAreaCode == addCommand.UserAreaCode)
.Should().Be(0);
app.Mocks
.CountMessagesPublished <UserUsernameUpdatedMessage>(m => m.UserId == addCommand.OutputUserId && m.UserAreaCode == addCommand.UserAreaCode)
.Should().Be(1);
app.Mocks
.CountMessagesPublished <UserSecurityStampUpdatedMessage>(m => m.UserId == addCommand.OutputUserId && m.UserAreaCode == addCommand.UserAreaCode)
.Should().Be(1);
}
}
public async Task <Response <UserVm> > Handle(AddUserCommand request, CancellationToken cancellationToken)
{
User user = new User
{
Name = request.User.Name,
Lastname = request.User.Lastname,
Email = request.User.Email,
TelephoneNumber = request.User.TelephoneNumber,
Address = request.User.Address.Select(adress => new Address()
{
Description = adress.Description
}).ToList(),
Age = request.User.Age
};
await _unitOfWork.Users.Add(user);
UserVm userResult = new UserVm()
{
Id = user.Id,
Name = user.Name,
Lastname = user.Lastname,
Email = user.Email,
TelephoneNumber = user.TelephoneNumber,
Address = user.Address.Select(adress => new AddressVm()
{
Description = adress.Description
}).ToList(),
Age = request.User.Age
};
return(Response.Ok200(userResult));
}
static void Main(string[] args)
{
Init();
var bus = ServiceLocator.Current.GetInstance <IServiceBus>();
bus.ToSubscribe <AddUserEvent>(new UserEventHandler());
Enumerable.Range(1, 40000).Select(p =>
{
var command = new AddUserCommand()
{
Name = "dsd-", CommandId = Guid.NewGuid()
};
bus.SendAsync(command).ToObservable().Subscribe(r =>
{
var changecommand = new ChangeNameCommand()
{
CommandId = Guid.NewGuid(), Id = "1", Name = "fzf003"
};
Console.WriteLine(r.Status + "|" + r.Result + "|" + r.CommandId);
bus.SendAsync(changecommand);
});
return(p);
}).ToArray();
Console.WriteLine("Query:{0}", bus.QueryAsync(new GetAll()).Result);
Console.WriteLine(".....");
Console.ReadKey();
}
public async Task ShouldAddUserWithRequirePasswordChangeAsTrue()
{
var guidString = Guid.NewGuid().ToString("N");
var newUser = new AddUserModel
{
Email = $"test{guidString}@test.com",
Password = "******",
ConfirmPassword = "******"
};
await ScopedAsync <UserManager <AdminAppUser> >(async manager =>
{
var command = new AddUserCommand();
var(userId, identityResult) = await command.Execute(newUser, manager);
string.Join(Environment.NewLine, identityResult.Errors.Select(x => x.Description)).ShouldBe("");
identityResult.Succeeded.ShouldBeTrue();
var addedUser = Query(userId);
addedUser.UserName.ShouldBe($"test{guidString}@test.com");
addedUser.Email.ShouldBe($"test{guidString}@test.com");
addedUser.RequirePasswordChange.ShouldBe(true);
});
}
public async Task CantChangeUserAreaByRoleCode()
{
var uniqueData = UNIQUE_PREFIX + nameof(CantChangeUserAreaByRoleCode);
using var app = _appFactory.Create();
var contentRepository = app.Services.GetContentRepositoryWithElevatedPermissions();
var userArea1 = app.SeededEntities.TestUserArea1;
var userArea2 = app.SeededEntities.TestUserArea2;
var addCommand = new AddUserCommand()
{
Email = uniqueData + EMAIL_DOMAIN,
Password = PASSWORD,
RoleCode = userArea1.RoleA.RoleCode,
UserAreaCode = userArea1.UserAreaCode
};
var userId = await contentRepository
.Users()
.AddAsync(addCommand);
var updateCommand = MapUpdateCommand(addCommand);
updateCommand.RoleCode = userArea2.RoleB.RoleCode;
await contentRepository
.Awaiting(r => r.Users().UpdateAsync(updateCommand))
.Should()
.ThrowAsync <ValidationErrorException>()
.WithMessage("*user area*");
}
public void Call_UserService_AddUser_Once()
{
var parameters = new List <string>()
{
"Fname", "Mname", "Lname", "0123123123", "Address", "Town"
};
var townServiceMock = new Mock <ITownService>();
var addressServiceMock = new Mock <IAddressService>();
var userServiceMock = new Mock <IUsersServices>();
var command = new AddUserCommand(userServiceMock.Object, addressServiceMock.Object, townServiceMock.Object);
townServiceMock.Setup(x => x.AddTown(It.IsAny <string>())).Returns(1);
addressServiceMock.Setup(x => x.AddAddress(It.IsAny <string>(), It.IsAny <int>())).Returns(1);
userServiceMock.Setup(x => x.AddUser(It.IsAny <string>()
, It.IsAny <string>()
, It.IsAny <string>()
, It.IsAny <string>()
, It.IsAny <DateTime>()
, It.IsAny <bool>()
, It.IsAny <int>()
)).Returns(new UserViewModel());
command.Execute(parameters);
userServiceMock.Verify(s => s.AddUser(parameters[0], parameters[1], parameters[2], parameters[3], It.IsAny <DateTime>(), false, 1), Times.Once());
}
private void SignUpButton_Click(object sender, RoutedEventArgs e)
{
var login = RetrieveLogin();
string message;
string caption;
using (var connection = new NpgsqlConnection(BuildConnectionString()))
{
connection.Open();
var salt = _saltGenerator.Next();
var password = _hasher.Hash(RetrievePassword(), salt);
var command = new AddUserCommand(connection, login, password, salt);
try
{
command.Execute();
message = "You have successfully signed up";
caption = "Success!";
}
catch (Exception)
{
message = "Can't create user with this login. Login violates database restrictions";
caption = "Failure!";
}
}
PostSignUp(message, caption);
}
private AddUserCommand MapCommand(AddUserWithTemporaryPasswordCommand command)
{
// The password policy should be configured with the definitive min-length
// as an attribute, but otherwise fall-back to the configured option
var passwordPolicy = _passwordPolicyService.GetDescription(command.UserAreaCode);
var minLengthAttribute = passwordPolicy.Attributes.GetOrDefault(PasswordPolicyAttributes.MinLength);
var options = _userAreaDefinitionRepository.GetOptionsByCode(command.UserAreaCode);
var minLength = IntParser.ParseOrDefault(minLengthAttribute, options.Password.MinLength);
var newUserCommand = new AddUserCommand()
{
FirstName = command.FirstName,
LastName = command.LastName,
DisplayName = command.DisplayName,
Email = command.Email,
Username = command.Username,
Password = _passwordGenerationService.Generate(minLength),
RequirePasswordChange = true,
UserAreaCode = command.UserAreaCode,
RoleId = command.RoleId,
RoleCode = command.RoleCode
};
return(newUserCommand);
}
public void Return_SuccessMessage()
{
var parameters = new List <string>()
{
"Fname", "Mname", "Lname", "0123123123", "Address", "Town"
};
var fullName = parameters[0] + ' ' + parameters[1] + ' ' + parameters[2];
var date = new DateTime(2018, 12, 12);
var townServiceMock = new Mock <ITownService>();
var addressServiceMock = new Mock <IAddressService>();
var userServiceMock = new Mock <IUsersServices>();
var command = new AddUserCommand(userServiceMock.Object, addressServiceMock.Object, townServiceMock.Object);
townServiceMock.Setup(x => x.AddTown(It.IsAny <string>())).Returns(1);
addressServiceMock.Setup(x => x.AddAddress(It.IsAny <string>(), It.IsAny <int>())).Returns(1);
userServiceMock.Setup(x => x.AddUser(It.IsAny <string>()
, It.IsAny <string>()
, It.IsAny <string>()
, It.IsAny <string>()
, It.IsAny <DateTime>()
, It.IsAny <bool>()
, It.IsAny <int>()
)).Returns(new UserViewModel()
{
FullName = fullName,
AddedOn = date
});
var message = command.Execute(parameters);
userServiceMock.Verify(s => s.AddUser(parameters[0], parameters[1], parameters[2], parameters[3], It.IsAny <DateTime>(), false, 1), Times.Once());
Assert.AreEqual($"New user {fullName} was added successfully on {date}.", message);
}
public Users AddUser(AddUserCommand user)
{
using (var db = _paintStoreContext)
{
if (db.Users.Any(x => x.Email == user.Email))
{
throw new DuplicateEmailException();
}
if (db.Users.Any(x => x.Name == user.Name))
{
throw new DuplicateNameException();
}
var newUser = new Users()
{
Email = user.Email, Name = user.Name, Link = user.Name.ToLower(), About = ""
};
newUser.PasswordSoil = CredentialsHelpers.CreateSalt();
var encoding = new ASCIIEncoding();
var soil = encoding.GetBytes(newUser.PasswordSoil);
var password = encoding.GetBytes(user.Password);
newUser.PasswordHash = Convert.ToBase64String(CredentialsHelpers.GenerateSaltedHash(password, soil));
db.Users.Add(newUser);
db.SaveChanges();
return(newUser);
}
}
public ModerPageVM(ModerPage page)
{
this.page = page;
AddUser = new AddUserCommand(page);
DellUser = new DellUserCommand(page);
UpdUser = new UpdUserCommand(page);
}
public void CreateUser(AddUserCommand newUserCommand)
{
newUserCommand.FirebaseUid = FirebaseUid;
var theNewUser = newUserCommand;
_userRepo.CreateNewUser(theNewUser);
}
public async Task CanSetVerifiedTrue()
{
var uniqueData = UNIQUE_PREFIX + nameof(CanSetVerifiedTrue);
using var app = _appFactory.Create();
var contentRepository = app.Services.GetContentRepositoryWithElevatedPermissions();
var dbContext = app.Services.GetRequiredService <CofoundryDbContext>();
var userArea = app.SeededEntities.TestUserArea1;
var command = new AddUserCommand()
{
Email = uniqueData + EMAIL_DOMAIN,
Password = PASSWORD,
RoleCode = userArea.RoleA.RoleCode,
UserAreaCode = userArea.UserAreaCode,
IsAccountVerified = true
};
await contentRepository
.Users()
.AddAsync(command);
var user = await dbContext
.Users
.AsNoTracking()
.FilterById(command.OutputUserId)
.SingleOrDefaultAsync();
using (new AssertionScope())
{
command.OutputUserId.Should().BePositive();
user.Should().NotBeNull();
user.AccountVerifiedDate.Should().NotBeNull().And.NotBeDefault();
}
}
public async Task WhenUserNameAsDisplayName_CopiesUsername()
{
var uniqueData = UNIQUE_PREFIX + "UNasDN_Copies";
using var app = _appFactory.Create(s => s.Configure <UsersSettings>(c => c.Username.UseAsDisplayName = true));
var contentRepository = app.Services.GetContentRepositoryWithElevatedPermissions();
var dbContext = app.Services.GetRequiredService <CofoundryDbContext>();
var command = new AddUserCommand()
{
Email = uniqueData + EMAIL_DOMAIN,
Password = PASSWORD,
RoleCode = app.SeededEntities.TestUserArea1.RoleA.RoleCode,
UserAreaCode = app.SeededEntities.TestUserArea1.UserAreaCode,
DisplayName = "Display Name",
FirstName = "FName",
LastName = "LName"
};
await contentRepository
.Users()
.AddAsync(command);
var user = await dbContext
.Users
.AsNoTracking()
.FilterById(command.OutputUserId)
.SingleOrDefaultAsync();
using (new AssertionScope())
{
user.Should().NotBeNull();
user.DisplayName.Should().Be(user.Username);
}
}
private async void Connect_Execute(string arg)
{
try
{
AddUserCommand.RaiseCanExecuteChanged();
_isConnected = true;
Operation = OperProgress.Connecting.ToString();
ConnectCommand.RaiseCanExecuteChanged();
_model.CreateFirebaseApp(arg);
Users = new ObservableCollection <UserRecord>(await _model.GetUsers());
Users.CollectionChanged += Users_CollectionChanged;
}
catch (Exception e)
{
_isConnected = false;
MessageBox.Show(e.Message);
}
finally
{
ConnectCommand.RaiseCanExecuteChanged();
AddUserCommand.RaiseCanExecuteChanged();
Operation = OperProgress.Connect.ToString();
}
}
private void UserModel_PropertyChanged(object sender, System.ComponentModel.PropertyChangedEventArgs e)
{
if (e.PropertyName == "HasErrors")
{
AddUserCommand.RaiseCanExecuteChanged();
}
}
public async Task SendsMessage()
{
var uniqueData = UNIQUE_PREFIX + nameof(SendsMessage);
using var app = _appFactory.Create();
var contentRepository = app.Services.GetContentRepositoryWithElevatedPermissions();
var userArea = app.SeededEntities.TestUserArea1;
var command = new AddUserCommand()
{
Email = uniqueData + EMAIL_DOMAIN,
Password = PASSWORD,
RoleCode = userArea.RoleA.RoleCode,
UserAreaCode = userArea.UserAreaCode
};
await contentRepository
.Users()
.AddAsync(command);
using (new AssertionScope())
{
app.Mocks
.CountMessagesPublished <UserAddedMessage>(m => m.UserId == command.OutputUserId && m.UserAreaCode == userArea.UserAreaCode)
.Should().Be(1);
app.Mocks
.CountMessagesPublished <UserUsernameUpdatedMessage>()
.Should().Be(0);
app.Mocks
.CountMessagesPublished <UserEmailUpdatedMessage>()
.Should().Be(0);
}
}
public async Task WhenNotPasswordSignIn_EmailNotRequired()
{
var uniqueData = UNIQUE_PREFIX + "NotPWSignIn_EmailNotReq";
using var app = _appFactory.Create();
var contentRepository = app.Services.GetContentRepositoryWithElevatedPermissions();
var dbContext = app.Services.GetRequiredService <CofoundryDbContext>();
var userAreaCode = UserAreaWithoutPasswordSignIn.Code;
var roleId = await app.TestData.Roles().AddAsync(uniqueData, userAreaCode);
var command = new AddUserCommand()
{
Username = uniqueData,
RoleId = roleId,
UserAreaCode = userAreaCode
};
await contentRepository
.Users()
.AddAsync(command);
var user = await dbContext
.Users
.AsNoTracking()
.FilterById(command.OutputUserId)
.SingleOrDefaultAsync();
using (new AssertionScope())
{
command.OutputUserId.Should().BePositive();
user.Should().NotBeNull();
user.Username.Should().Be(command.Username);
user.Email.Should().BeNull();
}
}
public async Task WithoutEmailAsUsername_ValidatesUsernameUnique()
{
var uniqueData = UNIQUE_PREFIX + "WOEmailUN_ValUnameUnique";
using var app = _appFactory.Create();
var contentRepository = app.Services.GetContentRepositoryWithElevatedPermissions();
var dbContext = app.Services.GetRequiredService <CofoundryDbContext>();
var userAreaCode = UserAreaWithoutEmailAsUsername.Code;
var roleId = await app.TestData.Roles().AddAsync(uniqueData, userAreaCode);
var command = new AddUserCommand()
{
Email = uniqueData + EMAIL_DOMAIN,
Username = uniqueData,
Password = PASSWORD,
RoleId = roleId,
UserAreaCode = userAreaCode
};
await contentRepository
.Users()
.AddAsync(command);
command.Email = uniqueData + "2" + EMAIL_DOMAIN;
command.OutputUserId = 0;
await contentRepository
.Awaiting(r => r.Users().AddAsync(command))
.Should()
.ThrowAsync <ValidationErrorException>()
.WithMemberNames(nameof(command.Username))
.WithMessage("*username*already*registered*");
}
public async Task WithEmailAsUsername_ValidatesEmailUnique()
{
var uniqueData = UNIQUE_PREFIX + nameof(WithEmailAsUsername_ValidatesEmailUnique);
using var app = _appFactory.Create();
var contentRepository = app.Services.GetContentRepositoryWithElevatedPermissions();
var dbContext = app.Services.GetRequiredService <CofoundryDbContext>();
var userArea = app.SeededEntities.TestUserArea1;
var command = new AddUserCommand()
{
Email = uniqueData + EMAIL_DOMAIN,
Password = PASSWORD,
RoleCode = userArea.RoleA.RoleCode,
UserAreaCode = userArea.UserAreaCode
};
await contentRepository
.Users()
.AddAsync(command);
command.OutputUserId = 0;
await contentRepository
.Awaiting(r => r.Users().AddAsync(command))
.Should()
.ThrowAsync <ValidationErrorException>()
.WithMemberNames(nameof(command.Email))
.WithMessage("*email*already*registered*");
}
public async Task WhenPasswordSignIn_CanAddWithMinimalData()
{
var uniqueData = UNIQUE_PREFIX + "PWSignIn_AddMinData";
using var app = _appFactory.Create();
var contentRepository = app.Services.GetContentRepositoryWithElevatedPermissions();
var dbContext = app.Services.GetRequiredService <CofoundryDbContext>();
var command = new AddUserCommand()
{
Email = uniqueData + EMAIL_DOMAIN,
Password = PASSWORD,
RoleCode = app.SeededEntities.TestUserArea1.RoleA.RoleCode,
UserAreaCode = app.SeededEntities.TestUserArea1.UserAreaCode
};
await contentRepository
.Users()
.AddAsync(command);
var user = await dbContext
.Users
.AsNoTracking()
.Include(r => r.Role)
.Include(r => r.EmailDomain)
.FilterById(command.OutputUserId)
.SingleOrDefaultAsync();
var lowerEmail = command.Email.ToLowerInvariant();
using (new AssertionScope())
{
command.OutputUserId.Should().BePositive();
user.Should().NotBeNull();
user.FirstName.Should().BeNull();
user.LastName.Should().BeNull();
user.DisplayName.Should().BeNull();
user.CreateDate.Should().NotBeDefault();
user.CreatorId.Should().BePositive();
user.Email.Should().Be(command.Email);
user.UniqueEmail.Should().Be(lowerEmail);
user.DeactivatedDate.Should().BeNull();
user.DeletedDate.Should().BeNull();
user.AccountVerifiedDate.Should().BeNull();
user.IsSystemAccount.Should().BeFalse();
user.LastSignInDate.Should().BeNull();
user.LastPasswordChangeDate.Should().NotBeDefault();
user.Password.Should().NotBeNullOrWhiteSpace();
user.PasswordHashVersion.Should().BePositive();
user.PreviousSignInDate.Should().NotBeDefault();
user.RequirePasswordChange.Should().BeFalse();
user.Role.RoleCode.Should().Be(command.RoleCode);
user.RoleId.Should().BePositive();
user.UserAreaCode.Should().Be(command.UserAreaCode);
user.Username.Should().Be(command.Email);
user.UniqueUsername.Should().Be(lowerEmail);
user.EmailDomain.Name.Should().Be("example.com");
user.SecurityStamp.Should().NotBeNullOrEmpty().And.HaveLength(32);
}
}
public ActionResult SignUp(AddUserCommand input)
{
//IoCFactory.Instance.TryResolve<IFullUrlBuilder>().FromUrl(Url.Action("Confirm", "Account"));
string pathResult = HttpContext.Request.Url.Scheme + "://" + HttpContext.Request.Url.Authority + Url.Action("Confirm", "Account");
input.PathResult = pathResult;
return(TryPush(input, setting => { setting.SuccessResult = () => RedirectToAction("LandingAjax", "Notification", new { type = "success", message = "Your account sign up. Please verify email." }); }));
}
