Inheritance: IUsuarioService
Ejemplo n.º 1
0
        public ActionResult Login(UsuarioViewModel usuarioViewModel)
        {
            UsuarioRepository usuarioRepository = new UsuarioRepository();
            Usuario usuario = usuarioRepository.Obter(usuarioViewModel.Email);
            HttpCookie cookie = new HttpCookie("GuiaDaPescaUsuario");

            if (usuario == null)
            {
                ViewBag.Mensagem = "Usuario não localizado.";
            }
            else
            {
                if (usuario.Senha == usuarioViewModel.Senha)
                {
                    usuarioViewModel = Mapper.Map<Usuario, UsuarioViewModel>(usuario);

                    cookie.Value = JsonConvert.SerializeObject(usuarioViewModel);
                    cookie.Expires = new DateTime(DateTime.Now.Year + 10, 1, 1);

                    Response.Cookies.Add(cookie);
                }
                else
                {
                    ViewBag.Mensagem = "A senha não pertence a esse usuario";
                }
            }

            return RedirectToAction("Index", "GuiaDaPesca");
        }
        public void SalvarUsuarioSemSenha()
        {
            var unit = new MainUnitOfWork();
            var usuarioRepository = new UsuarioRepository(unit);
            string erroSenha = "erro";

            Usuario usuario = new Usuario();
            usuario.Login = "******";
            //usuario.Senha = "123";
            usuario.Status = "A";
            usuario.Email = "*****@*****.**";

            var erros = usuario.FazerSeForValido<Usuario>(() =>
                {
                    usuarioRepository.Add(usuario);
                    usuarioRepository.UnitOfWork.Commit();
                    //unit.Commit();
                });

            if (erros.ExistemErros())
                erroSenha = erros.FirstOrDefault();

            Assert.IsTrue(erros.ExistemErros(), "Erros encontrados na validação da entidade!");
            Assert.AreEqual(erroSenha, "O campo Senha da entidade não pode ser nulo...", "Validação do campo senha!");

            //var usuarioCadastrado = usuarioRepository.ObterPeloLogin(usuario.Login).FirstOrDefault();

            //Assert.IsNotNull(usuarioCadastrado);
            //Assert.AreEqual(usuarioCadastrado.Login, usuario.Login, "Usuário cadastrado com sucesso!");
        }
        public ActionResult LogOn(LogOnModel model, string returnUrl)
        {
            if (ModelState.IsValid)
            {
                if (model.RecreateDB)
                    DBHelper.Generate();

                var usuarioRepository = new UsuarioRepository();
                if (usuarioRepository.ValidarUsuario(model.UserName, model.Password))
                {
                    FormsAuthentication.SetAuthCookie(model.UserName, model.RememberMe);
                    if (Url.IsLocalUrl(returnUrl) && returnUrl.Length > 1 && returnUrl.StartsWith("/")
                        && !returnUrl.StartsWith("//") && !returnUrl.StartsWith("/\\"))
                    {
                        return Redirect(returnUrl);
                    }
                    else
                    {
                        return RedirectToAction("Index", "Home");
                    }
                }
                else
                {
                    ModelState.AddModelError("", "The user name or password provided is incorrect.");
                }
            }

            // If we got this far, something failed, redisplay form
            return View(model);
        }
Ejemplo n.º 4
0
        public ActionResult Novo(UsuarioViewModel usuarioViewModel)
        {
            Usuario usuario;
            UsuarioRepository usuarioRepository = new UsuarioRepository();
            HttpCookie cookie = new HttpCookie("GuiaDaPescaUsuario");

            if (ModelState.IsValid)
            {
                try
                {
                    usuario = new Usuario(usuarioViewModel.Email,
                        usuarioViewModel.Senha,
                        usuarioViewModel.SenhaConfirmacao);

                    usuarioRepository.Adicionar(usuario);

                    usuarioViewModel = Mapper.Map<Usuario, UsuarioViewModel>(usuario);

                    cookie.Value = JsonConvert.SerializeObject(usuarioViewModel);
                    cookie.Expires = new DateTime(DateTime.Now.Year + 10, 1, 1);

                    Response.Cookies.Add(cookie);

                    return RedirectToAction("Index", "GuiaDaPesca");
                }
                catch (Exception ex)
                {
                    ModelState.AddModelError(string.Empty, ex);
                }
            }

            return View(usuarioViewModel);
        }
Ejemplo n.º 5
0
        public UsuarioService()
        {
            dbFactory = new DatabaseFactory();

            uow = new UnitOfWork(dbFactory);

            repository = new UsuarioRepository(dbFactory);
        }
 public void Initializer()
 {
     _unit = new MainUnitOfWork();
     _usuarioRepository = new UsuarioRepository(_unit);
     _usuarioService = new UsuarioService(_usuarioRepository);
     _tarefaRepository = new TarefaRepository(_unit);
     _tarefaService = new TarefaService(_tarefaRepository);
 }
 public ActionResult Index()
 {
     if (!Request.IsAuthenticated)
     {
         return Redirect("/Account/Logon");
     }
     else
     {
         var usuarioRepository = new UsuarioRepository();
         var usuario = usuarioRepository.GetAllFilteredBy(x => x.Login.Equals(User.Identity.Name, StringComparison.InvariantCultureIgnoreCase)).Single();
         return View(usuario);
     }
 }
Ejemplo n.º 8
0
        public ActionResult Logar(string username, string password, string msg)
        {
            UsuarioRepository iUsuario = new UsuarioRepository(bd);

            var usuario = iUsuario.ObterConta(username, password);

            var session = new UserSession();

            if (usuario.Item2)
            {
                if(usuario.Item3)
                {
                    clienteBusinessModels iCliente = new clienteBusinessModels(bd);

                    session.idConta = usuario.Item1.id;
                    var cliente = iCliente.ObterPerfilPorConta(session.idConta);
                    session.isCliente = true;
                    session.idCliente = cliente.id;
                    session.idConta = cliente.idUsername;
                    session.meuPerfil = "Cliente/Perfil/" + cliente.idUsername;
                    session.idBairro = cliente.idBairro;
                    session.nome = cliente.nome;
                    session.email = cliente.usuario.email;

                    Session["UserSession"] = session;
                    return RedirectToAction("Perfil", "Cliente", new { idConta = usuario.Item1.id });
                }
                else
                {
                    var iLoja = new lojaBusinessModels(bd);

                    session.idConta = usuario.Item1.id;
                    session.isCliente = false;
                    var loja = iLoja.ObterPerfilPorConta(session.idConta);
                    session.idConta = loja.idUsername;
                    session.idCliente = 0;
                    session.meuPerfil = "Loja/Perfil/" + loja.idUsername;
                    session.idBairro = loja.idBairro;
                    session.nome = loja.nome;
                    session.email = loja.usuario.email;

                    Session["UserSession"] = session;
                    return RedirectToAction("Perfil", "Loja", new { idConta = usuario.Item1.id });
                }
            }
            else
            {
                ViewBag.Login = usuario.Item4;
                return View("Entrar");
            }
        }
        public static bool ResetPassword(int usuarioId, string password)
        {
            try
            {
                var usuarioRepository = new UsuarioRepository();
                var encondedPassword = EncodePassword(password);
                usuarioRepository.CambiarPassword(usuarioId, encondedPassword, DateTime.Now);
                return true;
            }
            catch (Exception)
            {

                return false;
            }
        }
Ejemplo n.º 10
0
        public void InserirItemNaColecaoDoUsuario(String titulo, String descricao, 
            Int32 ano, String nomeAutor, Int32 tpItem, Int32 idUser)
        {
            String[] _nomeAutor = nomeAutor.Split(new char[] { ' ' });
            Item item = new ItemFactory().createItem(null, titulo, descricao, ano, _nomeAutor, tpItem);

            IItemRepository repository = new ItemRepository();
            IUsuarioRepository usrRepository = new UsuarioRepository();

            //buscar o usuário para setar no item
            Usuario usr = usrRepository.FindById(idUser);

            //setando o usuário no item para a referencia da fk.
            item._Usuario = usr;

            repository.Create(item);
            repository.Save();
        }
        public static bool Login(string username, string password, bool loginTemporal, out string error)
        {
            error = string.Empty;

            var repo = new UsuarioRepository();
            var usuario = repo.Obtener(u => u.NombreUsuario == username,
                                        u => u.Roles);

            //Verifico que el usuario existe
            if (usuario == null)
            {
                error = "El nombre de usuario es inválido";
                return false;
            }

            //Verifico que la contraseña sea correcta
            var membresia = repo.ObtenerMembresia(usuario.UsuarioId);
            var valido = Crypto.VerifyHashedPassword(membresia.Password, password);
            if (!valido)
            {
                error = "La contraseña ingresada es inválida";
                return false;
            }

            //var rolesAceptados = new []{ "Administrador","Encargado","SuperAdministrador"};
            //var esAdminOEncargado = usuario.Roles.Any(r => rolesAceptados.Contains(r.RoleName));
            //if (esAdminOEncargado || usuario.UsuarioMaxiKioscos.Any(m => m.MaxiKiosco.Identifier == AppSettings.MaxiKioscoIdentifier))
            //{
            //    if (loginTemporal)
            //        UsuarioActual.UsuarioTemporal = usuario;
            //    else
            //        UsuarioActual.Usuario = usuario;
            //    return true;
            //}

            //error = "El usuario ingresado no puede loguearse en este maxikiosco";
            //return false;

            if (loginTemporal)
                UsuarioActual.UsuarioTemporal = usuario;
            else
                UsuarioActual.Usuario = usuario;
            return true;
        }
Ejemplo n.º 12
0
        public void Setup()
        {
            //Arrange
            var optionsSqlite = new DbContextOptionsBuilder <AppACContext>()
                                .UseSqlite(@"Data Source=C:\sqlite\AppACDataBaseTest.db")
                                .Options;

            _dbContext = new AppACContext(optionsSqlite);
            _dbContext.Database.EnsureDeleted();
            _dbContext.Database.EnsureCreated();
            _usuarioRepository       = new UsuarioRepository(_dbContext);
            _tipoActividadRepository = new TipoActividadRepository(_dbContext);
            _asignarActividadService = new AsignarActividadService(
                new UnitOfWork(_dbContext),
                new ActividadRepository(_dbContext),
                _usuarioRepository,
                _tipoActividadRepository,
                new MailServerFake()
                );
        }
Ejemplo n.º 13
0
        public ActionResult Create([Bind(Include = "DetalheId,Usuarioid,Telefone,Endereco")] DetalheUsuario detalheUsuario)
        {
            if (ModelState.IsValid)
            {
                _repDet.Add(detalheUsuario);
                _repDet.Commit();

                return(RedirectToAction("Index"));
            }


            List <Usuario> lst = new List <Usuario>();

            using (var rep = new UsuarioRepository())
            {
                lst = rep.GetAll().ToList();
            }
            ViewBag.Usuarioid = new SelectList(lst, "UsuarioId", "Nome", detalheUsuario.Usuarioid);
            return(View(detalheUsuario));
        }
Ejemplo n.º 14
0
        public LoginResult FazerLogin([FromBody] LoginModel loginModel)
        {
            var result = new LoginResult();

            if (!result.ValidarModel(loginModel))
            {
                return(result);
            }

            var repository = new UsuarioRepository();

            result.IdUsuario = repository.ValidarLogin(loginModel);

            if (result.IdUsuario == 0)
            {
                result.Mensagem.Add("Não foi possível localizar o usuário informado. Verifique as credenciais de acesso");
            }

            return(result);
        }
Ejemplo n.º 15
0
        public AlterarDadosUsuarioResult AlterarUsuario([FromBody] UsuarioModel usuario)
        {
            var result = new AlterarDadosUsuarioResult();

            if (!result.ValidarModel(usuario))
            {
                return(result);
            }

            var repository = new UsuarioRepository();

            var sucesso = repository.AtualizarDadosUsuario(usuario);

            if (!sucesso)
            {
                result.Mensagem.Add("Não foi possível atualizar os dados do usuário. Houve um ou mais erros ao realizar a operação.");
            }

            return(result);
        }
Ejemplo n.º 16
0
        public static bool ValidarLogado(string cookie, out int codigo, out string nome, out string login)
        {
            codigo = 0;
            nome   = null;
            login  = null;

            if (cookie == null || cookie.Length != 72)
            {
                return(false);
            }

            if (int.TryParse(cookie.Substring(0, 8), System.Globalization.NumberStyles.HexNumber, System.Globalization.CultureInfo.InvariantCulture, out codigo) == false)
            {
                return(false);
            }

            codigo ^= CodigoHash;

            return(UsuarioRepository.ValidarToken(codigo, cookie.Substring(8), out nome, out login));
        }
Ejemplo n.º 17
0
        public void BuscarClientePorId()
        {
            //Arrange
            _mock        = new Mock <IDbConnection>();
            _transaction = new Mock <IDbTransaction>();
            _target      = new UsuarioRepository(_mock.Object);

            //Act
            var cliente = new Usuario("General Motors", "general_motors");

            _mock.Setup(x => x.BeginTransaction());
            _mock.Setup()
            .Returns(cliente);

            //Assert
            var esperado = _target.IncluirUsuario(cliente);
            var atual    = new Usuario(1, "General Motors", "general_motors", new List <Perfil>());

            Assert.AreEqual(esperado.Login, atual.Login);
        }
Ejemplo n.º 18
0
        // DELETE: api/Usuarios/5
        //[BasicAuhtentication]
        public IHttpActionResult DeleteUsuarios(long id)
        {
            if (id <= 0)
            {
                return(BadRequest("O id informado na URL deve ser maior que zero."));
            }
            UsuarioRepository userRepository = new UsuarioRepository();
            Usuario           usuario        = userRepository.RetornarPorId(id);

            if (usuario == null)
            {
                return(NotFound());
            }
            // if (/*empRepository.vagaCount(id) > 0*/ empresa.Vagas.Count > 0)
            //return Content(HttpStatusCode.Forbidden, "Essa empresa não pode ser excluída, pois há vagas ativas relacionadas a ela.");

            userRepository.Excluir(usuario);

            return(StatusCode(HttpStatusCode.NoContent));
        }
Ejemplo n.º 19
0
        public IActionResult Login(Usuario u)
        {
            UsuarioRepository ur      = new UsuarioRepository();
            Usuario           usuario = ur.Login(u);

            //Session  - Variaveis
            if (usuario != null)
            {
                HttpContext.Session.SetInt32("id", usuario.Id);
                HttpContext.Session.SetString("nome", usuario.Nome);
                HttpContext.Session.SetInt32("tipo", usuario.Tipo);
                ViewBag.Mensagem = "Usuário logado com sucesso!";
                return(Redirect("Conectado"));
            }
            else
            {
                ViewBag.Mensagem = "Erro, usuário ou senha invalidos!";
                return(View());
            }
        }
Ejemplo n.º 20
0
        public ClientController(UserManager <IdentityUser> userManager, SignInManager <IdentityUser> signInManager,
                                ItlaBankingContext context, IMapper mapper, UsuarioRepository usuarioRepository, CuentaRepository cuentaRepository,
                                TarjetaCreditoRepository tarjetasRepository, PrestamosRepository prestamosRepository, BeneficiarioRepository beneficiarioRepository,
                                TransaccionesRepository transaccionesRepository
                                )
        {
            _userManager   = userManager;
            _signinManager = signInManager;
            _context       = context;
            _mapper        = mapper;


            ///repositorios
            _usuarioRepository       = usuarioRepository;
            _cuentaRepository        = cuentaRepository;
            _prestamosRepository     = prestamosRepository;
            _tarjetasRepository      = tarjetasRepository;
            _beneficiarioRepository  = beneficiarioRepository;
            _transaccionesRepository = transaccionesRepository;
        }
Ejemplo n.º 21
0
        public string ObterNomeResponsavelTarefa()
        {
            // Resumo: Retorna o nome do criador da tarefa selecionada.

            if (dadosTarefa == null)
            {
                dadosTarefa = new TarefaRepository();
            }

            IdResponsavelServ = dadosTarefa.ConsultarTarefa(IdTarefaSelecionada).IdResponsavel;

            if (IdResponsavelServ == 0)
            {
                return("N/A");
            }

            dadosUsuario = new UsuarioRepository();

            return(dadosUsuario.ConsultarUsuarioPorId(IdResponsavelServ).NomeUsuario);
        }
Ejemplo n.º 22
0
        public ActionResult Cadastro()
        {
            if (LoginController.retorno == true)
            {
                CategoriaRepository categoriaRepository = new CategoriaRepository();
                ViewBag.Categorias = categoriaRepository.ObterTodos();

                UsuarioRepository usuarioRepository = new UsuarioRepository();
                ViewBag.Usuarios = usuarioRepository.ObterTodos();

                ProjetoRepository projetoRepository = new ProjetoRepository();
                ViewBag.Projetos = projetoRepository.ObterTodos();

                return(View());
            }
            else
            {
                return(Redirect("/login"));
            }
        }
Ejemplo n.º 23
0
        static void Main(string[] args)
        {
            AssociadosAsserti_AssociadosDataContext context = new AssociadosAsserti_AssociadosDataContext();

            EmpresaRepository empresaRepository = new EmpresaRepository(context);

            GerarEmpresa(empresaRepository);

            ProfissionalRepository profissionalRepository = new ProfissionalRepository(context);

            GerarProfissional(profissionalRepository);

            SocioRepository socioRepository = new SocioRepository(context);

            GerarSocio(socioRepository);

            UsuarioRepository usuarioRepository = new UsuarioRepository(context);

            GerarUsuario(usuarioRepository);
        }
Ejemplo n.º 24
0
        public void LoginIncorreto(string nome, string email, string senha)
        {
            IUsuarioRepository uRepo    = new UsuarioRepository(context);
            IUsuarioService    uService = new UsuarioService(uRepo);
            var controller = new AccountController(uService);

            //Faz o registro do usuário
            var user = new Usuario {
                nome = nome, email = email, senha = senha
            };
            var usuario = controller.SignUp(user) as OkNegotiatedContentResult <Usuario>;

            //verifica o login
            var login = new Login {
                email = email, senha = "1234"
            };
            var usuarioLogin = controller.Login(login) as OkNegotiatedContentResult <ResultError>;

            Assert.AreEqual(usuarioLogin.Content.statusCode, 401);
        }
Ejemplo n.º 25
0
        public IHttpActionResult UltimasAlertasUsuario()
        {
            var alertasUsuario = AlertaRepository.ObtenerAlertasDeUsuario(IdUsuarioExec, 5);
            var alertas        = CopiadoUtil.Copia(alertasUsuario);

            foreach (var alerta in alertas)
            {
                alerta.NombreUsuario = UsuarioRepository.ObtenerUsuarioPorId(alerta.IdUsuario).NombreCompleto();
            }
            var resultado = new ResultadoOperacionDto()
            {
                Mensaje          = "OK",
                Resultado        = true,
                InformacionExtra = alertas
            };

            Configuration.Formatters.JsonFormatter.SerializerSettings.ReferenceLoopHandling = ReferenceLoopHandling.Ignore;

            return(Ok(resultado));;
        }
Ejemplo n.º 26
0
        protected void registrarse_Click(object sender, EventArgs e)
        {
            try
            {
                if (ValidaForm())
                {
                    DataBase.usuario  u  = MapeaFormUsuario();
                    UsuarioRepository ur = new UsuarioRepository();
                    ur.Insertar(u);

                    Sesion(u);

                    Response.Redirect("~/Pages/Perfil.aspx", false);
                }
            }
            catch (Exception)
            {
                Response.Redirect("~/Error.aspx");
            }
        }
Ejemplo n.º 27
0
        public async Task TestLogin()
        {
            ConnectionStrings.BancoDadosConnection = bancoDadosConnection;

            _repository = new UsuarioRepository();
            _service    = new UsuarioService(_repository);
            _appService = new UsuarioAppService(AutoMapperConfiguration.RegisterMappings().CreateMapper(), _service, _jswtService);
            _controller = new UsuarioController(_appService);

            var credencial = new CredencialCommand()
            {
                Email = "*****@*****.**",
                Senha = "bwdesouza"
            };

            var result = await _controller.Login(credencial);

            Assert.IsNotNull(result);
            Assert.IsTrue(true);
        }
Ejemplo n.º 28
0
        public bool AutenticarUsuario()
        {
            #region Resumo
            // Consulta no banco de dados se os dados informados correspondem aos de alguma conta do usuário.
            // Retorna Verdadeiro se os dados equivalem aos dados de alguma conta. Caso contrário retorna Falso.
            #endregion Resumo

            UsuarioRepository dados = new UsuarioRepository();

            Usuario usuario = dados.AutenticarContaDeUsuario(EmailBus, SenhaBus);

            if (usuario == null)
            {
                // Mensagem: Usuário e/ou senha inválidos.
                AlertaForm = Mensagem.MENS_FORM_07;
                return(false);
            }
            Application.Current.Properties["id"] = usuario.Id;
            return(true);
        }
        public KadastroServiceHost()
        {
            //context
            var unit = new MainUnitOfWork();

            //repositories
            var usuarioRepository = new UsuarioRepository(unit);
            var pontoRepository = new PontoRepository(unit);
            var intervaloRepository = new IntervaloRepository(unit);
            var tarefaRepository = new TarefaRepository(unit);

            //services
            var usuarioService = new UsuarioService(usuarioRepository);
            var tarefaService = new TarefaService(tarefaRepository);
            //var pontoRepository = new PontoService(pontoRepository, intervaloRepository);

            //applications
            _usuarioAppService = new UsuarioAppService(usuarioRepository, usuarioService);
            _tarefaAppService = new TarefaAppService(tarefaRepository, tarefaService);
        }
        public IActionResult CadastrarUsuario(IFormCollection form)
        {
            Usuario usuario = new Usuario();

            usuario.Nome  = form["nome"];
            usuario.Email = form["email"];
            usuario.Senha = form["senha"];

            UsuarioRepository repository = new UsuarioRepository();

            if (usuario.Email != "" && usuario.Nome != "" && usuario.Senha != "")
            {
                repository.Cadastro(usuario);
                return(RedirectToAction("Index", "Home"));
            }
            else
            {
                return(RedirectToAction("Cadastro", "Usuario"));
            }
        }
 public void Create(UsuarioDTO usuario)
 {
     try
     {
         using (ModelosDBContainer context = new ModelosDBContainer())
         {
             UsuarioRepository repositorio = new UsuarioRepository(context);
             if (repositorio.Any(usuario.Username))
             {
                 throw new Exception("El usuario ya existe.");
             }
             repositorio.Create(this._mapper.Map <Usuario>(usuario));
             context.SaveChanges();
         }
     }
     catch (Exception ex)
     {
         throw ex;
     }
 }
        public void ShouldCallCreateUsuarioFromPrestaSysDbContext()
        {
            // Arrange
            const int expectedResult = 1;
            var       usuarioEntity  = new Usuario();
            var       dbContextMock  = new DbContextMock <PrestaSysDbContext>(DummyOptions);

            dbContextMock.Setup(s => s.Add(usuarioEntity)).Returns(It.IsAny <EntityEntry <Usuario> >());
            dbContextMock.Setup(s => s.SaveChanges()).Returns(expectedResult);

            var usuarioRepository = new UsuarioRepository(dbContextMock.Object);

            // Act
            var result = usuarioRepository.Create(usuarioEntity);

            // Assert
            dbContextMock.Verify(m => m.Add(usuarioEntity), Times.Once());
            dbContextMock.Verify(m => m.SaveChanges(), Times.Once());
            result.Should().Be(expectedResult);
        }
Ejemplo n.º 33
0
 public IActionResult Listar()
 {
     if (HttpContext.Session.GetInt32("idUsuario") == null)
     {
         return(RedirectToAction("Login"));
     }
     else
     {
         if (HttpContext.Session.GetInt32("tipoUsuario") == 1)
         {
             UsuarioRepository user    = new UsuarioRepository();
             List <Usuario>    usuario = user.Lista();
             return(View(usuario));
         }
         else
         {
             return(RedirectToAction("Index", "Home"));
         }
     }
 }
Ejemplo n.º 34
0
 public static Usuario GetUsuarioByName(string nome)
 {
     try
     {
         UsuarioRepository usuarioRepository = new UsuarioRepository();
         Usuario           usuario           = usuarioRepository.getUsuarioByName(nome);
         if (usuario != null)
         {
             return(usuario);
         }
         else
         {
             throw new Exception("Usuario não localizado - Nome: " + nome);
         }
     }
     catch (Exception e)
     {
         throw e;
     }
 }
 public IActionResult Conta(Usuario u)
 {
     try
     {
         UsuarioRepository ur = new UsuarioRepository();
         u.tipo = 0;
         if (u.avatar == null)
         {
             u.avatar = "/imagens/user1.png";
         }
         ur.insert(u);
         return(RedirectToAction("Login", "Usuario"));
     }
     catch (Exception e)
     {
         ViewBag.mensagem = e.Message;
         ViewBag.processo = "processo de criação de usuário";
         return(View("../Home/Erro"));
     }
 }
Ejemplo n.º 36
0
        public void ObterUsuarioPeloLogin()
        {
            var unit = new MainUnitOfWork();
            var usuarioRepository = new UsuarioRepository(unit);

            var usuario = new Usuario();
            usuario.Login = "******";
            usuario.Nome = "teste";
            usuario.PerfilAcesso = PerfilAcesso.Desenvolvedor;

            usuario.GenerateNewIdentity();

            usuarioRepository.Add(usuario);
            unit.CommitAndRefreshChanges();

            var usuarioCadastrado = usuarioRepository.GetByLogin(usuario.Login).FirstOrDefault();

            Assert.IsNotNull(usuarioCadastrado);
            Assert.IsTrue(usuarioCadastrado.Login == usuario.Login, "Não foi encontrado dados na tabela projeto do zimmer, talvez o método Seed não esteja funcional");
        }
Ejemplo n.º 37
0
        /// <summary>
        /// Salva ou atualiza um usuario
        /// </summary>
        /// <param name="usuarioNovo">dados do usuario</param>
        /// <param name="usuarioId">codigo do usuario autenticado</param>
        /// <returns></returns>
        public Usuario Save(Usuario usuarioNovo, int usuarioId = 0)
        {
            try
            {
                if (usuarioNovo.Id > 0)
                {
                    if (usuarioNovo.Id != usuarioId)
                    {
                        throw new Exception("Acesso negado!");
                    }

                    var usuario = UsuarioRepository.GetById(usuarioNovo.Id);
                    usuario.Nome     = usuarioNovo.Nome;
                    usuario.Email    = usuarioNovo.Email;
                    usuario.Telefone = usuarioNovo.Telefone;

                    UsuarioRepository.Update(usuario);
                }
                else
                {
                    if (UsuarioRepository.FindFirstBy(x => x.Email == usuarioNovo.Email) != null)
                    {
                        throw new ValidationException("E-mail já cadastrado!");
                    }

                    usuarioNovo.DataCadastro = DateTime.Now;
                    usuarioNovo.Senha        = usuarioNovo.Senha.Md5Hash();

                    UsuarioRepository.Add(usuarioNovo);
                }

                UsuarioRepository.SaveChanges();

                return(UsuarioRepository.GetFullByEmail(usuarioNovo.Email));
            }
            catch (Exception ex)
            {
                _logger.LogError(ex.Message);
                throw;
            }
        }
        public IActionResult EditarRifa()
        {
            RifaRepository    rifas    = new RifaRepository();
            UsuarioRepository usuarios = new UsuarioRepository();

            var listarRifas    = rifas.GetAll();
            var listarUsuarios = usuarios.GetAll();

            List <Usuarios> listUsers = new List <Usuarios>();

            foreach (var usuario in listarUsuarios)
            {
                List <int> listaPago    = new List <int>();
                List <int> listaNaoPago = new List <int>();

                foreach (var rifa in listarRifas)
                {
                    if (usuario.Id == rifa.NomeId)
                    {
                        if (rifa.Pago == true)
                        {
                            listaPago.Add(rifa.Numero);
                        }
                        else
                        {
                            listaNaoPago.Add(rifa.Numero);
                        }
                    }
                }

                usuario.Pagos    = String.Join("-", listaPago.ToArray());
                usuario.NaoPagos = String.Join("-", listaNaoPago.ToArray());
                listUsers.Add(usuario);
            }

            ViewBag.listaUsuarios = listUsers;



            return(View());
        }
Ejemplo n.º 39
0
        public Usuario AutenticarUsuario(Usuario usuario)
        {
            string password = string.Empty;

            if (string.IsNullOrEmpty(usuario.Email))
            {
                throw new Exception("Email não pode ser em branco");
            }


            if (string.IsNullOrEmpty(usuario.Password))
            {
                throw new Exception("Senha não pode ser em branco");
            }
            else
            {
                password = criptografiaService.RetornarMD5(usuario.Password);
            }


            UsuarioRepository usuarioRepository = new UsuarioRepository();

            try
            {
                usuario = usuarioRepository.RetornarUsuarioPorEmail(usuario.Email, false);
            }
            catch (Exception ex)
            {
                throw ex;
            }

            if (usuario.Password == password)
            {
                usuario.Password = null;
                return(usuario);
            }
            else
            {
                throw new Exception("Senha inválida");
            }
        }
        public void Relatorio()
        {
            StringBuilder conteudo = new StringBuilder();

            conteudo.Append("<h1>Relatório de Recebimentos</h1>");
            conteudo.Append($"<p>Relatório gerado em: {DateTime.Now}</p>");
            conteudo.Append("<br/>");
            conteudo.Append("<table border='1' style='width: 100%'>");
            conteudo.Append("<tr>");
            conteudo.Append("<td>Origem do Recebimento</td>");
            conteudo.Append("<td>Valor</td>");
            conteudo.Append("<td>Data de Entrada</td>");
            conteudo.Append("</tr>");

            UsuarioRepository repUsuario = new UsuarioRepository();
            Usuario           usuario    = repUsuario.Find(User.Identity.Name);

            ReceberRepository rep = new ReceberRepository();

            foreach (ContasReceber r in rep.FindAll(usuario.IdUsuario))
            {
                conteudo.Append("<tr>");
                conteudo.Append($"<td>{r.Titulo}</td>");
                conteudo.Append($"<td>{r.Valor}</td>");
                conteudo.Append($"<td>{r.DataCadastro}</td>");
                conteudo.Append("</tr>");
            }
            conteudo.Append("</table>");

            ReportsUtil util = new ReportsUtil();

            byte[] pdf = util.GetPDF(conteudo.ToString());
            //Download..

            Response.Clear();
            Response.ContentType = "application/pdf";
            Response.AddHeader("content-disposition", "attachment; filename=relatorio.pdf");
            Response.Cache.SetCacheability(HttpCacheability.NoCache);
            Response.BinaryWrite(pdf);
            Response.End();
        }
Ejemplo n.º 41
0
        public async Task <IActionResult> IniciarSesion(Usuario usuario, bool recordar)
        {
            ctrlusersContext            context = new ctrlusersContext();
            UsuarioRepository <Usuario> repos   = new UsuarioRepository <Usuario>(context);
            var datos = repos.GetUsuarioCorreo(usuario.Correo);

            if (datos != null && HashHelper.GetHash(usuario.Contra) == datos.Contra)
            {
                if (datos.Activo == 1)
                {
                    List <Claim> info = new List <Claim>();
                    info.Add(new Claim(ClaimTypes.Name, datos.NomUsuario));
                    info.Add(new Claim(ClaimTypes.Role, "Seguidor"));
                    info.Add(new Claim("Correo", datos.Correo));
                    info.Add(new Claim("Nombre", datos.NomUsuario));

                    var claimsIdentity  = new ClaimsIdentity(info, CookieAuthenticationDefaults.AuthenticationScheme);
                    var claimsPrincipal = new ClaimsPrincipal(claimsIdentity);

                    if (recordar == true)
                    {
                        await HttpContext.SignInAsync(CookieAuthenticationDefaults.AuthenticationScheme, claimsPrincipal, new AuthenticationProperties { IsPersistent = true });
                    }
                    else
                    {
                        await HttpContext.SignInAsync(CookieAuthenticationDefaults.AuthenticationScheme, claimsPrincipal, new AuthenticationProperties { IsPersistent = false });
                    }
                    return(RedirectToAction("Index"));
                }
                else
                {
                    ModelState.AddModelError("", "Tu cuenta no ha sido activada, dirígete al correo para activarla");
                    return(View(usuario));
                }
            }
            else
            {
                ModelState.AddModelError("", "El correo electrónico o la contraseña son incorrectos");
                return(View(usuario));
            }
        }
Ejemplo n.º 42
0
        public ActionResult Favoritar(int idLoja)
        {
            try
            {
                var iConta = new UsuarioRepository(bd);
                var session = Session["UserSession"] as UserSession;

                var conta = iConta.Obter(session.idConta);

                var dadosFavoritar = new lojafavorita();

                if (conta == null || !conta.IsCliente)
                {
                    return Json("Erro ao favoritar!");
                }
                else
                {
                    var iLojaFavorita = new lojaFavoritaBusinessModels(bd);

                    dadosFavoritar.idCliente = session.idCliente;
                    dadosFavoritar.idLoja = idLoja;

                    var evento = iLojaFavorita.CriarFavorito(dadosFavoritar);

                    if (evento.Item2)
                    {
                        return Json(evento.Item1);
                    }
                    else
                    {
                        return Json(evento.Item1);
                    }

                }
            }
            catch
            {

                return Json(null, "Erro ao favoritar!");
            }
        }
        private int InserirUsuario()
        {
            using (UsuarioRepository repo = new UsuarioRepository())
            {
                var usuario = new Usuario
                {
                    Nome   = "Demo teste 1",
                    Email  = "*****@*****.**",
                    Senha  = "123456",
                    Ativo  = true,
                    Perfil = new Perfil {
                        Id = 2, Nome = "Usuário"
                    }
                };

                int id = repo.Inserir(usuario).Id;

                Assert.IsTrue(id > 0);
                return(id);
            }
        }
        public void SetUp()
        {
            _dbContext   = new CrudAppContext();
            _transaction = _dbContext.Database.BeginTransaction();

            var config = new MapperConfiguration(cfg => {
                cfg.AddProfile(new DomainToViewModelMappingProfile());
                cfg.AddProfile(new ViewModelToDomainMappingProfile());
            });

            var usuarioRepository  = new UsuarioRepository(_dbContext);
            var unitOfWork         = new UnitOfWork(_dbContext);
            var domainNotification = new DomainNotification();

            _mapper            = config.CreateMapper();
            _usuarioService    = new UsuarioService(usuarioRepository, unitOfWork, domainNotification);
            _usuarioAppService = new UsuarioAppService(_mapper, _usuarioService);
            _usuarioViewModel  = new UsuarioViewModel {
                Nome = "Adler Pagliarini do Nascimento", Email = "*****@*****.**", Telefone = "15981312383"
            };
        }
 public Usuario Login(string username, string password)
 {
     var usuariosRepository = new UsuarioRepository();
     return usuariosRepository.GetByUsernameAndPassword(username, this.HashPassword(password));
 }
Ejemplo n.º 46
0
        public ActionResult Register(UsuarioDto usuarioDto)
        {
            IUsuarioRepository usuarioRepository = new UsuarioRepository();
            Usuario usuario = new Usuario();
            usuario = usuarioDto.getUsuario();

            if (ModelState.IsValid)
            {
                if (!WebSecurity.UserExists(usuario.Login))
                    WebSecurity.CreateUserAndAccount(
                        usuario.Login,
                        usuario.Password,
                        new
                        {
                            Nombre = usuario.Nombre,
                            Apellido = usuario.Apellido,
                            Codigo = usuario.Codigo,
                            Password = usuario.Password,
                        });

                if (!Roles.GetRolesForUser(usuario.Login).Contains(usuario.RolAcademico))
                    Roles.AddUsersToRoles(new[] { usuario.Login }, new[] { usuario.RolAcademico });

                return this.RedirectToAction("Index", "Home");
            }
            return View(usuarioDto);
        }
        public static bool VerificarPassword(string username, string password)
        {
            var repo = new UsuarioRepository();
            var usuario = repo.Obtener(u => u.NombreUsuario == username,
                                        u => u.Roles);

            //Verifico que la contraseña sea correcta
            var membresia = repo.ObtenerMembresia(usuario.UsuarioId);
            var valido = Crypto.VerifyHashedPassword(membresia.Password, password);
            return valido;
        }
 public bool existeUsername(string username)
 {
     UsuarioRepository usrRep = new UsuarioRepository();
     return usrRep.existeUsername(username);
 }
 public byte[] getPasswordHashedByUsername(string username)
 {
     UsuarioRepository usrRep = new UsuarioRepository();
     return usrRep.getPasswordHashedByUsername(username);
 }
 public int insertRolesUsuario(Usuario usuario)
 {
     UsuarioRepository usrRep = new UsuarioRepository();
     return usrRep.InsertRolesUsuario(usuario);
 }
 public void Initializer()
 {
     unit = new MainUnitOfWork();
     usuarioRepository = new UsuarioRepository(unit);
 }
 public void updatePassword(String username, byte[] hashedPassword)
 {
     UsuarioRepository usrRep = new UsuarioRepository();
     usrRep.updatePassword(username, hashedPassword);
 }
Ejemplo n.º 53
0
 /// <summary>
 /// Trae los permisos que tiene un usuario por cada seccion
 /// <param name="sectionId">El ID de la Seccion</param>
 /// <returns>Una coleccion de Permission</returns>
 public IQueryable<Permiso> Permisos(int sectionId)
 {
     UsuarioRepository _RepUser = new UsuarioRepository();
     return _RepUser.GetPermisosBySectionAndUser(this.Id, sectionId);
 }
Ejemplo n.º 54
0
 public IQueryable<Permiso> Permisos()
 {
     UsuarioRepository _RepUser = new UsuarioRepository();
     return _RepUser.GetPermisos(this.Id);
 }
Ejemplo n.º 55
0
 /// <summary>
 /// Trae las secciones a las que tiene permiso el usuario
 /// </summary>
 /// <returns>Una coleccion de Section</returns>
 public IQueryable<Seccion> Secciones()
 {
     UsuarioRepository _RepUser = new UsuarioRepository();
     return _RepUser.GetSeccionesByUserName(this.Id);
 }
Ejemplo n.º 56
0
        private void btnIngresar_Click(object sender, EventArgs e)
        {
            bool result = true;

            if (string.IsNullOrEmpty(this.txtUsuario.Text))
            {
                this.errorValidator.SetError(this.txtUsuario, "Ingresar Nombre Usuario.");
                result = false;
            }
            else
            {
                this.errorValidator.SetError(this.txtUsuario, string.Empty);
            }
            if (string.IsNullOrEmpty(this.txtClave.Text))
            {
                this.errorValidator.SetError(this.txtClave, "Ingresar Contraseña.");
                result = false;
            }
            else
            {
                this.errorValidator.SetError(this.txtClave, string.Empty);
            }

            if (result)
            {
                string userDomain = FindName(txtUsuario.Text);
                if (string.IsNullOrEmpty(userDomain))
                {
                    MessageBox.Show(this.ParentForm, "Usted No tiene acceso al Sistema", "Mensaje", MessageBoxButtons.OK, MessageBoxIcon.Warning);
                }
                else
                {
                    bool existeUsuario = UserExists(txtUsuario.Text);
                    if (existeUsuario)
                    {
                        if (AutenticarEnDominio(userDomain, txtUsuario.Text, txtClave.Text))
                        {
                            UsuarioRepository usuarioRepository = new UsuarioRepository();

                            if (usuarioRepository.GetByUsername(txtUsuario.Text) == null)
                            {
                                MessageBox.Show(this.ParentForm, "Este Usuario de Dominio " + txtUsuario.Text + " no pertenece al Sistema", "Mensaje", MessageBoxButtons.OK, MessageBoxIcon.Warning);
                            }
                            else
                            {
                                UsuarioSession.UserName = this.txtUsuario.Text;
                                UsuarioSession.Clave = txtClave.Text;
                                this.DialogResult = DialogResult.OK;
                                this.Close();
                            }
                        }
                        else
                        {
                            MessageBox.Show(this.ParentForm, "Password incorrecto para AD", "Mensaje", MessageBoxButtons.OK, MessageBoxIcon.Warning);
                        }
                    }
                    else
                    {
                        MessageBox.Show(this.ParentForm, "Este usuario no se encuentra en AD", "Mensaje", MessageBoxButtons.OK, MessageBoxIcon.Warning);
                    }
                }
            }
        }
 public Usuario BuscaPorUsuario(String login, String senha)
 {
     IUsuarioRepository repository = new UsuarioRepository();
     return repository.findByLoginAndSenha(login, senha);
 }
Ejemplo n.º 58
0
 protected override void Dispose(bool disposing)
 {
     _Rep = null;
     base.Dispose(disposing);
 }