public async Task <ActionResult> Registrar(ContaRegistrarViewModel modelo)
{
if (ModelState.IsValid)
{
var novoUsuario = new UsuarioAplicacao();
novoUsuario.Email = modelo.Email;
novoUsuario.UserName = modelo.UserName;
novoUsuario.NomeCompleto = modelo.NomeCompleto;
var user = await UserManager.FindByEmailAsync(modelo.Email);
if (user != null)
{
Console.WriteLine($"E-mail {modelo.Email} já cadastrado. Enviando usuário para tela inicial.");
return(View("AguardandoConfirmacao"));
}
var result = await UserManager.CreateAsync(novoUsuario, modelo.Senha);
if (result.Succeeded)
{
await EnviarEmailDeConfirmacao(novoUsuario);
return(View("AguardandoConfirmacao"));
}
else
{
AdicionaErros(result.Errors);
}
}
return(View(modelo));
}
private Usuario ValidarUsuario(Usuario usuario)
{
try
{
if (usuario == null)
{
return(null);
}
else
{
var resposta = new UsuarioAplicacao(_contexto).getUsuario(usuario.Login);
if (resposta != null)
{
if (resposta.Senha == usuario.Senha)
{
return(resposta);
}
else
{
return(null);
}
}
else
{
return(null);
}
}
}
catch (Exception)
{
return(null);
}
}
public ActionResult Login(TB_USUARIO tabela)
{
// - aqui vai pesquisar o login é senha
try
{
var tbuscar = new UsuarioAplicacao();
var validadados = new ValidaCaracter();
var retorno = tbuscar.ListarPorLoginSenha(validadados.ValidaDados(tabela.LoginUsuario), validadados.ValidaDados(tabela.SenhaUsuario));
if (retorno != null)
{
Session["idusuario"] = retorno.IdUsuario;
Session["NomeUsuario"] = retorno.NomeUsuario;
Session["Administrador"] = retorno.UsuarioAdmin;
Session["EmailUsuario"] = retorno.EmailUsuario;
//redireciona para o painel de controle
return(RedirectToAction("index", "PaginaInicial"));
//exemplo return RedirectToAction("Index", "Home", new { id = @Session["idpossibilidadde"] });
}
else
{
TempData["erro"] = "...Ops.. acredito que você tenha errado a senha/login, tente novamente, ou use a opção recuperar a sua senha!";
}
}
catch (Exception ex)
{
TempData["erro"] = ex.ToString(); // "...Ops.. acredito que você tenha errado a senha/login, tente novamente, ou use a opção recuperar a sua senha!";
}
ModelState.Clear();
return(RedirectToAction("index", "Home"));
}
public ActionResult ui012cadastrarusuario(Usuario usuario)
{
var idusuario = Request.Cookies["userId"].Value;
var permissao = Request.Cookies["permissao"].Value;
if (string.IsNullOrEmpty(idusuario))
{
Response.Redirect("http://www.projetodigimon.com.br/ui002login.jsp");
}
if (!String.IsNullOrEmpty(permissao))
{
if ((permissao != "3") && (permissao != "1") && (permissao != "2") && (permissao != "4") && (permissao != "6"))
{
Response.Redirect("http://www.projetodigimon.com.br/pagina-de-redirecionamento.jsp");
}
}
if (ModelState.IsValid)
{
var appUsuario = new UsuarioAplicacao();
appUsuario.Inserir(usuario);
return RedirectToAction("Index");
}
return View();
}
public IActionResult GetUsuario([FromBody] string login)
{
try
{
if (login == string.Empty)
{
return(BadRequest("Email inválido! Tente novamente."));
}
else
{
var resposta = new UsuarioAplicacao(_contexto).getUsuario(login);
if (resposta != null)
{
var usuarioResposta = JsonConvert.SerializeObject(resposta);
return(Ok(usuarioResposta));
}
else
{
return(BadRequest("Usuário não cadastrado!"));
}
}
}
catch (Exception)
{
return(BadRequest("Erro ao comunicar com a base de dados!"));
}
}
private void CriarAdministrador(IdentityDbContext <UsuarioAplicacao> dbContext)
{
using (var userStore = new UserStore <UsuarioAplicacao>(dbContext))
using (var userManager = new UserManager <UsuarioAplicacao>(userStore))
{
var administradorEmail = ConfigurationManager.AppSettings["admin:email"];
var administrador = userManager.FindByEmail(administradorEmail);
if (administrador != null)
{
return;
}
administrador = new UsuarioAplicacao();
administrador.Email = administradorEmail;
administrador.EmailConfirmed = true;
administrador.UserName = ConfigurationManager.AppSettings["admin:user_name"];
userManager.Create(
administrador,
ConfigurationManager.AppSettings["admin:senha"]);
userManager.AddToRole(administrador.Id, RolesNomes.ADMINISTRADOR);
}
}
public string Put([FromBody] Login lg)
{
UsuarioAplicacao objAppProd = new UsuarioAplicacao(_context);
if (lg != null)
{
if (string.IsNullOrEmpty(lg.Senha))
{
return("favor, inserir a senha!");
}
else
{
Security objSecurity = new Security();
lg.Senha = objSecurity.EncriptSimetrica(lg.Senha);
}
if (lg.CodCli > 0)
{
string retorno = objAppProd.AtualizarUsuario(lg);
return(retorno);
}
else
{
string retorno = objAppProd.InserirUsuario(lg);
return(retorno);
}
}
return("usuario invalido!");
}
public ActionResult ExcluirConfirmado(int id)
{
UsuarioAplicacao app = new UsuarioAplicacao();
app.Excluir(id);
return(RedirectToAction("Index"));
}
public ActionResult Index()
{
UsuarioAplicacao app = new UsuarioAplicacao();
var listaAlunos = app.ListarTodos();
return(View(listaAlunos));
}
public async Task <ActionResult> Registrar(ContaRegistrarViewModel modelo)
{
//https://imasters.com.br/back-end/c-programacao-assincrona-async-e-await
//detecta se o estado do modelo é valido ou não
if (ModelState.IsValid)
{
//criando de fato o usuario
var novoUsuario = new UsuarioAplicacao();
//associando os campos recebidos do IdentityUser
novoUsuario.Email = modelo.Email;
novoUsuario.UserName = modelo.UserName;
novoUsuario.NomeCompleto = modelo.NomeCompleto; //campo vindo da classe UsuarioAplicacao
var resultado = await UserManager.CreateAsync(novoUsuario, modelo.Senha);
//verifica o resultado da ação
if (resultado.Succeeded)
{
await EnviarEmailDeConfirmacaoAsync(novoUsuario);
return(View("AguardandoConfirmacao")); //Apos incluir, redireciona para home
}
else
{
AdicionaErros(resultado);
}
}
//algo deu errado
return(View(modelo));
}
static void Main(string[] args)
{
var app = new UsuarioAplicacao();
SqlConnection conexao = new SqlConnection(@"data source=DESKTOP-4PORDMS\SQLEXPRESS; Integrated Security=SSPI ; Initial Catalog=TesteEstagio");
conexao.Open();
System.Console.Write("Digite a Tarefa: ");
string Tarefa = System.Console.ReadLine();
System.Console.Write("Digite o Status: ");
string Status = System.Console.ReadLine();
var tarefas = new Tarefas
{
Tarefa = Tarefa,
Status = Status
};
//tarefas.TarefaId = 5;
app.Salvar(tarefas);
var dados = app.ListarTodos();
foreach (var tarefa in dados)
{
System.Console.WriteLine("TarefaId:{0}, Tarefa:{1}, Status:{2}", tarefa.TarefaId, tarefa.Tarefa, tarefa.Status);
}
}
public override string[] GetRolesForUser(string username)
{
Usuario usuario = new Usuario();
UsuarioAplicacao appUsuario = UsuarioAplicacaoConstrutor.UsuarioAplicacaoADO();
usuario.LoginEmail = username;
usuario = appUsuario.ValidarUsuarioEmail(usuario);
string[] permissoes = null;
if (usuario != null)
{
if (usuario.TipoUsuario == 1)
{
permissoes = new string[] { "Admin" };
}
else
{
permissoes = new string[] { "Visitante" };
}
return(permissoes.ToArray());
}
else
{
return(null);
}
}
public async Task <ActionResult> Registrar(ContaRegistrarViewModel modelo)
{
if (ModelState.IsValid)
{
var novoUsuario = new UsuarioAplicacao();
novoUsuario.Email = modelo.Email;
novoUsuario.UserName = modelo.UserName;
novoUsuario.NomeCompleto = modelo.NomeCompleto;
var usuario = await UserManager.FindByEmailAsync(novoUsuario.Email);
var usuarioExiste = usuario != null;
if (usuarioExiste)
{
return(View("AguardandoConfirmacao"));
}
var resultado = await UserManager.CreateAsync(novoUsuario, modelo.Senha);
if (resultado.Succeeded)
{
await EnviarEmailConfirmacao(novoUsuario);
return(View("AguardandoConfirmacao"));
}
else
{
AdicionaErros(resultado);
}
}
return(View(modelo));
}
// GET: Usuario
public ActionResult Index()
{
var appUsuario = new UsuarioAplicacao();
var listaUsuarios = appUsuario.ListarTodos();
return(View(listaUsuarios));
}
public ActionResult Editar(Usuario usuario)
{
if (usuario.Senha1 != usuario.ConfirmarSenha)
{
ModelState.AddModelError("", "As senhas não se coincidem!");
}
else
{
UsuarioAplicacao AppUsuario = new UsuarioAplicacao();
int retornoExecucao = AppUsuario.Salvar(usuario);
if (retornoExecucao == 1)
{
ModelState.AddModelError("", "O nome do usuário informado já existe em nosso sistema. Tente com outro nome.");
}
else if (retornoExecucao == 2)
{
ModelState.AddModelError("", "A senha informada já foi utilizada nas últimas 3 alterações. Favor informa outra senha.");
}
else
{
return(RedirectToAction("ListaUsuarios", new { nmUsuario = usuario.NmUsuario }));
}
}
return(View(usuario));
}
public UsuarioViewModel(UsuarioAplicacao usuario)
{
Id = usuario.Id;
NomeCompleto = usuario.NomeCompleto;
Email = usuario.Email;
UserName = usuario.UserName;
}
public async Task <ActionResult> RegistrarPorAutenticacaoExternaCallback()
{
var loginInfo = await SignInManager.AuthenticationManager.GetExternalLoginInfoAsync();
var usuarioExistente = await UserManager.FindByEmailAsync(loginInfo.Email);
if (usuarioExistente != null)
{
return(View("Error"));
}
var novoUsuario = new UsuarioAplicacao();
novoUsuario.Email = loginInfo.Email;
novoUsuario.UserName = loginInfo.Email;
novoUsuario.NomeCompleto = loginInfo.ExternalIdentity.FindFirstValue(loginInfo.ExternalIdentity.NameClaimType);
var resultado = await UserManager.CreateAsync(novoUsuario);
if (resultado.Succeeded)
{
var resultadoAddLoginInfo = await UserManager.AddLoginAsync(novoUsuario.Id, loginInfo.Login);
if (resultadoAddLoginInfo.Succeeded)
{
return(RedirectToAction("Index", "Home"));
}
}
return(RedirectToAction("Error"));
}
public async Task <ActionResult> Registrar(ContaRegistrarViewModel modelo)
{
if (ModelState.IsValid)
{
var novoUsuario = new UsuarioAplicacao();
novoUsuario.Email = modelo.Email;
novoUsuario.UserName = modelo.UserName;
novoUsuario.NomeCompleto = modelo.NomeCompleto;
var usuario = UserManager.FindByEmailAsync(modelo.Email);
var usuarioJaExiste = usuario != null;
//if (usuarioJaExiste)
//return View("AguardandoConfirmacao");
//return RedirectToAction("Index", "Home");
var resultado = await UserManager.CreateAsync(novoUsuario, modelo.Senha);
if (resultado.Succeeded)
{
await EnviarEmailDeConfirmacaoAsync(novoUsuario);
return(View("AguardandoConfirmacao"));
}
else
{
AdicionaErros(resultado);
}
}
// Alguma coisa de errado aconteceu!
return(View(modelo));
}
public async Task <IActionResult> Registrar(RegistrarViewModel modelo)
{
if (ModelState.IsValid)
{
var usuario = new UsuarioAplicacao()
{
UserName = modelo.Email,
Nome = modelo.Nome,
Email = modelo.Email,
DataCadastro = DateTime.Now,
DataUltimoAcesso = DateTime.Now
};
var resultadoCadastro = await _userManager.CreateAsync(usuario, modelo.Senha).ConfigureAwait(false);
if (resultadoCadastro.Succeeded)
{
await _userManager.AddToRoleAsync(usuario, PerfisPadroes.USUARIO).ConfigureAwait(false);
var login = await _signInManager.PasswordSignInAsync(usuario, modelo.Senha, false, lockoutOnFailure : false).ConfigureAwait(false);
if (login.Succeeded)
{
return(RedirectToAction("Index", "Painel"));
}
}
}
ViewData["erroLoginOuCadastro"] = 1;
ViewData["ApresentarRegrasSenha"] = 1;
ModelState.AddModelError("", _localizador["Não foi possivel completar o cadastro"]);
ModelState.AddModelError("", _localizador["Informe todos os campos obrigatórios"]);
return(View(modelo));
}
private async Task CriarAdministrador(IServiceProvider serviceProvider)
{
var roleManager = serviceProvider.GetRequiredService <RoleManager <IdentityRole> >();
var userManager = serviceProvider.GetRequiredService <UserManager <UsuarioAplicacao> >();
var administradorEmail = Configuration["RDADMIN:ADMINISTRADOR-EMAIL"];
var administradorSenha = Configuration["RDADMIN:ADMINISTRADOR-SENHA"];
var ExisteAdmin = await userManager.FindByEmailAsync(administradorEmail);
if (ExisteAdmin != null)
{
return;
}
var admin = new UsuarioAplicacao()
{
UserName = administradorEmail,
Email = administradorEmail,
EmailConfirmed = true,
Nome = "Administrador do Sistema",
DataCadastro = DateTime.Now,
DataUltimoAcesso = DateTime.Now
};
var result = await userManager.CreateAsync(admin, administradorSenha);
await userManager.AddToRoleAsync(admin, PerfisPadroes.ADMINISTRADOR);
}
public BolaoController()
{
appPartida = PartidaAplicacaoConstrutor.PartidaAplicacaoADO();
appCampeonato = CampeonatoAplicacaoConstrutor.CampeonatoAplicacaoADO();
appBolao = BolaoAplicacaoConstrutor.BolaoAplicacaoADO();
appUsuario = UsuarioAplicacaoConstrutor.UsuarioAplicacaoADO();
}
public UsuarioEditarFuncoesViewModel(UsuarioAplicacao usuario, RoleManager <IdentityRole> roleManager)
{
Id = usuario.Id;
NomeCompleto = usuario.NomeCompleto;
Email = usuario.Email;
UserName = usuario.UserName;
Funcoes = roleManager
.Roles
.ToList()
.Select(funcao => new UsuarioFuncaoViewModel
{
Nome = funcao.Name,
Id = funcao.Id
})
.ToList();
foreach (var funcao in Funcoes)
{
var usuarioPossuiRole = usuario.Roles.Any(
usuarioRole => usuarioRole.RoleId == funcao.Id
);
funcao.Selecionado = usuarioPossuiRole;
}
}
public ActionResult ui012cadastrarusuario(Usuario usuario)
{
var idusuario = Request.Cookies["userId"].Value;
var permissao = Request.Cookies["permissao"].Value;
if (string.IsNullOrEmpty(idusuario))
{
Response.Redirect("http://www.projetodigimon.com.br/ui002login.jsp");
}
if (!String.IsNullOrEmpty(permissao))
{
if ((permissao != "3") && (permissao != "1") && (permissao != "2") && (permissao != "4") && (permissao != "6"))
{
Response.Redirect("http://www.projetodigimon.com.br/pagina-de-redirecionamento.jsp");
}
}
if (ModelState.IsValid)
{
var appUsuario = new UsuarioAplicacao();
appUsuario.Inserir(usuario);
return(RedirectToAction("Index"));
}
return(View());
}
public ActionResult CadastroCashGame(CashGame cashGame)
{
var result = CashGameAplicacao.CadatrarCashGame(cashGame);
if (result.TemValor())
{
ViewBag.erro = result;
return(View("CadastroCashGame", new PaginacaoModel2 <CashGame, Cliente, FiltroCliente>
{
ListaModel = new List <CashGame> {
cashGame
},
ListaModel2 = new List <Cliente> {
new Cliente
{
Nome = cashGame.NomeCliente,
Id = cashGame.IdCliente
}
}
}));
}
var nomeImpressora = UsuarioAplicacao.ObterDadosUsuarioLogado().Impressora.ToString();
ImpressaoAplicacao.GravarImpressao(cashGame.Id, nomeImpressora, TipoImpressao.CashGame);
return(RedirectToAction("FiltroCashGame"));
}
private async Task EnviarEmailConfirmacao(UsuarioAplicacao usuario)
{
var token = await UserManager.GenerateEmailConfirmationTokenAsync(usuario.Id);
var link = Url.Action("ConfirmacaoEmail", "Conta", new { usuarioId = usuario.Id, token = token }, Request.Url.Scheme);
await UserManager.SendEmailAsync(usuario.Id, "Confirmação de e-mail", $"Bem vindo ao Forum, clique aqui {link} para confirmar seu e-mail.");
}
static void Main(string[] args)
{
var bd = new bd();
var usuario = new Usuario();
var usuarioAplicacao = new UsuarioAplicacao();
SqlConnection conexao = new SqlConnection(@"Server=localhost;Initial Catalog=ExemploBD;Persist Security Info=False;User ID=sa;Password=Poder6645@; MultipleActiveResultSets=True");
//Abrindo a conexão
conexao.Open();
//string strQueryUpdate = "UPDATE usuario SET nome = 'Fabio' WHERE usuarioId = 1";
//SqlCommand cmdComandoUpdate = new SqlCommand(strQueryUpdate, conn);
//cmdComandoUpdate.ExecuteNonQuery();
//string strQueryDelete = "DELETE FROM usuario WHERE usuarioID = 1";
//SqlCommand cmdComandoDelete = new SqlCommand(strQueryDelete, conn);
//cmdComandoDelete.ExecuteNonQuery();
Console.Write("Digite o nome do usuário:");
string nome = Console.ReadLine();
Console.Write("Digite o nome do Cargo:");
string cargo = Console.ReadLine();
Console.Write("Digite o nome do Data:");
string date = Console.ReadLine();
var Usuario = new Usuario
{
nome = nome,
cargo = cargo,
data = DateTime.Parse(date)
};
Usuario.Id = 4;
new UsuarioAplicacao().Salvar(usuario);
string strQueryInsert = string.Format("INSERT INTO usuario(nome, cargo, date) VALUES ('{0}', '{1}', '{2}')", nome, cargo, date);
bd.ExecutaComando(strQueryInsert);
string strQuerySelect = "SELECT * FROM usuario";
SqlDataReader dados = bd.ExecutaComandoComRetorno(strQuerySelect);
while (dados.Read())
{
Console.WriteLine("Id:{0}, Nome:{1}, Cargo:{2}, Date:{3}", dados["usuarioId"], dados["nome"], dados["cargo"], dados["date"]);
}
}
private async Task EnviarEmailDeConfirmacaoAsync(UsuarioAplicacao usuario)
{
var token = await UserManager.GenerateEmailConfirmationTokenAsync(usuario.Id);
var linkDeCallback = Url.Action("ConfirmacaoEmail", "Conta", new { usuarioId = usuario.Id, token = token }, Request.Url.Scheme);
await UserManager.SendEmailAsync(usuario.Id, "Projeto Teste Identity - Confirmação de Email",
$"Bem vindo, clique aqui {linkDeCallback} para confirmar seu email!");
}
public ActionResult ImprimirComprovante(long idPagamento)
{
//var comprovanteModel = PagamentosAplicacao.ObterPagamentoCommpleto(idPagamento);
var nomeImpressora = UsuarioAplicacao.ObterDadosUsuarioLogado().Impressora.ToString();
ImpressaoAplicacao.GravarImpressao(idPagamento, nomeImpressora, TipoImpressao.Comprovante);
//new ImprimeComprovante().Imprime(comprovanteModel, nomeImpressora);
return(RedirectToAction("ComprovantePagamentos"));
}
public ActionResult ImprimirTorneioCliente(long idTorneioCliente)
{
//var torneioCliente = TorneioClienteAplicacao.BuscarPorId(idTorneioCliente);
var nomeImpressora = UsuarioAplicacao.ObterDadosUsuarioLogado().Impressora.ToString();
ImpressaoAplicacao.GravarImpressao(idTorneioCliente, nomeImpressora, TipoImpressao.TorneioCliente);
//new ImprimeTorneioCliente().Imprime(torneioCliente, nomeImpressora);
return(RedirectToAction("FiltroTorneioCliente"));
}
public ActionResult Editar(Tarefas tarefas)
{
if (ModelState.IsValid)
{
var appUsuario = new UsuarioAplicacao();
appUsuario.Salvar(tarefas);
return(RedirectToAction("Index"));
}
return(View(tarefas));
}
private async Task EnviarSmsDeConfirmacaoAsync(UsuarioAplicacao usuario)
{
var tokenDeConfirmacao = await UserManager.GenerateChangePhoneNumberTokenAsync(usuario.Id, usuario.PhoneNumber);
await UserManager.SendSmsAsync
(
usuario.Id,
$"Token de confirmação: {tokenDeConfirmacao} "
);
}
