public ActionResult Create(CreateUserViewModel userViewModel, FormCollection form)
{
if (ModelState.IsValid)
{
var newUser = new ApplicationUser
{
Name = userViewModel.Name,
UserName = userViewModel.Email,
Email = userViewModel.Email
};
foreach (var i in getUserCoursesFromFormCollection(form, newUser.Id))
{
userCoursesRepository.AddUserCourse(i);
}
usersRepository.AddUser(newUser);
userCoursesRepository.SaveChanges();
if (userViewModel.Admin)
{
userManager.AddToRole(newUser.Id, "Administrator");
}
userManager.AddPassword(newUser.Id, userViewModel.Password);
return(RedirectToAction("Index"));
}
return(View(userViewModel));
}
public void AddUser_InvalidFields_ReturnsNull()
{
var usersDbMock = new Mock <IDb <User> >();
var insertIsCalled = false;
usersDbMock.Setup(db =>
db.Insert(It.IsAny <User>()))
.Callback((User user) => insertIsCalled = true);
var usersRepository = new UsersRepository(usersDbMock.Object);
Assert.IsNull(usersRepository.AddUser(null, "username", "password"));
Assert.IsNull(usersRepository.AddUser("name", null, "password"));
Assert.IsNull(usersRepository.AddUser("name", "username", null));
Assert.IsFalse(insertIsCalled);
}
public IActionResult SignUp(User user, string password)
{
UsersRepository rep = new UsersRepository(_connString);
rep.AddUser(user, password);
return(RedirectToAction("Login", "Account"));
}
public IActionResult Signup(User user, string password)
{
var db = new UsersRepository(_connectionString);
db.AddUser(user, password);
return(RedirectToAction("Index", "Home"));
}
public IActionResult Signup(User user, string password)
{
var repo = new UsersRepository(_connectionString);
repo.AddUser(user, password);
return(Redirect("/account/login"));
}
public int AddUser(User user)
{
user.Password = "******";
var repo = new UsersRepository();
return(repo.AddUser(user));
}
public async Task <IActionResult> Register(RegisterModel model)
{
if (ModelState.IsValid)
{
try
{
var user = _repo.GetUserByLogin(model.Username);
}
catch (Exception)
{
var hash = HashPassword(model.Password);
//получить юзера без добавления в базу и отправить в создание адреса, с него добавить в базу
var user = new Users {
Username = model.Username, Password = HashPassword(model.Password), Fullname = model.FullName
};
//_repo.AddUser(model.Username, hash, UserType.User, model.FullName);
UsersRepository.lastRegUser = _repo.AddUser(user);
//await Authenticate(model.Username);
return(RedirectToAction("Index", "RegAddress"));
return(RedirectToAction("Index", "Home"));
}
ModelState.AddModelError("", "Login or password are incorrect");
}
return(RedirectToAction("Error", "Home"));
}
public void AddUser_WhenCalled_ShouldReturnSameUser()
{
var usersRepository = new UsersRepository(DbContext);
var userToAdd = TestFactoryHelpers.CreateTestUser();
var addedUser = usersRepository.AddUser(userToAdd);
Assert.Equal(userToAdd, addedUser);
}
public void AddUser_WhenCalled_ShouldPutCreatedOnToUser()
{
var usersRepository = new UsersRepository(DbContext);
var userToAdd = TestFactoryHelpers.CreateTestUser();
var addedUser = usersRepository.AddUser(userToAdd);
Assert.NotNull(addedUser.CreatedOn);
}
public void Users_AddUser_SameUserTwice()
{
// Arrange
var repo = new UsersRepository(context);
var user = new UserView {
Name = "Hlynur",
Address = "Laufrimi 85",
Email = "*****@*****.**",
PhoneNumber = "823-8028"
};
// Act
repo.AddUser(user);
repo.AddUser(user);
// Assert
Assert.Fail("Should have thrown an AlreadyExistsException");
}
public ActionResult AddUser(CreateUserRequest createRequest)
{
if (!_validator.Validate(createRequest))
{
return(BadRequest(new { error = "Missing information. Please fill out the whole form." }));
}
var newUser = _usersRepository.AddUser(createRequest);
return(Created($"api/users/{newUser.Id}", newUser));
}
public void AddUser()
{
var repository = new UsersRepository();
repository.Initialize();
var initialCount = repository.GetUsers().Count;
repository.AddUser(new User());
Assert.AreEqual(initialCount + 1, repository.GetUsers().Count);
}
public void AddUser_WhenCalled_ShouldTrackUserInDbContext()
{
var usersRepository = new UsersRepository(DbContext);
var userToAdd = TestFactoryHelpers.CreateTestUser();
var addedUser = usersRepository.AddUser(userToAdd);
var trackingEntities = DbContext.ChangeTracker.Entries().Select(x => x.Entity);
Assert.Contains(addedUser, trackingEntities);
}
public ActionResult AddUser(CreateUserRequest createRequest)
{
if (!_validator.Validate(createRequest))
{
return(BadRequest(new { error = "Does Our User Have A Name?" }));
}
var newUser = _userRepository.AddUser(createRequest.Name, createRequest.ReleaseDate, createRequest.Age, createRequest.IsPrisoner);
return(Created($"api/users/{newUser.Id}", newUser));
}
public void LoginAction()
{
// todo call the api to login and store the token
var repo = new UsersRepository();
repo.AddUser(Account);
Account = new User();
RefreshTable();
}
public ActionResult Register(UserRegisterModel user)
{
if (UsersRepository.AddUser(user))
{
ModelState.Clear();
ViewBag.SuccessMessages = "Konto zostało utworzone pomyślnie";
return(View("Index"));
}
ViewBag.ErrorMessages = UsersRepository.ErrorList;
return(View("Register"));
}
public IActionResult Create([FromBody] UserDto model)
{
var cmd = new CreateUserCommand {
User = model
};
var events = _handler.Handle(null, cmd);
var streamId = _events.CreateStream("sample_user_123", Guid.NewGuid(), events.Single().Item2);
var(_, state) = _handler.GetUser(streamId);
var user = _repository.AddUser(state);
return(CreatedAtRoute("GetUser", new { id = user.Id }, user));
}
public void CreateUser_EmailAddressExistsAlready()
{
UserValidator userValidator = new UserValidator(@"^(?=.*[0-9])(?=.*[a-z])(?=.*[A-Z])(?=.*[\W_]).{6,}$", 6);
using (var db = new UsersRepository())
{
// Arrange
GenFu.GenFu.Configure <User>()
.Fill(x => x.EmailAddress).AsEmailAddress()
.Fill(x => x.Password, u => MockDataUtilities.RandomValidPassword(6))
.Fill(x => x.PasswordConfirmation, u => u.Password);
var user = GenFu.GenFu.New <User>();
// Act
db.AddUser(user, userValidator);
// add user again
string actualMessage = db.AddUser(user, userValidator);
// Assert
Assert.Equal(
Messages.UserExists,
actualMessage);
}
}
public void AddUser_AddCrashes_ReturnsNull()
{
var usersDbMock = new Mock <IDb <User> >();
var userToAdd = UsersList[0];
usersDbMock.Setup(db =>
db.Insert(It.IsAny <User>()))
.Throws <Exception>()
.Verifiable();
var usersRepository = new UsersRepository(usersDbMock.Object);
var userAdded = usersRepository.AddUser(userToAdd.Name, userToAdd.Username, "password");
Assert.IsNull(userAdded);
}
internal State UpdateSingleLoginMenu(FormFactory singleLoginForms, ButtonFactory singleLoginButtons,
State gameState, UsersRepository usersRepository, StarField starfield, GameTime gameTime)
{
MouseState mouseLogin = Mouse.GetState();
singleLoginForms.UpdateForms(mouseLogin);
singleLoginButtons.CreateButton(new Vector2(900, 426), State.SingleLoadGameMenu, "LogIn");
gameState = singleLoginButtons.ReturnButtonState(mouseLogin, gameState);
if (gameState == State.SingleLoadGameMenu)
{
usersRepository.AddUser(singleLoginForms);
}
starfield.Update(gameTime);
return(gameState);
}
public void AddUser_AddWorks_ReturnsUser()
{
var usersDbMock = new Mock <IDb <User> >();
var userToAdd = UsersList[0];
usersDbMock.Setup(db =>
db.Insert(It.IsAny <User>()))
.Callback((User u) => u.Id = 1)
.Verifiable();
var usersRepository = new UsersRepository(usersDbMock.Object);
var userAdded = usersRepository.AddUser(userToAdd.Name, userToAdd.Username, "password");
Assert.IsNotNull(userAdded);
Assert.AreEqual(1, userAdded.Id);
Assert.AreEqual(userToAdd.Name, userAdded.Name);
Assert.AreEqual(userToAdd.Username, userAdded.Username);
}
//Given_?_When_?_Then_?
public void Given_A_UserRepository_When_I_Call_AddUser_Then_A_User_Should_Be_Added()
{
// Arrange
var user = _fixture.Create <User>();
var options = new DbContextOptionsBuilder <UserContext>()
.UseInMemoryDatabase(databaseName: Guid.NewGuid().ToString())
.Options;
var context = new UserContext(options);
var mapping = Substitute.For <IPropertyMappingService>();
var usersRepository = new UsersRepository(context, mapping);
// Act
usersRepository.AddUser(user);
usersRepository.Save();
// Assert
Assert.Equal(1, context.Users.Count());
}
public ActionResult Registration(User u, string ConfirmPassword)
{
try {
if (ModelState.IsValid)
{
if (ConfirmPassword == u.Password)
{
UsersRepository ur = new UsersRepository();
if (ur.DoesUsernameExist(u.Username) == true)
{
ViewBag.Error = "Username already exist";
//return View(u);
}
else
{
u.Password = Encryption.HashPassword(u.Password)
;
ur.AddUser(u);
Role defaultrole = ur.GetDefaultRole();
ur.AllocateRoleToUser(u, defaultrole);
ViewBag.Message = "Registration successful";
ModelState.Clear();
}
}
else
{
ViewBag.Error = "password do not match";
}
}
else
{
ViewBag.Error = "Check your inputs";
}
}
catch (Exception ex)
{
ViewBag.Error = "Registration failed!";
}
return(View());
}
public IActionResult AddUser([FromBody] UserDto user)
{
if (ModelState.IsValid)
{
try
{
repo.AddUser(user);
return(Ok(string.Format("Successfully added {0} {1}", user.First_Name, user.Last_Name)));
}
catch (Exception e)
{
return(Ok(e.Message));
}
}
else
{
return(Ok("Form data correctly given"));
}
}
public void CreateUser_PasswordTooShort()
{
UserValidator userValidator = new UserValidator(@"^(?=.*[0-9])(?=.*[a-z])(?=.*[A-Z])(?=.*[\W_]).{6,}$", 6);
var db = new UsersRepository();
// Arrange
GenFu.GenFu.Configure <User>()
.Fill(x => x.EmailAddress).AsEmailAddress()
.Fill(x => x.Password, u => MockDataUtilities.RandomValidPassword(4))
.Fill(x => x.PasswordConfirmation).Fill(u => u.Password);
var user = GenFu.GenFu.New <User>();
// Act
string actualMessage = db.AddUser(user, userValidator);
// Assert
Assert.Equal(
Messages.PasswordTooShort,
actualMessage);
}
public void Register(User u)
{
UsersRepository ur = new UsersRepository();
if (ur.DoesUsernameExist(u.Username) == true)
{
throw new UsernameExistsException("Username already exists");
}
else
{
u.Password = new Encryption().HashString(u.Password);
AsymmetricParameters myParameters = new Encryption().GenerateAsymmetricParameters();
u.PublicKey = myParameters.PublicKey;
u.PrivateKey = myParameters.PrivateKey;
ur.AddUser(u);
ur.AllocateRoleToUser(u, ur.GetRole(1));
}
}
public ActionResult Register(FormCollection collection, Usuario user, HttpPostedFileBase file)
{
try
{
// TODO: Add insert logic here
bool teste = UsersRepository.Checar(user);
if (teste == false)
{
UsersRepository.AddUser(user, file);
Usuario login = UsersRepository.Login(user);
Session["object"] = login;
return(RedirectToAction("Welcome"));
}
return(View());
}
catch
{
return(View());
}
}
public void Users_AddUser_OneUser()
{
// Arrange
var repo = new UsersRepository(context);
var user = new UserView {
Name = "Hlynur",
Address = "Laufrimi 85",
Email = "*****@*****.**",
PhoneNumber = "823-8028"
};
// Act
repo.AddUser(user);
// Assert
Assert.AreEqual(2, context.Users.Count());
Assert.AreEqual("Hlynur", context.Users.Where(x => x.Name == "Hlynur").SingleOrDefault().Name);
Assert.AreEqual("Laufrimi 85", context.Users.Where(x => x.Address == "Laufrimi 85").SingleOrDefault().Address);
Assert.AreEqual("*****@*****.**", context.Users.Where(x => x.Email == "*****@*****.**").SingleOrDefault().Email);
Assert.AreEqual("823-8028", context.Users.Where(x => x.PhoneNumber == "823-8028").SingleOrDefault().PhoneNumber);
}
private async Task ResumeAfterUserDialog(IDialogContext context, IAwaitable <UserForm> result)
{
try
{
var message = await result;
if (message != null)
{
UsersRepository repository = new UsersRepository();
repository.AddUser(message);
}
}
catch (Exception ex)
{
await context.PostAsync($"Failed with message: {ex.Message}");
}
finally
{
context.Wait(this.MessageReceivedAsync);
}
}
public async Task <ActionResult> ExternalLoginCallback(string returnUrl)
{
var loginInfo = await AuthenticationManager.GetExternalLoginInfoAsync();
if (loginInfo == null)
{
return(RedirectToAction("Login"));
}
AuthenticationManager.SignOut(DefaultAuthenticationTypes.ApplicationCookie);
ClaimsIdentity claimsIdentity = new ClaimsIdentity(DefaultAuthenticationTypes.ApplicationCookie, ClaimTypes.NameIdentifier, ClaimTypes.Role);
claimsIdentity.AddClaim(new Claim(ClaimTypes.NameIdentifier, loginInfo.Email, "http://www.w3.org/2001/XMLSchema#string"));
claimsIdentity.AddClaim(new Claim(ClaimTypes.Name, loginInfo.DefaultUserName, "http://www.w3.org/2001/XMLSchema#string"));
claimsIdentity.AddClaim(new Claim("http://schemas.microsoft.com/accesscontrolservice/2010/07/claims/identityprovider", "Custom Identity", "http://www.w3.org/2001/XMLSchema#string"));
AuthenticationManager.SignIn(new AuthenticationProperties()
{
IsPersistent = true
}, claimsIdentity);
string name = loginInfo.ExternalIdentity.Claims.ElementAt(1).Value;
string surname = loginInfo.ExternalIdentity.Claims.ElementAt(2).Value;
UsersRepository ur = new UsersRepository();
if (ur.DoesEmailExist(loginInfo.Email) == false)
{
ur.AddUser(loginInfo.Email, name, surname);
}
else
{
//update lastloggedin
ur.UpdateLastLoggedIn(loginInfo.Email);
}
return(RedirectToAction("Index", "Home"));
}