public JsonResult AjaxVerificatroca(string idUsuario)
 {
     var ret = new UsuarioRepository();
        int valor = ret.VerificaTroca(int.Parse(idUsuario));
        return Json(valor, JsonRequestBehavior.AllowGet);
 }
        //
        // GET: /Login/
        public ActionResult EncerrarAcesso()
        {
            try
            {
                var log = new LogRepository(); // LOG: LOG no Lougout
                int _idUsuario = new UsuarioRepository().GetUsuario(Session["NomeUsuario"].ToString()).ID;
                log.RegistrarLOG(int.Parse(Session["IdCliente"].ToString()), int.Parse(Session["IdServico"].ToString()), 0, _idUsuario, 2, 3, 0, 0, Session["NomeUsuario"].ToString());
                log.RegistrarLOGDetalhe(3, Session["NomeUsuario"].ToString());

                //TODO: 07/03/2016 Novo metodo usando a proc LiberaUsuarioLogado
                new UsuarioRepository().LiberaUsuarioLogado(IdServico_Atual, UsuarioAtual.ID);

                AbandonarSessao();
                FormsAuthentication.SignOut();
                this.SingOut();
            }
            catch (Exception ex) { ModelState.AddModelError("error", ex); TempData["ViewData"] = ViewData; }

            return RedirectToAction("Index");
        }
        public ActionResult Alterar(FormCollection frm)
        {
            try
            {
                if (frm["login"].ToString() != frm["loginantes"].ToString()) //Se realmente foi alterado o login ai sim executa o VerificaLoginDisponivel
                {
                    var _ret = new UsuarioRepository().VerificaLoginDisponivel(UsuarioAtual.ID, frm["login"].ToString());
                    if (_ret.CodigoRetorno == 1)
                    {
                        throw new Exception(_ret.Mensagem);
                    }
                }

                var alt = new UsuarioRepository();

                int trocar = (frm["trocar"] != null) ? int.Parse(frm["trocar"].ToString()) : 0;
                var ret = alt.AlterarUsuario(int.Parse(frm["idusuario"].ToString())
                    , UsuarioAtual.ID
                    , frm["nome"].ToString()
                    , frm["login"].ToString()
                    , frm["email"].ToString()
                    , frm["senha"].ToString()
                    , trocar
                    , int.Parse(frm["SelPerfil"].ToString())
                    , int.Parse(frm["idservico"].ToString()));
                    //, int.Parse(frm["trocar"].ToString()));
                if (ret.CodigoRetorno < 0)
                {
                    throw new Exception(ret.Mensagem);
                }
                TempData["Msg"] = "Gravado com sucesso.";
                ViewBag.ListaUsuarios = TempData["LstUsuarios"];
                CarregaPerfil(int.Parse(frm["idservico"].ToString()));
                ViewBag.IdPerfil = int.Parse(frm["SelPerfil"].ToString());
            }
            catch(Exception ex)
            {
                TempData["Error"] = ex.Message;
            }
            ViewBag.Usuario = new UsuarioRepository().GetUsuarioID(int.Parse(frm["idusuario"].ToString()));
            return View("EditarUsuario");
        }
        public ActionResult TrocarSenha(FormCollection frm)
        {
            try
            {
                var _cripto = new Criptografia();
                var _utils = new Util();

                string senha_atual = _cripto.Executar(frm["txt_senha_atual"].Trim().ToString(), _utils.ChaveCripto, Criptografia.TipoNivel.Baixo, Criptografia.TipoAcao.Encriptar, Criptografia.TipoCripto.Números);
                string senha_nova =  _cripto.Executar(frm["txt_senha_nova"].Trim().ToString(), _utils.ChaveCripto, Criptografia.TipoNivel.Baixo, Criptografia.TipoAcao.Encriptar, Criptografia.TipoCripto.Números);

                var ret = new UsuarioRepository().AtualizarSenha(UsuarioAtual.ID, senha_atual, senha_nova);
                if (ret.CodigoRetorno >= 0)
                {
                    TempData["Msg"] = ret.Mensagem.ToString();
                    return RedirectToRoute("Principal");
                    //return View("TrocaSenha");
                }
                else
                {
                    throw new Exception(ret.Mensagem.ToString());
                }
            }
            catch (Exception ex)
            {
                //TempData["Error"] = ex.Message;
                TempData["Msg"] = ex.Message;
                //ViewBag.MsgError = ex.Message;
                return View("TrocaSenha");
            }
        }
 public JsonResult AjaxVerificarCPF(string cpf)
 {
     var RetCPF = new UsuarioRepository().VerificaCPFDisponivel(UsuarioAtual.ID, decimal.Parse(cpf.ToString()));
     return Json(RetCPF, JsonRequestBehavior.AllowGet);
 }
 public JsonResult AjaxVerificarLOGIN(string login)
 {
     var Ret = new UsuarioRepository().VerificaLoginDisponivel(UsuarioAtual.ID, login);
     return Json(Ret, JsonRequestBehavior.AllowGet);
 }
 public JsonResult AjaxReativarUsuario(string cpf)
 {
     //Usuario que esta com status de excluido vai ser reativado
     var Ret = new UsuarioRepository().ReativarUsuarioExcluido(UsuarioAtual.ID, decimal.Parse(cpf));
     return Json(Ret, JsonRequestBehavior.AllowGet);
 }
 public ActionResult EditarServico(int idUsuario)
 {
     ViewBag.Usuario = new UsuarioRepository().GetUsuarioID(idUsuario);
     Session["IdNovoUsuario"] = idUsuario;
     var usuRep = new UsuarioRepository();
     var _lista = usuRep.ListaClienteServicos(idUsuario);
     ViewBag.Lista = _lista;
     Session["TipoAcao"] = "4";
     ViewBag.StGravado = 4; //Deshabilita o campo Login
     CarregarCombos();
     return View("EditarServico");
 }
 public ActionResult VoltarListaUsuarios()
 {
     var f = (Filtro)Session["Filtro"];
     var usu = new UsuarioRepository().GetUsuarioCadastro(f.Tipo, f.Condicao, f.IdClienteAtual, f.Pesquisa, f.IdUsuarioAtual);
     ViewBag.ListaUsuarios = usu;
     return View("ManutencaoUsuario");
 }
 public JsonResult AjaxExcluirUsuario(int idUsuario, int idServico, int idUsuarioAtual)
 {
     var retorno = new UsuarioRepository().ExcluirUsuario(idUsuario, idServico, idUsuarioAtual);
     return Json(retorno, JsonRequestBehavior.AllowGet);
 }
        public ActionResult ListaUsuarios(FormCollection frm)
        {
            int _tipo = int.Parse(frm["selTipo"].ToString());
            int _condicao = int.Parse(frm["selCondicao"].ToString());
            string _txtpesquisa = frm["txtpesquisa"].ToString();

            int idclienteAtual = new ClienteRepository().GetClienteServicoPorNome(Session["NomeServico"].ToString(), Session["NomeCliente"].ToString()).IdCliente;

            Session["Filtro"] = new Filtro() { Tipo = _tipo, Condicao = _condicao, IdClienteAtual = idclienteAtual, Pesquisa = _txtpesquisa, IdUsuarioAtual = UsuarioAtual.ID };
            var usu = new UsuarioRepository().GetUsuarioCadastro(_tipo, _condicao, idclienteAtual, _txtpesquisa, UsuarioAtual.ID);
            ViewBag.ListaUsuarios = usu;
            return View("ManutencaoUsuario");
        }
 public ActionResult ListaDetalheUsuario(int idUsuarioDetalhe)
 {
     var detalhe_usu = new UsuarioRepository().GetDetalheUsuario(idUsuarioDetalhe, UsuarioAtual.ID);
     ViewBag.ListaDetalheUsuario = detalhe_usu.Take(1).ToList();
     ViewBag.ListaDetalheClienteServico = detalhe_usu;
     return View("DetalheUsuario");
 }
        public ActionResult Incluir(FormCollection frm)
        {
            try{

                var Ret = new UsuarioRepository().VerificaLoginDisponivel(UsuarioAtual.ID, frm["login"].ToString());
                var RetCPF = new UsuarioRepository().VerificaCPFDisponivel(UsuarioAtual.ID, decimal.Parse(frm["cpf"].ToString()));

                if ((Session["TipoAcao"] != null) && (Session["TipoAcao"] == "4")) { Ret.CodigoRetorno = 0; RetCPF.CodigoRetorno = 0; }

                if(Ret.CodigoRetorno == 1 || RetCPF.CodigoRetorno==1){
                    var _usu = new Usuario();

                    _usu.CPF = frm["cpf"].ToString();
                    _usu.NomeCompleto = frm["nome"].ToString();
                    _usu.NomeUsuario = frm["login"].ToString();
                    _usu.Senha = frm["senha"].ToString();
                    _usu.TipoAcao = 1;
                    _usu.ClienteID = int.Parse(frm["SelCliente"].ToString());
                    _usu.ServicoID = int.Parse(frm["SelServico"].ToString());
                    _usu.PerfilID = int.Parse(frm["SelPerfil"].ToString());
                    _usu.Situacao = int.Parse(frm["SelSituacao"].ToString());
                    _usu.Email = frm["email"].ToString();

                    ViewBag.Usuario = _usu;
                    //CarregarCombos();
                    if (RetCPF.CodigoRetorno == 1)
                        throw new Exception(RetCPF.Mensagem);
                    else
                        throw new Exception(Ret.Mensagem);
                }

                var usu = new Usuario();

                 usu.CPF = frm["cpf"].ToString();
                 usu.NomeCompleto = frm["nome"].ToString();
                 usu.NomeUsuario = frm["login"].ToString();
                 usu.Senha = frm["senha"].ToString();

                 if ((Session["TipoAcao"] != null) && (Session["TipoAcao"] != "4")){
                     usu.TipoAcao = 1;
                 }
                 else { usu.TipoAcao = 4; }

                 usu.ClienteID = int.Parse(frm["SelCliente"].ToString());
                 usu.ServicoID = int.Parse(frm["SelServico"].ToString());
                 usu.PerfilID  = int.Parse(frm["SelPerfil"].ToString());
                 usu.Situacao  = int.Parse(frm["SelSituacao"].ToString());
                 usu.Email     = frm["email"].ToString();

                 if (frm["trocar"] != null) usu.TrocarSenha = int.Parse(frm["trocar"].ToString());

                 var usuRep = new UsuarioRepository();

                //Incluir um novo Usuario ou um novo servico a este usuario
                 var Retorno = usuRep.IncluirUsuario(usu);
                 if (Retorno.CodigoRetorno == -1){
                     Session["TipoAcao"] = "1";
                     ViewBag.StGravado = 1;
                     throw new Exception(Retorno.Mensagem);
                 }
                 if ((Retorno.CodigoRetorno == -2) || (Retorno.CodigoRetorno == -3)){
                     Session["TipoAcao"] = "4";
                     ViewBag.StGravado = 4;
                     ViewBag.Usuario = new UsuarioRepository().GetUsuario(usu.NomeUsuario);
                     ViewBag.Lista = usuRep.ListaClienteServicos((int)Session["IdNovoUsuario"]);
                     throw new Exception(Retorno.Mensagem);
                 }

                 ViewBag.Usuario = new UsuarioRepository().GetUsuario(usu.NomeUsuario);
                 Session["IdNovoUsuario"] = (int)Retorno.CodigoRetorno;
                 var _lista = usuRep.ListaClienteServicos((int)Retorno.CodigoRetorno);  //Apos gravar sem erro retorna o codigo do novo usuario para CodigoRetorno  //(usu.ID);
                 ViewBag.Lista = _lista;

                 ViewBag.Msg = "Gravado com sucesso.";
                 TempData["Msg"] = "Gravado com sucesso.";
                 Session["TipoAcao"] = "4";
                 ViewBag.StGravado = 4; //Deshabilita o campo Login
            }
            catch(Exception ex){
                CarregarCombos();
                ViewBag.Error = ex.Message;
                TempData["Error"] = ex.Message;
            }
            CarregarCombos();
            return View("Novo");
        }
        public ActionResult Autenticar(LoginViewModel model, string returnUrl)
        {
            var log = new LogRepository();

            AbandonarSessao();

            if (ModelState.IsValid)
            {
                try
                {
                    var _cripto = new Criptografia();
                    var _utils = new Util();
                    string _senha = _cripto.Executar(model.Senha.Trim().ToString(), _utils.ChaveCripto, Criptografia.TipoNivel.Baixo, Criptografia.TipoAcao.Encriptar, Criptografia.TipoCripto.Números);

                    bool valido = this._usuarioService.ValidarUsuario(model.NomeUsuario, _senha);

                    if (valido)
                    {
                        // TODO:14/04/2016
                        var ret = new UsuarioRepository().VerificaServicoPerfil(model.NomeUsuario, _senha);
                        if (ret.CodigoRetorno != 0)
                        {
                            //return RedirectToRoute("Logout", new { msg = ret.Mensagem });
                            return RedirectToAction("Index", new { msg = ret.Mensagem });
                        }

                        //TODO: Andre 27/04/2016 int _idUsuario = new UsuarioRepository().GetUsuario(model.NomeUsuario).ID;
                        Session["ClsUsuario"] = (Usuario)new UsuarioRepository().GetUsuarioSessao(model.NomeUsuario);

                        bool _autenticado = this._authenticatioService.AuthenticateUser(this.HttpContext, model.NomeUsuario, model.Senha, model.ManterConectado);
                        if (_autenticado)
                        {
                            Session["NomeUsuario"] = model.NomeUsuario;

                            //TODO: 07/03/2016 Verifica se foi selecionado o Relembre-me e cria um cokie para armazenar o nome do usuário.
                            if (Request.Cookies["Login"] == null)
                            {
                                if (model.ManterConectado)
                                {
                                    HttpCookie cokLogin = new HttpCookie("Login");
                                    cokLogin["username"] = model.NomeUsuario;
                                    cokLogin["lembrarnome"] = "sim";
                                    cokLogin.Expires = DateTime.Now.AddDays(1d);
                                    Response.Cookies.Add(cokLogin);
                                }
                            }
                            else
                            {
                                if (model.ManterConectado)
                                {
                                    HttpCookie cokLogin = new HttpCookie("Login");
                                    cokLogin["username"] = model.NomeUsuario;
                                    cokLogin["lembrarnome"] = "sim";
                                    Response.Cookies.Set(cokLogin);
                                }
                                if (model.ManterConectado == false)
                                {
                                    HttpCookie cokLogin = new HttpCookie("Login");
                                    cokLogin["username"] = "";
                                    cokLogin["lembrarnome"] = "nao";
                                    Response.Cookies.Set(cokLogin);
                                }
                            }

                            var cli = new ClienteRepository();
                            cli.PrimeiroClienteServicoPadrao(model.NomeUsuario, model.Senha);

                            if (cli.Servico == null)
                            {
                                return RedirectToAction("Index", new { msg = "Nenhum Cliente e Serviço Padrão selecionado. Por favor,  entre em contato com o administrador do sistema." });
                                //TempData["Error"] = "Nenhum Cliente e Serviço Padrão selecionado...";
                            }

                            Session["IdCliente"] = cli.TCliente.ID;
                            Session["NomeCliente"] = cli.TCliente.Descricao;
                            Session["NomeServico"] = cli.Servico;
                            Session["IdServico"] = cli.idServico;//aqui

                            //TODO: Andre 10/05/2016
                            var usu = new Usuario(){ ID=UsuarioAtual.ID, ServicoID=cli.idServico, ClienteID=cli.TCliente.ID};
                            var retorno = new LicensaRepository().CarregaLicensa(usu, 1);
                            if (retorno.CodigoRetorno < 0)
                            {
                                ViewBag.Atencao = retorno.Mensagem;
                                TempData["Msg"] = retorno.Mensagem;
                            }
                            else
                            {
                                // LOG: Login Autenticado -- Cesar
                                log.RegistrarLOG(cli.TCliente.ID, cli.idServico, 0, 0, 1, 1, 0, 0, model.NomeUsuario);
                                log.RegistrarLOGDetalhe(1, model.NomeUsuario);

                                return RedirectToRoute(new { action = "../Home", controller = "", area = "" });// Redirect (returnUrl ?? FormsAuthentication.DefaultUrl);

                            }

                        }

                        FormsAuthentication.SetAuthCookie(model.NomeUsuario, false);
                    }
                }
                catch (Exception ex) {
                    //ModelState.AddModelError("Error", ex.Message);
                    //LOG: Login Não Autenticado
                    log.RegistrarLOG(0, 0, 0, 0, 1, 2, 0, 0, model.NomeUsuario);
                    log.RegistrarLOGDetalhe(2, model.NomeUsuario);
                    ViewBag.Atencao = ex.Message;
                    TempData["Msg"] = ex.Message;
                }
            }
            return View("Index");
        }
 public JsonResult AjaxVerificaLoginDisponivel(string nomeUsuario)
 {
     var retorno = new UsuarioRepository().VerificaLoginDisponivel(UsuarioAtual.ID, nomeUsuario);
     return Json(retorno, JsonRequestBehavior.AllowGet);
 }
        public ActionResult Incluir(FormCollection frm)
        {
            var Retorno = new Retorno();

            try
            {

                var cli = new Cliente()
                {
                    TipoAcao=1,
                    CPF_CNPJ = Decimal.Parse(frm["cpfcnpj"].ToString()),
                    Descricao = frm["nome"].ToString(),
                    Status = frm["status"]==null ? 0 : int.Parse(frm["status"].ToString()),
                    QtdeUsuario = int.Parse(frm["qtdusu"].ToString()),
                    EmailPrincipal = frm["email"].ToString(),
                    idUsuarioAtual = UsuarioAtual.ID
                };
                ViewBag.Cliente = cli;
                var RetCPF = new UsuarioRepository().VerificaCPFDisponivel(UsuarioAtual.ID, decimal.Parse(frm["cpfcnpj"].ToString()));
                if (RetCPF.CodigoRetorno == 1)
                    throw new Exception(RetCPF.Mensagem);

                var cliRet = new ClienteRepository();
                Retorno = cliRet.Incluir(cli);
                if (Retorno.CodigoRetorno < 0)
                {
                    throw new Exception(Retorno.Mensagem);
                }
                TempData["Msg"] = Retorno.Mensagem;
                return RedirectToAction("Index", new { msg = Retorno.Mensagem });
            }
            catch(Exception ex)
            {
                ViewBag.Error = ex.Message;
                TempData["Error"] = ex.Message;
                return View("Create",frm);
                //throw new Exception(ex.Message);
            }
        }
 public JsonResult BloquearUsuario(string idUsuBloqueado,string idServico)
 {
     var retorno = new UsuarioRepository().BloquearUsuario(int.Parse(idServico), int.Parse(idUsuBloqueado), UsuarioAtual.ID);
        return Json(retorno, JsonRequestBehavior.AllowGet);
 }