public void SetSenha(string senha, string confirmarSenha)
{
AssertionConcern.AssertArgumentNotNull(senha, Errors.InvalidUserPassword);
AssertionConcern.AssertArgumentNotNull(confirmarSenha, Errors.InvalidUserPassword);
AssertionConcern.AssertArgumentEquals(senha, confirmarSenha, Errors.PasswordDoesNotMatch);
Senha = PasswordAssertionConcern.Encrypt(senha);
}
public string redefinirSenha()
{
string senha = Guid.NewGuid().ToString().Substring(0, 8);
Senha = PasswordAssertionConcern.Encrypt(senha);
return(senha);
}
public void SetPassword(string password, string confirmPassword)
{
AssertionConcern.AssertArgumentNotNull(password, Errors.InvalidEmail);
AssertionConcern.AssertArgumentNotNull(confirmPassword, Errors.InvalidEmail);
AssertionConcern.AssertArgumentEquals(password, confirmPassword, Errors.PwNotMatch);
this.Password = PasswordAssertionConcern.Encrypt(password);
}
public string resetPassword()
{
string password = new Guid().ToString().Substring(0, 8);
this.Password = PasswordAssertionConcern.Encrypt(password);
return(password);
}
public void SetSenha(string senha, string confirmaSenha)
{
AssertionConcern.AssertArgumentNotNull(senha, Errors.InvalidPassword);
AssertionConcern.AssertArgumentNotNull(confirmaSenha, Errors.InvalidPassword);
AssertionConcern.AssertArgumentLength(senha, 6, 20, Errors.InvalidPassword);
AssertionConcern.AssertArgumentEquals(senha, confirmaSenha, Errors.PasswordDoNotMatch);
this.Senha = PasswordAssertionConcern.Encrypt(senha);
}
public string ResetPassword()
{
string senha = Guid.NewGuid().ToString().Substring(0, 8);
this.Senha = PasswordAssertionConcern.Encrypt(senha);
return(senha);
}
public string ResetPassword()
{
var password = Guid.NewGuid().ToString().Substring(0, 8);
Password = PasswordAssertionConcern.Encrypt(password);
return(password);
}
public string ResetarSenha()
{
string password = Guid.NewGuid().ToString().Substring(0, 8);
this.Senha = PasswordAssertionConcern.Encrypt(password);
return(password);
}
public void SetPassword(string password, string confirmPassword)
{
AssertionConcern.AssertArgumentNotNull(password, Errors.InvalidPassword);
AssertionConcern.AssertArgumentNotNull(confirmPassword, Errors.InvalidPasswordConfirmation);
AssertionConcern.AssertArgumentEquals(password, confirmPassword, Errors.PasswordNotMatch);
AssertionConcern.AssertArgumentLength(password, 6, 20, Errors.InvalidPassword);
this.Password = PasswordAssertionConcern.Encrypt(password);
}
public void AlterarSenha(Usuario usuario)
{
AssertionConcern.AssertArgumentNotEmpty(usuario.UsuarioNome, Erros.InvalidUserName);
var usuarioAtual = _usuarioRepository.ObterComPermissoesPorUsuarioNome(usuario.UsuarioNome);
usuarioAtual.Senha = PasswordAssertionConcern.Encrypt(usuario.Senha);
usuarioAtual.Validar();
_usuarioRepository.Atualizar(usuarioAtual);
}
public void SetarSenha(string senha, string confirmarSenha)
{
AssertionConcern.AssertArgumentNotNull(senha, "Senha Inválida");
AssertionConcern.AssertArgumentNotNull(confirmarSenha, "Senha de confirmação inválida");
AssertionConcern.AssertArgumentEquals(senha, confirmarSenha, "Senhas não coincidem");
AssertionConcern.AssertArgumentLength(senha, 3, 12, "Senha inválida");
this.Senha = PasswordAssertionConcern.Encrypt(senha);
}
public void setPassword(string password, string confirmPassword)
{
AssertionConcern.AssertArgumentNotNull(password, Errors.InvalidUserPassword);
AssertionConcern.AssertArgumentNotNull(confirmPassword, Errors.InvalidUserPassword);
AssertionConcern.AssertArgumentEquals(password, confirmPassword, Errors.InvalidUserPassword);
AssertionConcern.AssertArgumentLength(password, 6, 10, Errors.InvalidUserPassword);
this.Password = PasswordAssertionConcern.Encrypt(password);
}
public void InsertPassword(string password, string confirmPassword)
{
AssertionConcern.AssertArgumentNotNullOrEmpty(password, "Senha vazia");
AssertionConcern.AssertArgumentNotNullOrEmpty(confirmPassword, "Confirmação de senha vazia");
AssertionConcern.AssertArgumentEquals(password, confirmPassword, "Senhas são diferentes");
AssertionConcern.AssertArgumentLength(password, 6, 20, "Tamanho da senha inválida");
this.Password = PasswordAssertionConcern.Encrypt(password);;
}
public Usuario AutenticarUsuario(string usuarioNome, string senha)
{
var usuario = _usuarioRepository.ObterPorUsuarioNome(usuarioNome);
if (usuario == null || !PasswordAssertionConcern.Encrypt(senha).Equals(usuario.Senha))
{
return(null);
}
return(usuario);
}
public User Authenticate(string email, string password)
{
var user = GetByEmail(email);
if (user.Password != PasswordAssertionConcern.Encrypt(password))
{
throw new Exception(Errors.InvalidCredentials);
}
return(user);
}
public async Task <UserModel> LoginAsync(string email, string password)
{
var user = await GetSingleAsync(x => x.Email.Equals(email));
if (user == null || user.Password != PasswordAssertionConcern.Encrypt(password))
{
throw new Exception(string.Format(Language.InvalidF, Language.Credentials));
}
return(user);
}
public Contact Authenticate(string email, string password)
{
var contact = GetByEmail(email);
if (contact.Password != PasswordAssertionConcern.Encrypt(password))
{
throw new Exception("Errors.InvalidCredentials");
}
return(contact);
}
public Usuario Autenticar(string email, string senha)
{
var user = this.Obter(email);
if (user.Senha != PasswordAssertionConcern.Encrypt(senha))
{
throw new Exception("Senha inválida");
}
return(user);
}
public Player Authenticate(string email, string password)
{
var player = _repository.Get(email);
if (player.Password != PasswordAssertionConcern.Encrypt(password))
{
throw new Exception(ErrorMessages.InvalidCredentials);
}
return(player);
}
public async Task <Usuario> Authenticantion(string email, string senha)
{
using (var loja = new LojaContext())
{
loja.Configuration.AutoDetectChangesEnabled = false;
senha = PasswordAssertionConcern.Encrypt(senha);
return(await loja.Set <Usuario>()
.Where(
user =>
user.Ativo == true && user.Email == email &&
user.Senha == senha)
.Include(usuario => usuario.UsuarioPerfil)
.Include(usuario => usuario.Empresa).FirstOrDefaultAsync());
}
}
public void EditarUsuario(Usuario usuario)
{
var usuarioAtual = _usuarioRepository.ObterPorCodigoComPermissoesEGrupo(usuario.UsuarioCodigo);
AssertionConcern.AssertArgumentNotNull(usuarioAtual, Erros.UserDoesNotExist);
if (usuarioAtual.GrupoPermissao.GrupoPermissaoCodigo != usuario.GrupoPermissao.GrupoPermissaoCodigo)
{
var novoGrupo =
_grupoPermissaoRepository.ObterPorCodigoComPermissoes(usuario.GrupoPermissao.GrupoPermissaoCodigo);
AssertionConcern.AssertArgumentNotNull(novoGrupo, Erros.GroupDoesNotExist);
usuarioAtual.GrupoPermissao = novoGrupo;
}
usuarioAtual.Ativo = usuario.Ativo;
usuarioAtual.UsuarioNome = usuario.UsuarioNome;
if (!string.IsNullOrEmpty(usuario.Senha))
{
usuarioAtual.Senha = PasswordAssertionConcern.Encrypt(usuario.Senha);
}
_usuarioRepository.Atualizar(usuarioAtual);
}
public void Registrar(string nome, string senha, string confimaSenha, int codigoGrupo)
{
AssertionConcern.AssertArgumentNotEmpty(nome, Erros.InvalidUserName);
var temUsuario = _usuarioRepository.ObterPorUsuarioNome(nome.ToLower());
if (temUsuario != null)
{
throw new Exception(Erros.DuplicateUserName);
}
;
var temGrupo = _grupoPermissaoRepository.ObterPorCodigoComPermissoes(codigoGrupo);
AssertionConcern.AssertArgumentNotEquals(temGrupo, null, Erros.GroupDoesNotExist);
var usuario = new Usuario()
{
UsuarioNome = nome.ToLower(),
Senha = PasswordAssertionConcern.Encrypt(senha),
Ativo = true,
GrupoPermissao = temGrupo
};
usuario.Validar();
_usuarioRepository.Criar(usuario);
}
public void ValidateAutentication()
{
EmailAssertionConcern.AssertIsValid(this.Email);
PasswordAssertionConcern.AssertIsValid(this.Password);
this.Password = PasswordAssertionConcern.Encrypt(this.Password);
}
protected override void Seed(HungryUp.Infrastructure.Data.AppDataContext context)
{
context.Restaurants.AddOrUpdate(p => p.Name,
new Restaurant("Camobi Churrascaria")
{
RestaurantId = 1
}
, new Restaurant("Camoburguer")
{
RestaurantId = 2
}
, new Restaurant("Nélia Lanches")
{
RestaurantId = 3
}
, new Restaurant("Due Frateli")
{
RestaurantId = 4
}
, new Restaurant("Via Fornale")
{
RestaurantId = 5
}
, new Restaurant("Floriano Lanches")
{
RestaurantId = 6
}
, new Restaurant("Piu Piu Lanches")
{
RestaurantId = 7
}
, new Restaurant("Porto Belo")
{
RestaurantId = 8
}
, new Restaurant("Hellios")
{
RestaurantId = 9
}
, new Restaurant("Etnias")
{
RestaurantId = 10
}
, new Restaurant("Dariu Lanches")
{
RestaurantId = 11
}
);
context.Users.AddOrUpdate(p => p.Name,
new User("DbServer Test", "*****@*****.**", PasswordAssertionConcern.Encrypt("dbserver_teste"))
{
UserId = 1
},
new User("Daniel", "*****@*****.**", PasswordAssertionConcern.Encrypt("ruafbf"))
{
UserId = 2
},
new User("Felipe", "*****@*****.**", PasswordAssertionConcern.Encrypt("ruafbf"))
{
UserId = 3
},
new User("Igor", "*****@*****.**", PasswordAssertionConcern.Encrypt("ruafbf"))
{
UserId = 4
},
new User("Boscaini", "*****@*****.**", PasswordAssertionConcern.Encrypt("ruafbf"))
{
UserId = 5
},
new User("Elzon", "*****@*****.**", PasswordAssertionConcern.Encrypt("ruafbf"))
{
UserId = 6
});
}
protected override void Seed(DataBase.DataBaseContext context)
{
//Atualização inicial estados
context.Estados.AddOrUpdate(
e => e.EstadoNome,
new Estado {
EstadoNome = "Acre"
},
new Estado {
EstadoNome = "Alagoas"
},
new Estado {
EstadoNome = "Amapá"
},
new Estado {
EstadoNome = "Amazonas"
},
new Estado {
EstadoNome = "Bahia"
},
new Estado {
EstadoNome = "Ceará"
},
new Estado {
EstadoNome = "Distrito Federal"
},
new Estado {
EstadoNome = "Espírito Santo"
},
new Estado {
EstadoNome = "Goiás"
},
new Estado {
EstadoNome = "Maranhão"
},
new Estado {
EstadoNome = "Mato Grosso"
},
new Estado {
EstadoNome = "Mato Grosso do Sul"
},
new Estado {
EstadoNome = "Minas Gerais"
},
new Estado {
EstadoNome = "Pará"
},
new Estado {
EstadoNome = "Paraíba"
},
new Estado {
EstadoNome = "Paraná"
},
new Estado {
EstadoNome = "Pernambuco"
},
new Estado {
EstadoNome = "Piauí"
},
new Estado {
EstadoNome = "Rio de Janeiro"
},
new Estado {
EstadoNome = "Rio Grande do Norte"
},
new Estado {
EstadoNome = "Rio Grande do Sul"
},
new Estado {
EstadoNome = "Rondônia"
},
new Estado {
EstadoNome = "Roraima"
},
new Estado {
EstadoNome = "Santa Catarina"
},
new Estado {
EstadoNome = "São Paulo"
},
new Estado {
EstadoNome = "Sergipe"
},
new Estado {
EstadoNome = "Tocantins"
});
//Atualização inicial estado civil
context.EstadosCivis.AddOrUpdate(
ec => ec.EstadoCivilNome,
new EstadoCivil {
EstadoCivilNome = "Solteiro(a)"
},
new EstadoCivil {
EstadoCivilNome = "Casado(a)"
},
new EstadoCivil {
EstadoCivilNome = "Divorciado(a)"
},
new EstadoCivil {
EstadoCivilNome = "Viúvo(a)"
},
new EstadoCivil {
EstadoCivilNome = "Separado(a)"
});
//Atualização inicial papel
context.Papeis.AddOrUpdate(
p => p.PapelNome,
new Papel {
PapelNome = "Pessoa Fisica"
},
new Papel {
PapelNome = "Pessoa Juridica"
},
new Papel {
PapelNome = "Funcionario"
},
new Papel {
PapelNome = "Cliente"
},
new Papel {
PapelNome = "Fornecedor"
});
//Atualização inicial unidades
context.Unidades.AddOrUpdate(u => u.UnidadeNome,
new Unidade {
UnidadeNome = "KG – Quilograma"
},
new Unidade {
UnidadeNome = "LT – Litro"
},
new Unidade {
UnidadeNome = "UN – Unidade"
},
new Unidade {
UnidadeNome = "MT – Metro linear"
},
new Unidade {
UnidadeNome = "M2 – Metro quadrado"
},
new Unidade {
UnidadeNome = "M3 – Metro cúbico"
});
//Atualização inicial Usuario
context.Usuarios.AddOrUpdate(
u => u.UsuarioNome,
new Usuario
{
UsuarioNome = "Admin",
Senha = PasswordAssertionConcern.Encrypt("admin"),
Ativo = true,
GrupoPermissao = new GrupoPermissao
{
GrupoPermissaoNome = "TOTAL",
Permissoes = new List <Permissao>
{
new Permissao
{
PermissaoNome = "Pesquisa Compra",
AcaoNome = "PesquisaCompra"
},
new Permissao
{
PermissaoNome = "Nova Compra",
AcaoNome = "NovaCompra"
},
new Permissao
{
PermissaoNome = "Editar Compra",
AcaoNome = "EditarCompra"
},
new Permissao
{
PermissaoNome = "Excluir Compra",
AcaoNome = "ExcluirCompra"
},
new Permissao
{
PermissaoNome = "Pesquisa Condicao Pagamento",
AcaoNome = "PesquisaCondicaoPagamento"
},
new Permissao
{
PermissaoNome = "Nova Condicao Pagamento",
AcaoNome = "NovaCondicaoPagamento"
},
new Permissao
{
PermissaoNome = "Editar Condicao Pagamento",
AcaoNome = "EditarCondicaoPagamento"
},
new Permissao
{
PermissaoNome = "Excluir Condicao Pagamento",
AcaoNome = "ExcluirCondicaoPagamento"
},
new Permissao
{
PermissaoNome = "Pesquisa Conta Pagar",
AcaoNome = "PesquisaContaPagar"
},
new Permissao
{
PermissaoNome = "Pesquisa Conta Receber",
AcaoNome = "PesquisaContaReceber"
},
new Permissao
{
PermissaoNome = "Pesquisa Forma Pagamento",
AcaoNome = "PesquisaFormaPagamento"
},
new Permissao
{
PermissaoNome = "Nova Forma Pagamento",
AcaoNome = "NovaFormaPagamento"
},
new Permissao
{
PermissaoNome = "Editar Forma Pagamento",
AcaoNome = "EditarFormaPagamento"
},
new Permissao
{
PermissaoNome = "Excluir Forma Pagamento",
AcaoNome = "ExcluirFormaPagamento"
},
new Permissao
{
PermissaoNome = "Pesquisa Cliente",
AcaoNome = "PesquisaCliente"
},
new Permissao
{
PermissaoNome = "Novo Cliente",
AcaoNome = "NovoCliente"
},
new Permissao
{
PermissaoNome = "Editar Cliente",
AcaoNome = "EditarCliente"
},
new Permissao
{
PermissaoNome = "Excluir Cliente",
AcaoNome = "ExcluirCliente"
},
new Permissao
{
PermissaoNome = "Pesquisa Fornecedor",
AcaoNome = "PesquisaFornecedor"
},
new Permissao
{
PermissaoNome = "Novo Fornecedor",
AcaoNome = "NovoFornecedor"
},
new Permissao
{
PermissaoNome = "Editar Fornecedor",
AcaoNome = "EditarFornecedor"
},
new Permissao
{
PermissaoNome = "Excluir Fornecedor",
AcaoNome = "ExcluirFornecedor"
},
new Permissao
{
PermissaoNome = "Pesquisa Funcionario",
AcaoNome = "PesquisaFuncionario"
},
new Permissao
{
PermissaoNome = "Novo Funcionario",
AcaoNome = "NovoFuncionario"
},
new Permissao
{
PermissaoNome = "Editar Funcionario",
AcaoNome = "EditarFuncionario"
},
new Permissao
{
PermissaoNome = "Excluir Funcionario",
AcaoNome = "ExcluirFuncionario"
},
new Permissao
{
PermissaoNome = "Pesquisa Produto",
AcaoNome = "PesquisaProduto"
},
new Permissao
{
PermissaoNome = "Novo Produto",
AcaoNome = "NovoProduto"
},
new Permissao
{
PermissaoNome = "Editar Produto",
AcaoNome = "EditarProduto"
},
new Permissao
{
PermissaoNome = "Excluir Produto",
AcaoNome = "ExcluirProduto"
},
new Permissao
{
PermissaoNome = "Pesquisa Grupo",
AcaoNome = "PesquisaGrupo"
},
new Permissao
{
PermissaoNome = "Novo Grupo",
AcaoNome = "NovoGrupo"
},
new Permissao
{
PermissaoNome = "Editar Grupo",
AcaoNome = "EditarGrupo"
},
new Permissao
{
PermissaoNome = "Excluir Grupo",
AcaoNome = "ExcluirGrupo"
},
new Permissao
{
PermissaoNome = "Configuracao Usuario",
AcaoNome = "ConfiguracaoUsuario"
},
new Permissao
{
PermissaoNome = "Pesquisa Usuario",
AcaoNome = "PesquisaUsuario"
},
new Permissao
{
PermissaoNome = "Novo Usuario",
AcaoNome = "NovoUsuario"
},
new Permissao
{
PermissaoNome = "Editar Usuario",
AcaoNome = "EditarUsuario"
},
new Permissao
{
PermissaoNome = "Excluir Usuario",
AcaoNome = "ExcluirUsuario"
},
new Permissao
{
PermissaoNome = "Alterar Senha",
AcaoNome = "AlterarSenha"
},
new Permissao
{
PermissaoNome = "Pesquisa Venda",
AcaoNome = "PesquisaVenda"
},
new Permissao
{
PermissaoNome = "Nova Venda",
AcaoNome = "NovaVenda"
},
new Permissao
{
PermissaoNome = "Editar Venda",
AcaoNome = "EditarVenda"
},
new Permissao
{
PermissaoNome = "Excluir Venda",
AcaoNome = "ExcluirVenda"
}
}
}
});
}
public string SetSenha(string senha)
{
AssertionConcern.AssertArgumentNotNull(senha, Errors.InvalidUserPassword);
return(PasswordAssertionConcern.Encrypt(senha));
}
public void definirSenha(string senha, string confirmarSenha)
{
Senha = senha;
UsuarioScopes.definirSenhaUsuarioEhValido(this, confirmarSenha);
Senha = PasswordAssertionConcern.Encrypt(senha);
}
protected override void Seed(GameEndpoints.Infrastructure.Data.AppDataContext context)
{
context.Players.AddOrUpdate(
p => p.PlayerName,
new Player {
PlayerId = 1, PlayerName = "Guns and Roses", Email = "*****@*****.**", Password = PasswordAssertionConcern.Encrypt("girlsarepretty")
},
new Player {
PlayerId = 2, PlayerName = "Foo Fighters", Email = "*****@*****.**", Password = PasswordAssertionConcern.Encrypt("imanewdayrising")
},
new Player {
PlayerId = 3, PlayerName = "AC/DC", Email = "*****@*****.**", Password = PasswordAssertionConcern.Encrypt("pullthetrigger")
},
new Player {
PlayerId = 4, PlayerName = "Iron Maiden", Email = "*****@*****.**", Password = PasswordAssertionConcern.Encrypt("runforyourlives")
},
new Player {
PlayerId = 5, PlayerName = "Raul Seixas", Email = "*****@*****.**", Password = PasswordAssertionConcern.Encrypt("ambulante")
}
);
context.Games.AddOrUpdate(
p => p.GameName,
new Game {
GameId = 1, GameName = "Appetite for Destruction"
},
new Game {
GameId = 2, GameName = "In Your Honor"
},
new Game {
GameId = 3, GameName = "Back in Black"
},
new Game {
GameId = 4, GameName = "The Number of the Beast"
},
new Game {
GameId = 5, GameName = "Krig-ha, Bandolo!"
}
);
base.Seed(context);
}
