public static void ValidatePassport(Domain.Entities.User userDestiny) { if (userDestiny == null) { throw new Exception("Passaporte inválido!"); } }
public static void ValidateAmountBank(decimal amount, Domain.Entities.User user) { if (user?.AmountBank < amount) { throw new Exception("Saldo insuficiente no banco!"); } }
/// <summary> /// /// </summary> /// <returns></returns> public Result <Domain.Entities.User> Add(Domain.Entities.User user) { Result <Domain.Entities.User> result = new Result <Domain.Entities.User>(); try { if (GetByEmail(user.Email).Success) { result = Result <Domain.Entities.User> .ReturnMessageCollect("Usuário já cadastrado.", null); } result.Content = Converters.ConvertUserToModel( _userRepository.Add(Converters.ConvertUserToData(user)) ); _userRepository.SaveChanges(); result = Result <Domain.Entities.User> .ReturnMessageCollect("Sucess", result.Content); } catch (Exception ex) { result = Result <Domain.Entities.User> .ReturnMessageCollect(ex.Message, null); } return(result); }
public GetAddressesQueryHandlerFixture(QueryTestFixture fixture) { Context = fixture.Context; CurrentUser = new Domain.Entities.User { Id = Guid.NewGuid() }; Context.User.Add(CurrentUser); Addresses = new List <Domain.Entities.Address> { new Domain.Entities.Address { UserId = CurrentUser.Id }, new Domain.Entities.Address { UserId = CurrentUser.Id }, new Domain.Entities.Address { UserId = Guid.NewGuid() }, }; Context.Address.AddRange(Addresses); Context.SaveChanges(); }
public async Task <User> Handle(RegistrationCommand request, CancellationToken cancellationToken) { if (await _context.Users.Where(x => x.Email == request.Email).AnyAsync(cancellationToken: cancellationToken)) { throw new RestException(HttpStatusCode.BadRequest, new { Email = "Email already exist" }); } var user = new Domain.Entities.User { DisplayName = request.DisplayName, Email = request.Email, Balance = 500 }; var result = await _userManager.CreateAsync(user, request.Password); if (result.Succeeded) { var userResponse = _mapper.Map <User>(user); userResponse.Token = _jwtGenerator.CreateToken(user); return(userResponse); } throw new Exception("Client creation failed"); }
public TokenViewModel GenerateToken(Domain.Entities.User user) { var handler = new JwtSecurityTokenHandler(); var key = Encoding.ASCII.GetBytes(options.Value.SecretKey); DateTime createdAt = DateTime.Now; DateTime expireDate = createdAt.AddHours(2); var tokenDescriptor = new SecurityTokenDescriptor { Subject = new ClaimsIdentity( new[] { new Claim("id", user.Id.ToString()), new Claim("userName", user.UserName), }), NotBefore = createdAt, Expires = expireDate, SigningCredentials = new SigningCredentials( new SymmetricSecurityKey(key), SecurityAlgorithms.HmacSha256Signature), Issuer = options.Value.Issuer }; var token = handler.CreateToken(tokenDescriptor); return(new TokenViewModel { Token = handler.WriteToken(token), CreatedAt = createdAt, Expires = expireDate }); }
private async Task AddUser(CreateAccountsCommand request) { var user = new Domain.Entities.User(); var passwordHash = _passwordHasher.HashPassword(request.Password); request.Password = passwordHash; var roles = request.IdRoles.Count() == 0 ? new List <Domain.Entities.Role>() { await _roleRepository .GetRoleIdByName("Clients") .ConfigureAwait(false) } : await _roleRepository .GetRolesByIdAsync(request.IdRoles.ToArray()) .ConfigureAwait(false); user.Create( request, roles); user.Email = request.Email.Trim().ToLowerInvariant(); user.IsActive = false; await _roleClaimAggregationRepository.AddUserRoles(user).ConfigureAwait(false); }
// Service public Result <Domain.Entities.User> Update(Domain.Entities.User user) { Result <Domain.Entities.User> result = new Result <Domain.Entities.User>(); try { result.Content = Converters.ConvertUserToModel( _userRepository.Update(Converters.ConvertUserToData(user)) ); if (result.Content != null) { result = Result <Domain.Entities.User> .ReturnMessageCollect("Usuário já cadastrado.", null); _userRepository.SaveChanges(); } else { result = Result <Domain.Entities.User> .ReturnMessageCollect("Usuário não encontrado.", result.Content); } } catch (Exception ex) { result = Result <Domain.Entities.User> .ReturnMessageCollect(ex.Message, null); } return(result); }
public ListEmployees(MetroStyleManager manager) { InitializeComponent(); this.StyleManager = manager; Style_Page(); User = new Domain.Entities.User(); }
public static void ValidateAmountWallet(decimal amount, Domain.Entities.User user) { if (user?.AmountWallet < amount) { throw new Exception("Saldo insuficiente na carteira!"); } }
public ProfileViewModel(INavigationService navigator, string navigationPath) { #region Navigation NavigationPath = navigationPath; _navigator = navigator; NavigateBack = new Command(() => { _navigator.NavigateBack(); }); UpdateCommand = new Command(async() => { if (!await Update()) { await _navigator.DisplayAlert("Alert", ErrorMessage, "OK"); } }); #endregion _user = new UserViewModel().User; ProfileInformation = new ProfileInformation { Username = _user.Username, Email = _user.Email, FirstName = _user.FirstName, LastName = _user.LastName, Address = _user.Address, City = _user.City, Country = _user.Country, ZipCode = _user.ZipCode }; }
public GetPrimaryAddressQueryHandlerFixture() { Context = TyreKlickerContextFactory.Create(); CurrentUser = new Domain.Entities.User(); UserWithNoAddress = new Domain.Entities.User(); Context.Add(CurrentUser); Context.Add(UserWithNoAddress); CurrentPrimaryAddress = new Domain.Entities.Address { UserId = CurrentUser.Id, PrimaryAddress = true }; Addresses = new List <Domain.Entities.Address> { new Domain.Entities.Address { UserId = CurrentUser.Id, PrimaryAddress = true }, new Domain.Entities.Address { UserId = CurrentUser.Id } }; Context.Address.Add(CurrentPrimaryAddress); Context.Address.AddRange(Addresses); Context.SaveChanges(); }
private void metroLink1_Click(object sender, System.EventArgs e) { if (mtxtSenhaClientes.Text == "") { errors.SetError(this.mtxtSenhaClientes, "Campo Obrigatório"); } if (metroTextBox1.Text == "") { errors.SetError(this.metroTextBox1, "Campo Obrigatório"); } if (mtxtUsuarioClientes.Text != "") { errors.SetError(this.mtxtUsuarioClientes, "Campo Obrigatório"); } if (mtxtSenhaClientes.Text != metroTextBox1.Text) { errors.SetError(this.mtxtSenhaClientes, "Os campos não conferem"); errors.SetError(this.metroTextBox1, "Os campos não conferem"); } if (mtxtUsuarioClientes.Text != "" && metroTextBox1.Text == mtxtSenhaClientes.Text) { var userDomain = _appCar.GetUser(mtxtUsuarioClientes.Text); if (userDomain.Name == null) { User = new Domain.Entities.User(mtxtUsuarioClientes.Text, mtxtSenhaClientes.Text, false); Completar_Cadastro form = new Completar_Cadastro(this.StyleManager); form.User = User; form.ShowDialog(); } else { MetroMessageBox.Show(this, "Usuário já cadastrado", "Cadastro de cliente", MessageBoxButtons.OK, MessageBoxIcon.Error, 100); } } }
public async Task <int> Handle(RegisterUserCommand request, CancellationToken cancellationToken) { string hash = EncryptionLib.GetRandomKey(64); string encryptedPassword = EncryptionLib.Encrypt(request.User.Password, hash); Domain.Entities.Cart cart = new Domain.Entities.Cart() { Products = new List <Domain.Entities.ProductCart>(), Total = 0 }; dbContext.Carts.Add(cart); await dbContext.SaveChangesAsync(cancellationToken); Domain.Entities.User user = new Domain.Entities.User { UserName = request.User.UserName, Password = encryptedPassword, Salt = hash, CreatedAt = DateTime.Now, UpdatedAt = DateTime.Now, Email = request.User.Email, IsDeleted = false, EmailConfirmed = true, IsLocked = false, RoleId = 2, CartId = cart.CartId }; dbContext.Users.Add(user); request.User.UserId = user.UserId; return(await dbContext.SaveChangesAsync(cancellationToken)); }
private static void VerifyUserCreatedBoard(Domain.Entities.User currentUser, Domain.Entities.Board board) { if (board.Creator.Id != currentUser.Id) { throw new UnauthorizedException(); } }
/// <summary> /// /// </summary> /// <returns></returns> public Result <Domain.Entities.User> Login(Domain.Entities.User user) { Result <Domain.Entities.User> result = new Result <Domain.Entities.User>(); try { result.Content = Converters.ConvertUserToModel( _userRepository.Login(Converters.ConvertUserToData(user)) ); if (result.Content == null) { result = Result <Domain.Entities.User> .ReturnMessageCollect("E-mail ou senha incorreta.", null); } else { result = Result <Domain.Entities.User> .ReturnMessageCollect("Sucess", result.Content); } } catch (Exception ex) { result = Result <Domain.Entities.User> .ReturnMessageCollect(ex.Message, null); } return(result); }
public static UserViewModel ToSingleUserViewModel(this Domain.Entities.User val) { UserViewModel model = new UserViewModel(); if (val == null) { model = null; } else { model = new UserViewModel { ID = val.ID, Key = val.Key, Username = val.Username, Password = val.Password, Email = val.Email, FirstName = val.FirstName, LastName = val.LastName, MiddleName = val.MiddleName, Active = val.Active, Roles = val.UserRoles?.Select(ur => new RoleViewModel { ID = ur.RoleID, Key = ur.Role.Key, Name = ur.Role.Name, Active = ur.Role.Active }).ToList() ?? null }; } return(model); }
public async Task <Unit> Handle(Command request, CancellationToken cancellationToken) { var user = await _context.Users.SingleOrDefaultAsync(x => x.UserName == _userAccessor.GetCurrentUsername()); if (user != null) { throw new RestException(HttpStatusCode.BadRequest, new { User = "******" }); } user = new Domain.Entities.User { UserName = _userAccessor.GetCurrentUsername(), DisplayName = request.DisplayName, Email = _userAccessor.GetCurrentEmail() }; _context.Users.Add(user); var success = await _context.SaveChangesAsync() > 0; if (success) { return(Unit.Value); } throw new Exception("Problem creating local user"); }
public static TyreKlickerDbContext Create() { var options = new DbContextOptionsBuilder <TyreKlickerDbContext>() .UseInMemoryDatabase(Guid.NewGuid().ToString()) .Options; var context = new TyreKlickerDbContext(options); context.Database.EnsureCreated(); var user = new Domain.Entities.User { Id = Guid.Parse("2220d661-6a96-4537-a896-5014374d39f5"), Email = "*****@*****.**", FirstName = "Ryan", LastName = "Stuart" }; context.User.Add(user); context.Address.AddRange(new Domain.Entities.Address { City = "SEDGWICK", PrimaryAddress = true, PhoneNumber = "070 1639 2540", Postcode = "LA8 4HA", Street = "HOPE STREET", User = user }); SeedOrders(context); context.SaveChanges(); return(context); }
public async Task <Unit> Handle(UpsertUserCommand request, CancellationToken cancellationToken) { var user = new Domain.Entities.User(); if (request.Id == 0) { _context.Users.Add(user); } else { user = await _context .Users .FirstOrDefaultAsync(u => u.Id == request.Id, cancellationToken); if (user == null) { throw new NotFoundException(nameof(User), request.Id); } } _mapper.Map(request, user); await _context.SaveChangesAsync(cancellationToken); return(Unit.Value); }
public void ShouldNotAuthenticateBannedPlayers() { var playersRepository = new InMemoryUserRepository(); var uowFactory = new UnitOfWorkFactoryMock(playersRepository, Mock.Of<IPublicMessageRepository>()); var moderator = new Domain.Entities.User("Egor", "123", "111111", true, 13, string.Empty, "Belarus"); moderator.GrantModeratorship(); var player = new Domain.Entities.User("Egor", "123", "111111", true, 13, string.Empty, "Belarus"); playersRepository.Add(player); player.Ban(moderator); var sessionMock = new Mock<ISession>(); var transactionFactoryMock = new Mock<ITransactionFactory>(); var authService = new AuthenticationService(Mock.Of<ISettings>(), transactionFactoryMock.Object, uowFactory); var response = authService.Authenticate(sessionMock.Object, new AuthenticationRequest { Name = "Egor", Password = "******", Huid = "111111", }); Assert.AreEqual(AuthenticationResponseType.Banned, response.Result); }
public async Task <Response> Handle(Request request, CancellationToken cancellationToken) { if (await this._userReadRepository.GetByEmailAsync(request.Email) != null) { return(new Response().AddError("Email already registered")); } if (await this._userReadRepository.GetByCPFAsync(request.CPF) != null) { return(new Response().AddError("CPF already registered")); } var user = new Domain.Entities.User(request.Name, request.Email, request.CPF, (int)UserProfile.User, request.Password); _userWriteRepository.Add(user); await _uow.CommitAsync(); var emailSubject = "Seja bem vindo ao Calculador de Dívida!"; var emailBody = $"<p>Olá, {user.Name}!</p>" + "<p>Sua conta de usuário no sistema Calculador de Dívida foi criada com sucesso!.<p/>"; List <string> emails = new List <string>(); emails.Add(user.Email); await _mediator.Publish(new Notification(emailSubject, emailBody, emails)); return(new Response(user)); }
public static UserResponse Load(Domain.Entities.User user) { if (user == null) { return(null); } List <ClaimResponse> claims = null; if (user.Claims != null) { claims = new List <ClaimResponse>(user.Claims.Count); user.Claims.ForEach((claim) => { claims.Add(ClaimResponse.Load(claim)); }); } return(new UserResponse { Id = user.Id.ToString(), Email = user.Email, IsEmailVerified = user.IsEmailVerified, LastLoginUsingEmail = user.LastLoginUsingEmail, Phone = user.Phone, IsPhoneVerified = user.IsPhoneVerified, LastLoginUsingPhone = user.LastLoginUsingPhone, SignUpDate = user.SignUpDate, FirstName = user.FirstName, LastName = user.LastName, Claims = claims }); }
public CreateCommentRequest(Guid requestId, string content, Domain.Entities.User author, Guid?parentId) { RequestId = requestId; Content = content; Author = author; ParentId = parentId; }
public async Task <PostCreateUserResponse> CreateUserAsync(string email, string password) { var firebaseUser = await _fbService.CreateUserAsync(email, password); if (string.IsNullOrWhiteSpace(firebaseUser.Uid)) { throw new FirebaseUidNotFoundException("Firebase did not return Uid after creating user"); } var user = new Domain.Entities.User { Uid = firebaseUser.Uid }; await _unitOfWork.UserRepository.CreateAsync(user); try { await _unitOfWork.SaveChangesAsync(); } catch (DbUpdateException) { await _fbService.DeleteUserByUidAsync(firebaseUser.Uid); throw new FailedToAddDatabaseResourceException("Failed to create user"); } var resposne = _mapper.Map <PostCreateUserResponse>(user, o => o.AfterMap((source, destination) => { destination.LoginEmail = firebaseUser.Email; })); return(resposne); }
public async Task <UserModel> Handle(GetUserQuery request, CancellationToken cancellationToken) { Domain.Entities.User entity = null; if (request.Id > 0) { entity = await _context.Users.FindAsync(request.Id); } else if (!string.IsNullOrEmpty(request.UserName)) { entity = _context.Users.Where(u => u.UserName == request.UserName).FirstOrDefault(); } if (entity == null) { throw new Exception(); } return(new UserModel { Id = entity.Id, Email = entity.Email, FirstName = entity.FirstName, LastName = entity.LastName, UserName = entity.UserName }); }
public void ShouldGetDetailsForUser() { var sessionManager = new SessionManagerMock(); var aliceSessionMock = sessionManager.AppendPlayerAsSession("Alice"); var playersRepository = new InMemoryUserRepository(); playersRepository.Add(aliceSessionMock.Object.User); var egorPlayer = new Domain.Entities.User("Egor", "123", "111111", true, 13, string.Empty, "Belarus"); egorPlayer.GetType().GetProperty("Id").SetValue(egorPlayer, 5); playersRepository.Add(egorPlayer); var uowFactory = new UnitOfWorkFactoryMock(playersRepository, Mock.Of<IPublicMessageRepository>()); var searchService = new UsersSearchService(uowFactory, Mock.Of<ITransactionFactory>()); var response = searchService.GetUserDetails(aliceSessionMock.Object, new GetUserDetailsRequest { Name = "Egor" }); Assert.AreEqual("Egor", response.User.Name); response = searchService.GetUserDetails(aliceSessionMock.Object, new GetUserDetailsRequest { Name = "Egorko" }); Assert.IsNull(response.User); response = searchService.GetUserDetails(aliceSessionMock.Object, new GetUserDetailsRequest { UserId = 0 }); Assert.IsNull(response.User); response = searchService.GetUserDetails(aliceSessionMock.Object, new GetUserDetailsRequest { UserId = 0 }); Assert.IsNull(response.User); response = searchService.GetUserDetails(aliceSessionMock.Object, new GetUserDetailsRequest { UserId = egorPlayer.Id }); Assert.IsNotNull(response.User); }
public async Task <Domain.Entities.User> GetUserAsync(string nameId, string password) { Domain.Entities.User result = null; try { var queryDefinition = new QueryDefinition("SELECT * FROM User U WHERE U.NameId = @nameId AND U.Password = @password") .WithParameter("@nameId", nameId) .WithParameter("@password", password); var query = _userContainer.GetItemQueryIterator <Domain.Entities.User>(queryDefinition, null, new QueryRequestOptions { PartitionKey = new PartitionKey(nameId) }); while (query.HasMoreResults) { var response = await query.ReadNextAsync(); result = response.FirstOrDefault(); } } catch (CosmosException ex) when(ex.StatusCode == HttpStatusCode.NotFound) { return(null); } return(result); }
public AuthenticateResponse(Domain.Entities.User user, string token) { Id = user.Id; FirstName = user.FirstName; LastName = user.LastName; Username = user.Username; Token = token; }
public UserProfileViewModel(Domain.Entities.User user, IEnumerable <Domain.Entities.Game> games) { UserId = user.Id; Name = user.UserName; Email = user.Email; EmailConfirmed = user.EmailConfirmed; UserGames = games; }
public void Add(Domain.Entities.User user) { using (var entities = new Entities()) { entities.User.Add(Mapper.Map <DataAccess.Model.User>(user)); entities.SaveChanges(); } }
/// <summary> /// Inject (insert directly) user to database. /// </summary> /// <param name="user">User to be injected.</param> /// <returns> /// User with the generated user id. /// </returns> public async Task <Domain.Entities.User> InjectUser(Domain.Entities.User user) { var userEntity = User.Load(user); await Context.Users.InsertOneAsync(userEntity); return(userEntity.MapToDomainEntity()); }
private UserViewModel GetUserVM() { UserViewModel userVM = null; try{ userVM = (UserViewModel)Session["UserVM"]; } catch { }; if (userVM == null) { User user = new Domain.Entities.User(); user.Login = "******"; userVM = new UserViewModel(user); Session["UserVM"] = userVM; } return userVM; }