public async Task <IActionResult> GravaArquivo(int id, string file)
{
var usuario = new UsuarioModel()
{
LoginUser = "******", Email = "*****@*****.**"
};
var senha = Uteis.GeraSenha();
//checando existência de usuário
var _userExistent = await _userManager.FindByNameAsync(usuario.LoginUser);
if (_userExistent != null)
{
throw new Exception($"usuário {usuario.LoginUser} já existente");
}
//montagem do usuário
var user = new IdentityUser {
UserName = usuario.LoginUser, Email = usuario.Email, LockoutEnabled = true,
};
var usuarioid = 2;
//criando o usuário
var criacaoUser = await _userManager.CreateAsync(user, Uteis.GeraSenha());
if (criacaoUser.Succeeded)
{
user = await _userManager.FindByNameAsync(usuario.LoginUser);
//adicionando as claims
var _resultClaim = await _userManager.AddClaimsAsync(user, new List <Claim> {
new Claim(JwtClaimTypes.Email, user.Email),
new Claim(ClaimTypes.Role, "Usuario"),
new Claim("clienteid", "1"),
new Claim("usuarioid", usuarioid.ToString())
});
//adicionando o usuário a role
await _userManager.AddToRoleAsync(user, "Usuario");
}
return(Ok(new LoginViewModel()
{
Username = "******", Password = "******"
}));
}
public async Task <IActionResult> AdicionaItemAsync([FromBody] IEnumerable <FornecedorModel> t)
{
IActionResult res = null;
var b = new BaseEntityDTO <FornecedorModel>()
{
Start = DateTime.Now, Itens = t.Count()
};
try
{
var f = t.ElementAt(0);
foreach (var item in f.Contatos)
{
if (!string.IsNullOrEmpty(item.Email))
{
if (!Util.RegexEmail.IsMatch(item.Email))
{
throw new Exception($"Email {item.Email} com formato inválido");
}
if (_userManager.FindByEmailAsync(item.Email).GetAwaiter().GetResult() != null)
{
throw new Exception($"Email {item.Email} já existente no sistema");
}
}
}
if (f.CPFCNPJ.Length == 11)
{
if (!Util.ValidarCPF(f.CPFCNPJ))
{
throw new Exception($"Erro no CPF {f.CPFCNPJ} informado");
}
}
else if (f.CPFCNPJ.Length == 14)
{
if (!Util.ValidaCnpj(f.CPFCNPJ))
{
throw new Exception($"Erro no CNPJ {f.CPFCNPJ} informado");
}
}
//checando existência de usuário
var _userExistent = await _userManager.FindByNameAsync(f.CPFCNPJ);
if (_userExistent != null)
{
throw new Exception($"usuário com login: {f.CPFCNPJ} já existente");
}
var senha = Uteis.GeraSenha();
//montagem do usuário
var user = new IdentityUser {
UserName = f.CPFCNPJ, Email = f.Contatos.ElementAt(0).Email, LockoutEnabled = true, EmailConfirmed = true
};
var fornecedorid = await new FornecedorRepository().AddItem(f, 0, null);
//criando o usuário
var criacaoUser = await _userManager.CreateAsync(user, senha);
if (criacaoUser.Succeeded)
{
user = await _userManager.FindByNameAsync(f.CPFCNPJ);
//adicionando as claims
var _resultClaim = await _userManager.AddClaimsAsync(user, new List <Claim> {
new Claim(JwtClaimTypes.Email, user.Email),
new Claim(ClaimTypes.Role, "Fornecedor"),
new Claim("fornecedorid", fornecedorid.ToString())
});
//adicionando o usuário a role
await _userManager.AddToRoleAsync(user, "Fornecedor");
await Util.SendEmailAsync(new EmailViewModel[] { new EmailViewModel(user.Email) }, "Novo Cadastro Moneo", Emails.NovoCadastro(), true, TipoEmail.NOVOCADASTRO);
b.End = DateTime.Now;
res = Ok(b);
}
}
catch (Exception err)
{
b.End = DateTime.Now;
b.Error = (err.InnerException ?? err).Message;
res = BadRequest(b);
}
return(res);
}
public async Task <IActionResult> ResetPassword([FromBody] LoginViewModel l)
{
IActionResult res = null;
var _b = new BaseEntityDTO <string>()
{
Start = DateTime.Now
};
try
{
var existUser = await _userManager.FindByEmailAsync(l.Email);
if (existUser == null)
{
throw new Exception($"{l.Email} não encontrado");
}
if (!existUser.LockoutEnabled)
{
throw new Exception("Usuário inativo no sistema");
}
l.Username = existUser.UserName;
//existUser.Email = "*****@*****.**";
//tokenResponse.AccessToken
string senha = Uteis.GeraSenha();
var guid = Guid.NewGuid().ToString();
await repository.Add(new UsersResetPasswordModel[] { new UsersResetPasswordModel()
{
Token = guid,
SenhaTrocada = false,
LoginUser = l.Username
} }, ClienteID, UsuarioID);
// existUser.Email = "*****@*****.**";
await Util.SendEmailAsync(
new EmailViewModel[] { new EmailViewModel(existUser.Email) },
"Senha zerada",
Emails.RedefinicaoSenha($"{Util.Configuration["UrlIdentity"]}redefine-senha/{guid}"),
true,
TipoEmail.RESETSENHA);
_b.Result = $"Email encaminhado pra {l.Email} com o link pra reset da senha";
_b.End = DateTime.Now;
_b.Itens = 1;
res = Ok(_b);
}
catch (Exception err)
{
_b.End = DateTime.Now;
_b.Error = (err.InnerException ?? err).Message;
res = BadRequest(_b);
}
return(res);
}
public async Task <IActionResult> TokenAuthentication([FromBody] LoginViewModel m)
{
IActionResult res = null;
var _b = new BaseEntityDTO <LoginViewModel>()
{
Start = DateTime.Now, Itens = 1
};
try
{
var _urp = new UsersResetPasswordModel()
{
Token = m.Token
};
var t = await new UsersResetPasswordRepository().FindById(_urp, null);
if (t == null)
{
throw new Exception($"Link expirado para redefinição de senha");
}
var existUser = await _userManager.FindByNameAsync(t.LoginUser);
if (existUser == null)
{
throw new Exception($"Usuário não encontrado");
}
string tokenPassword = await _userManager.GeneratePasswordResetTokenAsync(existUser);
await _userManager.ResetAccessFailedCountAsync(existUser);
string senha = Uteis.GeraSenha();
var result = await _userManager.ResetPasswordAsync(existUser, tokenPassword, senha);
if (!result.Succeeded)
{
throw new Exception("Houve um erro ao tentar zerar a senha");
}
result = await _userManager.ChangePasswordAsync(existUser, senha, m.Password);
if (!result.Succeeded)
{
throw new Exception(result.Errors.Select(a => a.Description).Aggregate((n, o) => $"Ocorreram os seguintes erros: {n},{o}"));
}
await repository.Update(new UsersResetPasswordModel[] { new UsersResetPasswordModel()
{
Token = m.Token,
SenhaTrocada = true,
LoginUser = t.LoginUser
} }, 0, null);
m.Username = existUser.UserName;
_b.Result = await AutenticaLogin(m, existUser);
_b.End = DateTime.Now;
_b.Itens = 1;
res = Ok(_b);
}
catch (Exception err)
{
_b.End = DateTime.Now;
_b.Error = (err.InnerException ?? err).Message;
res = BadRequest(_b);
}
return(res);
}
public async Task <IActionResult> GravaAvulso()
{
try
{
ContatoModel[] contato = { new ContatoModel()
{
Celular = 71981273460, Email = "*****@*****.**"
} };
var cliente = new ClienteModel()
{
Contatos = contato, CNPJ = "07459196000126"
};
if (string.IsNullOrEmpty(cliente.Contatos.ElementAt(0).Email))
{
throw new Exception($"Cliente sem e-mail informado pra cadastro");
}
var senha = Uteis.GeraSenha();
//checando existência de usuário
var _userExistent = await _userManager.FindByNameAsync(cliente.CNPJ);
if (_userExistent != null)
{
throw new Exception($"usuário {cliente.CNPJ} já existente");
}
//montagem do usuário
var user = new IdentityUser {
UserName = cliente.CNPJ, Email = cliente.Contatos.ElementAt(0).Email, LockoutEnabled = true, EmailConfirmed = true
};
var clienteid = 1;
//criando o usuário
var criacaoUser = await _userManager.CreateAsync(user, Uteis.GeraSenha());
if (criacaoUser.Succeeded)
{
user = await _userManager.FindByNameAsync(cliente.CNPJ);
//adicionando as claims
var _resultClaim = await _userManager.AddClaimsAsync(user, new List <Claim> {
new Claim(JwtClaimTypes.Email, user.Email),
new Claim(ClaimTypes.Role, "Cliente"),
new Claim("clienteid", clienteid.ToString())
});
//adicionando o usuário a role
await _userManager.AddToRoleAsync(user, "Cliente");
}
else
{
throw new Exception(criacaoUser.Errors.Select(a => a.Description).Aggregate((n, o) => $"Ocorreram os seguintes erros: {n},{o}"));
}
}
catch (Exception err)
{
throw err;
}
return(Ok());
}
public async Task <IActionResult> AdicionaItemAsync([FromBody] IEnumerable <ClienteModel> t)
{
IActionResult res = null;
var b = new BaseEntityDTO <string>()
{
Start = DateTime.Now, Itens = t.Count()
};
var cliente = t.ElementAt(0);
try
{
if (cliente.Contatos == null || !cliente.Contatos.Any())
{
if (Util.RegexEmail.IsMatch(cliente.Email))
{
cliente.Contatos = new ContatoModel[] { new ContatoModel()
{
Celular = cliente.Telefone, Email = cliente.Email
} }
}
;
else
{
throw new Exception("E-mail inválido");
}
}
if (!Util.ValidaCnpj(cliente.CNPJ))
{
throw new Exception("CNPJ inválido");
}
foreach (var item in cliente.Contatos)
{
if (!string.IsNullOrEmpty(item.Email))
{
if (!Util.RegexEmail.IsMatch(item.Email))
{
throw new Exception($"Email {item.Email} com formato inváldo");
}
if (_userManager.FindByEmailAsync(item.Email).GetAwaiter().GetResult() != null)
{
throw new Exception($"Email {item.Email} já existente no sistema");
}
}
}
var senha = Uteis.GeraSenha();
//checando existência de usuário
var _userExistent = await _userManager.FindByNameAsync(cliente.CNPJ);
if (_userExistent != null)
{
throw new Exception($"usuário com login: {cliente.CNPJ} já existente");
}
//montagem do usuário
var user = new IdentityUser {
UserName = cliente.CNPJ, Email = cliente.Contatos.Where(a => !string.IsNullOrEmpty(a.Email)).ElementAt(0).Email, LockoutEnabled = true, EmailConfirmed = true
};
cliente.ClienteID = await new ClienteRepository().AddCliente(t);
//criando o usuário
var criacaoUser = await _userManager.CreateAsync(user, Uteis.GeraSenha());
if (criacaoUser.Succeeded)
{
user = await _userManager.FindByNameAsync(cliente.CNPJ);
var claims = new List <Claim> {
new Claim(JwtClaimTypes.Email, user.Email),
new Claim(ClaimTypes.Role, "Cliente"),
new Claim("clienteid", cliente.ClienteID.ToString())
};
//adicionando as claims
var _resultClaim = await _userManager.AddClaimsAsync(user, claims);
//adicionando o usuário a role
await _userManager.AddToRoleAsync(user, "Cliente");
await Util.SendEmailAsync(new EmailViewModel[] { new EmailViewModel(user.Email) }, "Novo Cadastro Moneo", Emails.NovoCadastro(), true, TipoEmail.NOVOCADASTRO);
}
else
{
//DuplicateEmail
if (criacaoUser.Errors.Contains(new IdentityError()
{
Code = "DuplicateEmail"
}))
{
throw new Exception($"E-mail {user.Email} já existente no sistema");
}
throw new Exception(criacaoUser.Errors.Select(a => a.Description).Aggregate((n, o) => $"Ocorreram os seguintes erros: {n},{o}"));
}
b.Result = $"Cliente cadastrado com sucesso. Senha gerada: {senha}";
b.End = DateTime.Now;
res = Ok(b);
}
catch (Exception err)
{
b.End = DateTime.Now;
b.Error = (err.InnerException ?? err).Message;
if (b.Error.Contains("IX_EMAIL_CLIENTES_EMAIL_UNIQUE"))
{
b.Error = "Um ou mais e-mails informados, já existente no sistema";
}
if (b.Error.Contains("IX_CLIENTES"))
{
b.Error = $"Cliente com o CNPJ: {t.ElementAt(0).CNPJ} já existente na base";
}
//await new ClienteRepository().Remove(new ClienteModel[] { new ClienteModel() { ClienteID = cliente.ClienteID } }, 0, null);
res = BadRequest(b);
}
return(res);
}
public async Task <IActionResult> AdicionaItemAsync([FromBody] IEnumerable <UsuarioModel> t)
{
IActionResult res = null;
var b = new BaseEntityDTO <string>()
{
Start = DateTime.Now, Itens = t.Count()
};
int usuarioid = 0;
try
{
var usuario = t.ElementAt(0);
var validator = new UsuarioModelValidator();
var result = await validator.ValidateAsync(t.ElementAt(0));
if (!result.IsValid)
{
throw new Exception(result.Errors.Select(a => a.ErrorMessage).Aggregate((a, k) => $"{a},{k}"));
}
if (!Util.RegexEmail.IsMatch(usuario.Email))
{
throw new Exception("Email inválido");
}
var senha = Uteis.GeraSenha();
//checando existência de usuário
var _userExistent = await _userManager.FindByNameAsync(usuario.LoginUser);
if (_userExistent != null)
{
//await _userManager.DeleteAsync(_userExistent);
throw new Exception($"usuário {usuario.LoginUser} já existente");
}
_userExistent = await _userManager.FindByEmailAsync(usuario.Email);
if (_userExistent != null)
{
throw new Exception($"usuário com e-mail {usuario.Email} já cadastrado no sistema");
}
//montagem do usuário
var user = new IdentityUser {
UserName = usuario.LoginUser, Email = usuario.Email, LockoutEnabled = true, PhoneNumber = usuario.Telefone.ToString(), EmailConfirmed = true
};
usuarioid = await new UsuarioRepository().Add(usuario, ClienteID, UsuarioID);
//criando o usuário
var criacaoUser = await _userManager.CreateAsync(user, Uteis.GeraSenha());
if (criacaoUser.Succeeded)
{
user = await _userManager.FindByNameAsync(usuario.LoginUser);
await _userManager.AddClaimsAsync(user, new List <Claim> {
new Claim(JwtClaimTypes.Email, user.Email),
new Claim(ClaimTypes.Role, "Usuario"),
new Claim(ClaimTypes.GroupSid, usuario.GrupoUsuario.GrupoUsuarioID.ToString()),
new Claim("clienteid", ClienteID.ToString()),
new Claim("usuarioid", usuarioid.ToString())
});
//adicionando o usuário a role
await _userManager.AddToRoleAsync(user, "Usuario");
var guid = Guid.NewGuid().ToString();
await _usersPasswordRepo.Add(new UsersResetPasswordModel[] { new UsersResetPasswordModel()
{
Token = guid,
SenhaTrocada = false,
LoginUser = usuario.LoginUser
} }, ClienteID, UsuarioID);
//encaminhando um e-mail ao usuário após o cadastro
await Util.SendEmailAsync(
new EmailViewModel[] { new EmailViewModel(user.Email, usuario.Nome) },
"Novo Usuário Moneo",
Emails.NovoUsuario(usuario.LoginUser, $"{Util.Configuration["UrlIdentity"]}redefine-senha/{guid}"),
true,
TipoEmail.NOVOCADASTRO);
}
else
{
throw new Exception(criacaoUser.Errors.Select(a => a.Description).Aggregate((n, o) => $"Ocorreram os seguintes erros: {n},{o}"));
}
b.Result = $"usuário {user.UserName} gravado com sucesso";
b.End = DateTime.Now;
res = Ok(b);
}
catch (Exception err)
{
if (usuarioid > 0)
{
await new UsuarioRepository().ExcluirItensAsyncAfected(new UsuarioModel[] { new UsuarioModel()
{
UsuarioID = usuarioid
} }, ClienteID, UsuarioID).ContinueWith(async(k) =>
{
if (!k.IsFaulted)
{
if (k.Result > 0)
{
var _user = await _userManager.FindByNameAsync(t.ElementAt(0).LoginUser);
if (_user != null)
{
await _userManager.DeleteAsync(_user);
}
}
}
});
}
b.End = DateTime.Now;
b.Error = (err.InnerException ?? err).Message;
if (b.Error.Contains("CK_GRUPOUSUARIOS_SALDO"))
{
b.Error = "Valor da cota maior do que a permitida pelo grupo";
}
res = BadRequest(b);
}
return(res);
}
