public ActionResult ConsultarUsuario(AutorizarUsuarioViewModel model)
        {
            #region Decidir se deve proseguir com a requisição
            Autorizacao  auth;
            ActionResult urlRetorno = DecideUrlFormulários("/Autorizacao/AutorizarUsuario", model);
            if (urlRetorno != null)
            {
                if (usuario != null) // Usuario preenchido com os dados da seção na superclasse
                {
                    model = PreencheModel(model);
                }
                return(urlRetorno); // ação que deve ser retornada para o browser
            }

            #endregion

            IFachada <Profissional> fachada = new FachadaAdmWeb <Profissional>();
            fachada.DefineTemQueFecharConexao(false);

            IList <Profissional> resultados = this.ConsultaUsuarioNoBanco(model, fachada);


            if (resultados == null || resultados.Count == 0)
            {
                ViewBag.Mensagem = "Nenhum Usuário encontrado (" + model.NomeUsuario.Trim() + ")";

                // Por padrão, fecha ao finalizar a transação
                fachadaVM = new FachadaAdmWeb <AutorizarUsuarioViewModel>();
                fachadaVM.SalvaConexaoAtiva(fachada.RetornaConexaoAtiva());     // manter conexão
                fachadaVM.SalvaTransacaoAtiva(fachada.RetornaTransacaoAtiva()); // manter trasação

                model = PreencheModel(model);
            }
            else if (resultados.Count == 1)
            {
                auth                    = new Autorizacao();
                auth.Usuario            = resultados[0];
                auth.UsuarioAutorizando = usuario;

                IFachada <Autorizacao> fachadaAuth = new FachadaAdmWeb <Autorizacao>();
                fachadaAuth.SalvaConexaoAtiva(fachada.RetornaConexaoAtiva());     // manter conexao
                fachadaAuth.SalvaTransacaoAtiva(fachada.RetornaTransacaoAtiva()); // manter transacao
                fachadaAuth.DefineTemQueFecharConexao(false);                     // Não deve fechar

                IList <Autorizacao> autorizacoes = fachadaAuth.Consultar(auth);
                if (autorizacoes == null)
                {
                    autorizacoes = new List <Autorizacao>();
                    if (auth.UsuarioAutorizando.Perfil == Perfil.AUTORIZADOR)
                    {
                        auth.OrgaoAutorizado = auth.UsuarioAutorizando.OrgaoAtual;
                    }
                    autorizacoes.Add(auth);
                }

                // Por padrão, fecha ao finalizar a transação
                fachadaVM = new FachadaAdmWeb <AutorizarUsuarioViewModel>();
                fachadaVM.SalvaConexaoAtiva(fachadaAuth.RetornaConexaoAtiva());     // manter conexão
                fachadaVM.SalvaTransacaoAtiva(fachadaAuth.RetornaTransacaoAtiva()); // manter trasação


                model = PreencheModel(autorizacoes, model);
            }



            return(View("AutorizarUsuario", model));
        }
        public ActionResult CopiarAutorizacao(CopiarAutorizacaoViewModel model, AutorizarUsuarioViewModel modelRetorno)
        {
            #region Decidir se deve proseguir com a requisição

            ActionResult urlRetorno = DecideUrlFormulários("/Autorizacao/AutorizarUsuario", modelRetorno);
            if (urlRetorno != null)
            {
                if (usuario != null) // Usuario preenchido com os dados da seção na superclasse
                {
                    modelRetorno = PreencheModel(modelRetorno);
                }
                return(urlRetorno); // ação que deve ser retornada para o browser
            }
            #endregion

            modelRetorno.UsuarioLiberacao = model.UsuarioLiberacao = usuario;

            IList <Autorizacao> autorizacoes = modelRetorno.CriarModelo();

            CopiaDeAutorizacao copia = model.CriarModelo();

            IList <CopiaDeAutorizacao>    retorno = new List <CopiaDeAutorizacao>();
            IFachada <CopiaDeAutorizacao> fachada = new FachadaAdmWeb <CopiaDeAutorizacao>();
            fachada.DefineTemQueFecharConexao(false); // manter transação e conexão aberta

            string msgValidacao = fachada.ConsultarComValidacao(copia, retorno);


            if (msgValidacao != null)
            {
                ViewBag.Mensagem = msgValidacao;

                fachadaVM = new FachadaAdmWeb <AutorizarUsuarioViewModel>();
                fachadaVM.SalvaConexaoAtiva(fachada.RetornaConexaoAtiva());     // mantém conexão anterior
                fachadaVM.SalvaTransacaoAtiva(fachada.RetornaTransacaoAtiva()); // mantém transação anterior


                return(View("AutorizarUsuario", PreencheModel(autorizacoes, modelRetorno)));
            }
            else if (retorno == null || retorno.Count == 0)
            {
                fachadaVM = new FachadaAdmWeb <AutorizarUsuarioViewModel>();    // Por padrão fecha a conexão
                fachadaVM.SalvaConexaoAtiva(fachada.RetornaConexaoAtiva());     // mantém conexão anterior
                fachadaVM.SalvaTransacaoAtiva(fachada.RetornaTransacaoAtiva()); // mantém transação anterior

                ViewBag.Mensagem = "Não há validações para copiar";


                return(View("AutorizarUsuario", PreencheModel(autorizacoes, modelRetorno)));
            }



            fachada.DefineTemQueFecharConexao(true); // a próxima operação é a última
            msgValidacao = fachada.SalvarTodos(retorno);

            if (msgValidacao != null)
            {
                ViewBag.Mensagem = msgValidacao;
            }
            else
            {
                ViewBag.Mensagem = "Autorizações copiadas com sucesso.";
            }

            //return View("AutorizarUsuario", PreencheModel(autorizacoes, modelRetorno));
            return(View("../Home/Index"));
        } // CopiarAutorizações