public async void DoneClick(object sender, EventArgs e) { user.email = emailEntry.Text; user.firstName = firstNameEntry.Text; user.lastName = lastNameEntry.Text; await userRepository.AddAsync(user); await DisplayAlert("Profilo utente", "Profilo aggiornato correttamente", "OK"); }
public void AddAsync_MissingUsernameThrows() { var(repo, _) = SetupTarget(); var user = new User { Username = String.Empty, Password = "******" }; var ex = Assert.ThrowsAsync <MessageStoreException>(async() => await repo.AddAsync(user)); Assert.That(ex.ErrorCode, Is.EqualTo(ErrorCodes.Required)); }
public async Task AddAsync() { var user = new User { Id = 2, Name = "Test", Email = "*****@*****.**" }; var userAdded = await _repository.AddAsync(user); Assert.True(userAdded.Id == user.Id && userAdded.Name == user.Name && userAdded.Email == user.Email); }
public async Task Niepoprawne_dawanie_do_bazy_danych_nowego_użytkownika__Dwukrotna_próba_podania_tych_samych_danych() { // Arrange DbContextOptions <DataBaseContext> options = new DbContextOptionsBuilder <DataBaseContext>() .UseInMemoryDatabase(Guid.NewGuid().ToString()) .Options; DataBaseContext context = new DataBaseContext(options); User user = new User("*****@*****.**", "tester", "secret", "user"); UserRepository userRepository = new UserRepository(context); // Act await userRepository.AddAsync(user); // Assert await Assert.ThrowsAsync <ArgumentException>(async() => await userRepository.AddAsync(user)); }
public async Task <IActionResult> Register(RegisterModel model) { if (ModelState.IsValid) { User user = await db.FindUserByEmailAsync(model.Email); if (user == null) { // добавляем пользователя в бд var us = new User { Email = model.Email, Password = model.Password }; await db.AddAsync(us); await Authenticate(model.Email); // аутентификация return(RedirectToAction("Index", "Home")); } else { ModelState.AddModelError("", "Некорректные логин и(или) пароль"); } } return(View(model)); }
public void ValidateExistUser() { var user = new User { BirthDate = DateTime.Now.AddYears(-20), Cpf = "56602275038", Name = "Amilton Nobregas", Password = "******" }; var context = new ContextFake().CreateContext(); var repostorio = new UserRepository(context); repostorio.AddAsync(user).Wait(); context.SaveChanges(); var userModel = new UserModel { BirthDate = DateTime.Now.AddYears(-20), Cpf = "56602275038", Name = "Amilton Nobregas", Password = "******", }; var result = _userValidation.ValidateModel(userModel); Assert.False(result.Success); repostorio.Delete(user).Wait(); context.SaveChanges(); }
private async Task RegisterInGame(Message message) { var fullName = $"{message.from.first_name} {message.from.last_name}"; var checkUser = await _userRepository.GetUserByIdAndChatIdAsync(message.from.id, message.chat.id); if (checkUser != null) { var foundChat = await _chatRepository.GetByTelegramId(message.chat.id); User user = new User() { TelegramId = message.from.id, LastName = message.from.last_name, FirstName = message.from.first_name, Chat = foundChat }; await _userRepository.AddAsync(user).ConfigureAwait(false); await _userRepository.SaveAsync().ConfigureAwait(false); string text = $"Поздравляю! Теперь {fullName} участвует в погоне за бонусами"; _service.SendMessageAsync(message.chat.id, text); } else { string text = $"{fullName} узбагойся, дай другим отхватить кусочек бонусов!"; _service.SendMessageAsync(message.chat.id, text); } }
public async Task <UserDisplayDto> CreateUser(UserRegisterDto user) { User createdUser = new User { FirstName = user.FirstName, LastName = user.LastName, Email = user.Email, PasswordHash = Util.HashHelper.GetMD5HashData(user.Password), UserName = user.UserName, CreatedOn = DateTime.Now }; LMSEntities context = new LMSEntities(); UserRepository userRepository = new UserRepository(context); createdUser = await userRepository.AddAsync(createdUser); UserDisplayDto displayUser = new UserDisplayDto { UserName = user.UserName, FirstName = user.FirstName, LastName = user.LastName, Email = user.Email, }; return(displayUser); }
public async void RegisterButton_Clicked(object sender, EventArgs e) { try { string uid = await auth.RegisterWithEmailAndPassword(emailEntry.Text, passwordEntry.Text); if (!string.IsNullOrEmpty(uid)) { User u = new User(); u.email = emailEntry.Text; u.password = passwordEntry.Text; u.uid = uid; await userRepository.AddAsync(u); Application.Current.MainPage = new MainPage(u); } else { ShowError(); } }catch (Exception ex) { await DisplayAlert("Errore", "L'email inserita è già utilizzata da un altro account", "OK"); } }
private static void GenerateOneUser(string username, string email, string password, bool isAdmin) { UserRepository userRepository = new UserRepository(connString); testUsernames.Add(username); // no need for creating the user if it already exists if (userRepository.FindByCondition("username", username).Result.Any()) { return; } User user = new User() { Username = username, Email = email, Password = SecurePasswordHasher.Hash(password), IsAdmin = false }; var addResult = userRepository.AddAsync(user); if (addResult.Result == null) { Console.WriteLine("A user could not be created"); } }
public async Task Should_Get_User_By_ObjectId() { IUserRepository userRepo = new UserRepository( _fxt.Database.GetCollection <User>("users") ); // insert a new user into the collection string userId; { User newUser = new User { FirstName = "Dave", DisplayId = "dav3", PassphraseHash = "passphrase~hash" }; await userRepo.AddAsync(newUser); userId = newUser.Id; } User user = await userRepo.GetByIdAsync(userId); Assert.Equal("Dave", user.FirstName); Assert.Equal("dav3", user.DisplayId); Assert.Equal("passphrase~hash", user.PassphraseHash); Assert.True(ObjectId.TryParse(user.Id, out _), "User ID should be a Mongo ObjectID."); Assert.InRange(user.JoinedAt, DateTime.UtcNow.AddSeconds(-5), DateTime.UtcNow); Assert.Null(user.LastName); Assert.Null(user.Token); Assert.Null(user.ModifiedAt); }
public async Task <User> FindUserByUsernameAsync(string username, bool?isAdmin = null) { var user = await _userRepository.GetUserByUsernameAsync(username.TrimStart('@')); if (user == null || (isAdmin.HasValue && user.IsGlobalAdmin != isAdmin)) { var tlUser = await _userTL.FindUserByUsernameAsync(username); if (tlUser == null) { throw new ArgumentException($"User {username} does not exists"); } var existingUser = user ?? await _userRepository.GetUserByTLIdAsync(tlUser.id); if (existingUser != null) { CopyUserProps(existingUser, tlUser, isAdmin); await _userRepository.SaveChangesAsync(); user = existingUser; } else { user = new User { Id = tlUser.id }; CopyUserProps(user, tlUser, isAdmin); await _userRepository.AddAsync(user); } } return(user); }
public Task HandleAsync(CreateUser command) { var user = userFactory.Create(command.FirstName, command.LastName, command.Email, command.Password, command.Role); command.CreatedId = user.Id; return(repository.AddAsync(user)); }
public async Task <ISingleResponse <UserModel> > AddUserAsync(UserModel details) { Logger.Info(CreateInvokedMethodLog(MethodBase.GetCurrentMethod().ReflectedType.FullName)); var response = new SingleResponse <UserModel>(); using (var transaction = DbContext.Database.BeginTransaction()) { try { var user = Mapper.Map <User>(details); await UserRepository.AddAsync(user); var userCredential = Mapper.Map <UserCredential>(details); userCredential.User = user; await UserCredentialRepository.AddAsync(userCredential); transaction.Commit(); response.Model = Mapper.Map <UserModel>(user); } catch (Exception ex) { transaction.Rollback(); response.SetError(ex, Logger); } } return(response); }
public async Task AddUserInformationAsync(User user) { if (user == null) { throw new ArgumentNullException(nameof(user)); } var userId = await userRepository.AddAsync(UserMapping.CreateDtoUser(user)); if (user.Address != null) { var addressId = await addressRepository.AddAsync(AddressMapping.CreateDtoAddress(user.Address)); await userAddressesRepository.AddAsync(AddressMapping.CreateUserAddressDTO(userId, addressId)); } }
public async void LeaveClick(object sender, EventArgs e) { familyTabPageViewModel.family.removeMember(familyTabPageViewModel.user.uid); familyTabPageViewModel.user.familyId = null; await familyRepository.AddAsync(familyTabPageViewModel.family); await userRepository.AddAsync(familyTabPageViewModel.user); GoInAddMode(); await Device.InvokeOnMainThreadAsync(async() => { lstUsers.ItemsSource = familyTabPageViewModel.members; }); await Device.InvokeOnMainThreadAsync(async() => { familyNameEntry.Text = ""; }); await DisplayAlert("La tua famiglia", "Sei uscito correttamente dalla famiglia", "OK"); Parent.BindingContext = familyTabPageViewModel; }
public async Task when_adding_newuser_it_should_be_added_correctly_to_the_collection() { var user = new User(Guid.NewGuid(), "user", "test", "*****@*****.**", "secret"); IUserRepository repository = new UserRepository(); await repository.AddAsync(user); var exestingUser = await repository.GetAsync(user.Id); Assert.Equal(user, exestingUser); }
public async Task <TLDialogs> AutoKickAsync() { var dialogs = await _messagesTL.GetDialogsAsync(); if (dialogs?.dialogs == null || dialogs.dialogs.lists.Count == 0) { return(dialogs); } var autoKickChats = await _chatRepository.GetAutoKickAsync(); foreach (var dialog in dialogs.dialogs.lists.Where(d => d.unread_count > 0 && d.peer is TLPeerChat).ToList()) { var chatId = ((TLPeerChat)dialog.peer).chat_id; if (autoKickChats.All(c => c.Id != chatId)) { continue; } var users = await _messagesTL.GetAddUserMessagesAsync(chatId, dialog.unread_count); foreach (var tlUser in users) { var user = await _userRepository.GetUserByTLIdAsync(tlUser.id) ?? new User { Id = tlUser.id }; UserService.CopyUserProps(user, tlUser, false); if (user.UserId == 0) { await _userRepository.AddAsync(user); } else { await _userRepository.SaveChangesAsync(); } try { await _chatTL.RemoveUserAsync(new Chat { Id = chatId }, user); } catch (InvalidOperationException ex) { if (!ex.Message.Equals("USER_NOT_PARTICIPANT", StringComparison.InvariantCultureIgnoreCase)) { throw; } } } await _messagesTL.MarkUserMessagesAsReadAsync(new TLInputPeerChat { chat_id = chatId }); } return(dialogs); }
public async Task <ActionResult <string> > PostAsync([FromBody] UserEntity PEntity) { if (await _UserRepository.AddAsync(PEntity).ConfigureAwait(false) > 0) { return(Ok(PEntity)); } else { return(Ok(PEntity)); } }
private static void InitData() { for (int i = 0; i < 50; i++) { var gender = FakeUtil.CreateGender(); var item = new User() { Username = FakeUtil.CreateUsername(5, 10), Password = FakeUtil.CreatePassword(), Email = FakeUtil.CreateEmail(), Name = FakeUtil.CreatePersonName(gender), Gender = gender, Age = FakeUtil.RandomInt(18, 50), CreateTime = DateTime.Now }; _userRepository.AddAsync(item).GetAwaiter().GetResult(); Assert.True(true); } }
public async Task CreateNewUser() { //Arrange User user = new User(); user.Id = 0; user.Username = "******"; user.Email = "user1Email"; user.Password = SecurePasswordHasher.Hash("user1password"); user.IsAdmin = false; user.CreatedAt = DateTime.Now; //Act var addResult = await userRepository.AddAsync(user); //Assert Assert.IsNotNull(addResult); Assert.AreEqual(user.Username, addResult.Username); Assert.AreEqual(user.Email, addResult.Email); Assert.AreEqual(user.Password, addResult.Password); }
public async Task Should_Throw_When_Add_Duplicate_Username() { IUserRepository userRepo = new UserRepository( _fxt.Database.GetCollection <User>("users") ); await Assert.ThrowsAsync <DuplicateKeyException>(() => userRepo.AddAsync(new User { DisplayId = "CHuck" }) ); }
public async Task LoadImmage() { try { string path = DownloadImage(new Uri(await firebaseStorageService.GetFile(user.uid), UriKind.Absolute)); user.photoURL = path; await userRepository.AddAsync(user); } catch (Exception e) { user.photoURL = "placeholder_profile.png"; } }
public async Task when_adding_new_user_it_should_be_added_correcty_to_the_list() { //Arrange var user = new User(Guid.NewGuid(), "user", "test", "*****@*****.**", "secret"); IUserRepository repository = new UserRepository(); //Act await repository.AddAsync(user); //Assert var existingUser = await repository.GetAsync(user.Id); Assert.Equal(user, existingUser); }
public async Task Post_Login_Returns_Ok() { //Arrange string email = "*****@*****.**"; string password = "******"; UserViewModel user = new UserViewModel() { Email = email, FirstName = "Atanas", LastName = "Kambitov", Id = 1, IsAdmin = true, UniqueToken = Guid.NewGuid().ToString(), Lists = new List <TodoListViewModel>(), }; await _userRepository.AddAsync(user, password); _userRepository.CommitChanges(); LoginViewModel model = new LoginViewModel { Email = email, Password = password }; //Act int usersCount = _userRepository.Count(); var result = await _authController.Post(model); var objectResponse = result as ObjectResult; //Assert Assert.Equal(1, usersCount); Assert.IsType <OkObjectResult>(result); Assert.Equal(200, objectResponse.StatusCode); }
public async Task Should_Add_New_User() { // insert a new user into the collection User user; { IUserRepository userRepo = new UserRepository( _fxt.Database.GetCollection <User>("users") ); user = new User { FirstName = "Charles", DisplayId = "chuck", PassphraseHash = "some secret-PASS" }; await userRepo.AddAsync(user); } // ensure user object is updated { Assert.Equal("Charles", user.FirstName); Assert.Equal("chuck", user.DisplayId); Assert.Equal("some secret-PASS", user.PassphraseHash); Assert.NotNull(user.Id); Assert.True(ObjectId.TryParse(user.Id, out _), "User ID should be a Mongo ObjectID."); Assert.InRange(user.JoinedAt, DateTime.UtcNow.AddSeconds(-5), DateTime.UtcNow); Assert.Null(user.LastName); Assert.Null(user.Token); Assert.Null(user.ModifiedAt); } // ensure user document is created in the collection { BsonDocument userDocument = _fxt.Database .GetCollection <BsonDocument>("users") .FindSync(FilterDefinition <BsonDocument> .Empty) .Single(); Assert.Equal( BsonDocument.Parse($@"{{ _id: ObjectId(""{user.Id}""), name: ""chuck"", pass: ""some secret-PASS"", fname: ""Charles"", joined: ISODate(""{user.JoinedAt:O}"") }}"), userDocument ); } }
public async Task AddAsync_UniqueValidUser_AddedToList() { //Arange var user = new User(Guid.NewGuid(), "admin", "admin", "*****@*****.**", "pasword"); IUserRepository userRepository = new UserRepository(); //Act await userRepository.AddAsync(user); //Assert var existingUser = await userRepository.GetAsync("*****@*****.**"); Assert.Equal(existingUser, user); }
public async Task when_adding_new_user_it_should_be_added_correctly_to_the_list() { //Arrange - cały setup, przypisujemy zmienne, wartosci itp var user = new User(Guid.NewGuid(), "user", "test", "*****@*****.**", "secret"); IUserRepository repository = new UserRepository(); //Act - operacja, która ma zostać sprawdzona await repository.AddAsync(user); //Assert - sprawdzenie, czy test jest poprawny var existingUser = await repository.GetAsync(user.Id); Assert.Equal(user, existingUser); }
public async Task <User> Handle(UserCreateCommand request, CancellationToken cancellationToken) { (string Salt, string Hashed)p = Password.Hash(request.Password); var user = await UserRepository.AddAsync(new User { Email = request.Email, Password = p.Hashed, Salt = p.Salt, Name = request.Name, Created = System.DateTime.Now }); return(user); }
public async Task WhenAddingNewUserThanItBeAddedCorrectlyToTheList() { // Arrange var user = new User(Guid.NewGuid(), "user", "NewUser", "*****@*****.**", "tajneHasło 54%$"); IUserRepository repo = new UserRepository(); // Act await repo.AddAsync(user); var existingUser = await repo.GetAsync(user.Id); // Assert Assert.Equal(user, existingUser); }