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;
}
