示例#1
0
        public async Task <IActionResult> CadastrarOrganizador(Gerenciar model)
        {
            try
            {
                if (!ModelState.IsValid)
                {
                    return(BadRequest());
                }

                var user = new ApplicationUser
                {
                    Email              = model.Email,
                    NormalizedEmail    = model.Email.ToUpper(),
                    UserName           = model.Email,
                    NormalizedUserName = model.Email.ToUpper(),
                    DataCadastro       = DateTime.Now,
                    Nome          = model.Nome,
                    Sobrenome     = model.Sobrenome,
                    PhoneNumber   = model.PhoneNumber,
                    Celular       = model.Celular,
                    CursosId      = 1,
                    InstituicaoId = 1,
                    EnderecoId    = 1,
                    FirstAccess   = true
                };

                var result = await _userManager.CreateAsync(user);

                if (result.Succeeded)
                {
                    await _userManager.AddToRoleAsync(user, "ORGANIZADOR");

                    //link
                    var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);

                    var callbackUrl = Url.Action(
                        "ConfirmEmail", "Account",
                        new { user = user.UserName, code = code });

                    var url = $"{urlRoot}{callbackUrl}";

                    //email
                    var email = await _emailServices.EnviarEmail(user.Email, url);

                    ViewBag.Cadastrado = "cadastrado";
                    return(View("GerenciarOrganizador", new List <Gerenciar>()));
                }
                else
                {
                    await _userManager.DeleteAsync(user);

                    ViewBag.Errors = result.ConvertToHTML();
                    return(View("CadastrarOrganizador", model));
                }
            }
            catch (Exception ex)
            {
                return(BadRequest(ex.Message));
            }
        }
示例#2
0
        public async Task <IActionResult> Login(LoginViewModel model)
        {
            try
            {
                var user = await _userManager.FindByNameAsync(model.EmailLogin);

                if (user != null)
                {
                    if (!ModelState.IsValid)
                    {
                        return(BadRequest());
                    }

                    var result = await _signInManager.PasswordSignInAsync(model.EmailLogin,
                                                                          model.SenhaLogin, model.RememberMe, user.EmailConfirmed);

                    if (result.Succeeded)
                    {
                        if (!string.IsNullOrEmpty(model.ReturnUrl) && Url.IsLocalUrl(model.ReturnUrl))
                        {
                            return(Redirect(model.ReturnUrl));
                        }
                        else if (model.ConfirmaEmail && user.EmailConfirmed == false)
                        {
                            //link
                            var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);

                            var callbackUrl = Url.Action(
                                "ConfirmEmail", "Account",
                                new { user = user.UserName, code = code });

                            var url = $"http://localhost:54134{callbackUrl}";

                            //email
                            var email = await _emailServices.EnviarEmail(user.Email, url);

                            ViewBag.EnviadoEmail = true;
                            return(View("Login", new LoginViewModel()));
                        }
                        else if (model.ConfirmaEmail == false && user.EmailConfirmed == false)
                        {
                            ViewBag.EmailNaoConfirmado = true;
                            return(View("Login", new LoginViewModel()));
                        }
                        else if (user.FirstAccess == true)
                        {
                            return(RedirectToAction("Registrar"));
                        }
                        else
                        {
                            return(RedirectToAction("Home"));
                        }
                    }
                    else
                    {
                        ModelState.AddModelError("", "Invalid login attempt");
                        return(View(model));
                    }
                }
                ViewBag.UsuarioNaoExiste = true;
                return(View("Login", model));
            }
            catch (Exception ex)
            {
                return(BadRequest(ex.Message));
            }
        }
示例#3
0
        public async Task <IActionResult> AdicionarAutor(string email, long id, bool orientador)
        {
            try
            {
                //verifica se esse email já esta cadastrado, devolve id do usuario
                var usuario = await _accountRepository.BuscaUsuario(email);

                if (usuario != null)
                {
                    //verificar se esse usuario ja esta cadastrado no trabalho
                    var existeCadastro = await _trabalhoRepository.VerificaCadastroTrabalho(id, usuario.Id);

                    if (existeCadastro == true)
                    {
                        return(BadRequest("Usuario já cadastrado no trabalho"));
                    }
                    else
                    {
                        var autor = new AutorTrabalho()
                        {
                            StatusUsuarioId = (usuario.Nome == null) ? 3 : 2,
                            Orientador      = orientador,
                            TrabalhoId      = id,
                            UsuarioId       = usuario.Id
                        };

                        var cadastrar = await _trabalhoRepository.CadastraAutorTrabalho(autor.UsuarioId, autor.StatusUsuarioId, autor.Orientador, autor.TrabalhoId, false);

                        if (cadastrar == true)
                        {
                            var autorCadastrado = new AutorViewModel
                            {
                                Id        = usuario.Id,
                                Email     = email,
                                Nome      = (usuario.Nome == null) ? "" : usuario.Nome.ToUpper(),
                                Sobrenome = (usuario.Sobrenome == null) ? "" : usuario.Sobrenome.ToUpper(),
                                StatusId  = (usuario.Nome == null) ? 3 : 2,
                            };
                            return(Json(autorCadastrado));
                        }
                        else
                        {
                            return(BadRequest("Não foi possível cadastrar usuario"));
                        }
                    }
                }
                else
                {
                    string caracteresPermitidos = "abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNOPQRSTUVWXYZ0123456789!@$?_-";
                    char[] chars = new char[6];
                    Random rd    = new Random();
                    for (int i = 0; i < 6; i++)
                    {
                        chars[i] = caracteresPermitidos[rd.Next(0, caracteresPermitidos.Length)];
                    }
                    var senha = new string(chars);

                    var user = new ApplicationUser()
                    {
                        Email              = email,
                        UserName           = email,
                        NormalizedEmail    = email,
                        NormalizedUserName = email,
                        FirstAccess        = true,
                        DataCadastro       = DateTime.Now,
                        CursosId           = 1,
                        InstituicaoId      = 1,
                        EnderecoId         = 1,
                    };

                    var result = await _userManager.CreateAsync(user, senha);

                    if (result.Succeeded)
                    {
                        try
                        {
                            await _userManager.AddToRoleAsync(user, "AUTOR");

                            var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);

                            var callbackUrl = Url.Action(
                                "ConfirmEmail", "Account",
                                new { user = user.UserName, code = code });

                            var url = $"{urlRoot}{callbackUrl}";

                            //email
                            var emailConfirmation = await _emailServices.EnviarEmail(user.Email, url, senha);

                            var autor = new AutorTrabalho()
                            {
                                StatusUsuarioId = 3,
                                Orientador      = orientador,
                                TrabalhoId      = id,
                                UsuarioId       = user.Id
                            };

                            //cadastra autor no trabalho
                            var cadastrar = await _trabalhoRepository.CadastraAutorTrabalho(autor.UsuarioId, autor.StatusUsuarioId, autor.Orientador, autor.TrabalhoId, false);

                            if (cadastrar == true)
                            {
                                var autorCadastrado = new AutorViewModel
                                {
                                    Id       = user.Id,
                                    Email    = email,
                                    StatusId = 3
                                };
                                return(Json(autorCadastrado));
                            }
                            else
                            {
                                return(BadRequest("Não foi possível cadastrar usuario"));
                            }
                        }
                        catch (Exception ex)
                        {
                            await _userManager.DeleteAsync(user);

                            return(BadRequest("Houve um erro ao cadastrar o usuário."));
                        }
                    }
                    return(Ok());
                }
            }
            catch (Exception ex)
            {
                return(BadRequest(ex.Message));
            }
        }