private UsuarioModel BuscarUsuario(string idUsuario)
        {
            int id = Convert.ToInt32(idUsuario);

            try
            {
                using (Context db = new Context())
                {
                    UsuarioBLL bll = new UsuarioBLL(db, -999);
                    //Usuario usuario = bll.FindSingle(u => u.idUsuario == id, p => p.Perfis);
                    Usuario usuario = bll.FindSingle(u => u.idUsuario == id, i => i.Perfis.Select(e => e.Perfil));
                    
                    if (usuario != null)
                    {
                        List<UsuarioModel.Perfil> Perfis = new List<UsuarioModel.Perfil>();

                        foreach (var perfilUsuario in usuario.Perfis)
                        {
                            Perfis.Add(new UsuarioModel.Perfil { 
                                idPerfil = perfilUsuario.idPerfil,
                                nmPerfil = perfilUsuario.Perfil.nmPerfil
                            });
                        }

                        return new UsuarioModel
                        {
                            idUsuario = usuario.idUsuario,
                            nmUsuario = usuario.nmUsuario,
                            dsLogin = usuario.dsLogin,
                            dsEmail = usuario.dsEmail,
                            dtValidade = usuario.dtValidade,
                            flAtivo = usuario.flAtivo,
                            Perfis = Perfis
                        };
                    }

                    return null;
                }
            }
            catch
            {
                return null;
            }
        }
        private LoginData DoLogin(LoginVM model, string nrAcesso)
        {
            LoginData data = new LoginData
            {
                LoginMessage = LoginMessageId.Sucesso,
                ShowCaptcha = false
            };

            using (Context db = new Context())
            {
                using (var transaction = new RP.DataAccess.RPTransactionScope(db))
                {

                    // instancia bll do usuario
                    UsuarioBLL usuarioBLL = new UsuarioBLL(db, 0);

                    // consulta usuario pelo login
                    Usuario usuario = usuarioBLL.FindSingle(u => u.dsLogin.ToLower().Equals(model.Usuario.ToLower()));

                    //if (data.ShowCaptcha)
                    //    return data;

                    // se o usuario nao existir
                    if (usuario == null)
                    {
                        data.LoginMessage = LoginMessageId.UsuarioInvalido;
                    }
                    // se o usuario existir
                    else
                    {
                        data.ShowCaptcha = usuario.nrFalhalogin >= Convert.ToInt32(ConfigurationManager.AppSettings["Seguranca:tentativasParaExibirCaptcha"]);
                        // se a senha informada estiver incorreta
                        if (!(usuario.dsSenha == RP.Util.Class.Util.getHash(model.Senha)))
                        {
                            // registra a tentiva falha de acesso
                            AccessRegister(model.Usuario, false);

                            // seta status do login
                            data.LoginMessage = LoginMessageId.SenhaInvalida;

                            // instancia bll de Log
                            //RP.Log.Model.BLL LogBLL = new Log.Model.BLL();

                            // altera a quantidade de falhas
                            usuario.nrFalhalogin = (usuario.nrFalhalogin ?? 0) + 1;
                            data.ShowCaptcha = usuario.nrFalhalogin >= Convert.ToInt32(ConfigurationManager.AppSettings["Seguranca:tentativasParaExibirCaptcha"]);

                            // armazena tentativas falhas de acesso
                            data.TentativasFalhas = usuario.nrFalhalogin ?? 0;

                            // armazena as tentativas falhas de acesso
                            if (data.TentativasFalhas >= Convert.ToInt32(ConfigurationManager.AppSettings["Seguranca:tentativasParaBloquearUsuario"]))
                            {
                                // bloqueia o usuario no banco
                                usuario.flAtivo = "Não";
                                usuarioBLL.Update(usuario);

                                // seta status do login
                                data.LoginMessage = LoginMessageId.UsuarioInativo;
                            }
                            else
                            {
                                usuarioBLL.UpdateLoginCount(usuario);
                            }

                        }
                        // se a senha estiver correta
                        else
                        {
                            // se usuario não estiver ativo
                            if (!(usuario.flAtivo.ToLower().Equals("sim")))
                            {
                                data.LoginMessage = LoginMessageId.UsuarioInativo;
                            }
                            // se usuario nao tiver licencas disponiveis
                            else if (!Auth.Class.License.UseLicense(usuario.dsLogin, nrAcesso))
                            {
                                data.LoginMessage = LoginMessageId.SemLicenca;
                            }
                            // se a senha do usuario estiver expirada
                            else if ((usuario.dtValidade ?? DateTime.Now.Date.AddDays(-1)) < DateTime.Now.Date)
                            {
                                data.LoginMessage = LoginMessageId.SenhaExpirada;
                            }
                            else
                            {
                                usuario.nrFalhalogin = 0;
                                usuarioBLL.UpdateLoginCount(usuario);
                            }

                            // armazena usuario
                            data.Usuario = usuario;
                        }

                        usuarioBLL.SaveChanges();
                        transaction.Complete();
                    }
                }
            }

            return data;
        }
        public ActionResult ChangePassword(EditarSenhaVM model)
        {
            try
            {
                // obtem o id do usuario da sessao
                int idUsuario = Convert.ToInt32(Session["login.UsuarioId"]);

                using (Context db = new Context())
                {
                    // instancia bll do usuario
                    UsuarioBLL usuarioBLL = new UsuarioBLL(db, 0);

                    // consulta usuario pelo id
                    Usuario usuario = usuarioBLL.FindSingle(u => u.idUsuario == idUsuario);

                    // se o usuario do formulario for diferente do usuario da sessao
                    if (usuario.dsLogin != model.Usuario)
                    {
                        throw new Exception("O usuário não confere com o login! Certifique-se de estar alterando o seu usuário.");
                    }
                    //certifica-se de que o usuario informado tem a senha com data expirada
                    // garante que somente um usuário com senha expirada, poderá ser alterado
                    else if (usuario.dtValidade >= DateTime.Now.Date)
                    {
                        throw new Exception("O usuário informado não possui a senha expirada! Certifique-se de estar alterando o seu usuário.");
                    }
                    // se a senha do usuario for diferente da senha informada no formulario
                    else if (!(usuario.dsSenha == RP.Util.Class.Util.getHash(model.Senha)))
                    {
                        // adiciona mensagem no modelstate
                        ModelState.AddModelError("Senha", "Usuário ou senha incorretos");
                    }
                    // se a nova senha for igual a senha atual do usuario
                    else if (usuario.dsSenha == RP.Util.Class.Util.getHash(model.NovaSenha))
                    {
                        // adiciona mensagem no modelstate
                        ModelState.AddModelError("NovaSenha", "A nova senha deve ser diferente da senha atual");
                    }

                    // se modelstate for valido
                    if (ModelState.IsValid)
                    {
                        // seta nova senha criptografada para o usuario
                        usuario.dsSenha = RP.Util.Class.Util.getHash(model.NovaSenha);
                        usuario.dtValidade = DateTime.Now.Date.AddDays(Convert.ToInt32(ConfigurationManager.AppSettings["UsuarioValidadeSenha"]));
                        usuario.flAtivo = "Sim";

                        // altera o usuario
                        using (var transaction = new RP.DataAccess.RPTransactionScope(db))
                        {
                            BLL.UsuarioBLL bll = new BLL.UsuarioBLL(db, Helpers.Helper.UserId);
                            bll.Update(usuario);
                            bll.SaveChanges();
                            transaction.Complete();
                        }

                        // faz login do usuario no sistema
                        CriarCookieUsuario(usuario, Convert.ToString(Session["login.nrAcesso"]), false);

                        // registra o acesso como sucesso
                        AccessRegister(usuario.dsLogin, true);

                        // remove usuario da sessao
                        Session.Remove("login.UsuarioId");

                        // remove Id de acesso na sessao
                        Session.Remove("login.nrAcesso");

                        // adiciona mensagem de sucesso
                        this.AddFlashMessage(RP.Util.Resource.Message.PASSWORD_UPDATE, FlashMessage.SUCCESS);

                        // redireciona para index
                        return RedirectToAction("Index");
                    }
                }
            }
            catch (Exception ex)
            {
                // adiciona mensagem de erro
                this.AddFlashMessage(RP.Util.Exception.Message.Get(ex), FlashMessage.ERROR);

                // redireciona para login
                return RedirectToAction("Login");
            }

            return View(model);
        }
        public ActionResult ForgotPassword(ResetSenha model)
        {
            try
            {
                using (Context db = new Context())
                {
                    // instancia bll do usuario
                    UsuarioBLL usuarioBLL = new UsuarioBLL(db, 0);

                    // consulta usuario pelo email
                    Usuario usuario = usuarioBLL.FindSingle(u => u.dsEmail == model.email);

                    // se o usuario do formulario for diferente do usuario da sessao
                    if (usuario == null)
                    {
                        ModelState.AddModelError("email", "Não foi possível determinar o email informado, informe um email valido");
                    }

                    // se modelstate for valido
                    if (ModelState.IsValid)
                    {

                        // reseta a senha
                        using (var transaction = new RP.DataAccess.RPTransactionScope(db))
                        {
                            usuarioBLL.ResetarSenha(usuario);
                            usuarioBLL.SaveChanges();
                            transaction.Complete();
                        }

                        // redireciona para index
                        this.AddFlashMessage("Verifique seu email!", FlashMessage.ALERT);
                        return RedirectToAction("Index");
                    }
                }
            }
            catch (Exception ex)
            {
                // adiciona mensagem de erro
                this.AddFlashMessage(RP.Util.Exception.Message.Get(ex), FlashMessage.ERROR);

                // redireciona para login
                return RedirectToAction("ForgotPassword");
            }

            return View(model);
        }