public override string Executar(object entidade)
{
if (entidade is CopiaDeAutorizacao)
{
CopiaDeAutorizacao copia = entidade as CopiaDeAutorizacao;
string msg = this.Executar(copia.AutorizacaoOrigem);
if (msg == null)
{
msg = this.Executar(copia.AutorizacaoDestino);
}
return(msg);
}
Autorizacao auth = entidade as Autorizacao;
IFachada <Profissional> fachada = new FachadaAdmWeb <Profissional>();
fachada.SalvaConexaoAtiva(this.conexao); // Manter conexão anterior
fachada.SalvaTransacaoAtiva(this.transacao); // Manter transação anterior
fachada.DefineTemQueFecharConexao(false); // Não fechar ao finalizar
Orgao aux = auth.Usuario.OrgaoAtual;
auth.Usuario.OrgaoAtual = null;
IList <Profissional> retorno = fachada.Consultar(auth.Usuario);
auth.Usuario.OrgaoAtual = aux;
if (retorno == null)
{
return("O Usuário informado não existe!");
}
return(null);
}
public ActionResult AlterarUsuario(AlterarOuSalvarUsuarioView dados)
{
#region Decidir se deve proseguir com a requisição
ActionResult urlRetorno = DecideUrlFormulários("/Profissional/AlterarUsuario", "ConsultarUsuario");
if (urlRetorno != null)
{
return(urlRetorno); // ação que deve ser retornada para o browser
}
#endregion
Profissional usuario = new Profissional();
usuario = dados.CriarModelo();
IFachada <Profissional> fachada = new FachadaAdmWeb <Profissional>();
string retorno = fachada.Alterar(usuario);
if (retorno != null)//se não retornar null, é porque ocorreu um erro de validação
{
ViewBag.Mensagem = retorno;
AlterarOuSalvarUsuarioView modelo = new AlterarOuSalvarUsuarioView();
modelo.PreencherDadosView(usuario);
dados.ActionDestino = "/Profissional/AlterarUsuario";
return(View("CadastrarUsuario", modelo));
}
ViewBag.Mensagem = "Alterado com sucesso!";
return(View("../Home/Index"));
}
public override string Executar(object entidade)
{
Profissional user = (Profissional)entidade;
IFachada <Profissional> fachada = new FachadaAdmWeb <Profissional>();
fachada.SalvaConexaoAtiva(this.conexao); // Manter conexão anterior
fachada.SalvaTransacaoAtiva(this.transacao); // Manter transação anterior
fachada.DefineTemQueFecharConexao(false); // Não fechar ao finalizar
IList <Profissional> codigoUsuarioRetonornado = fachada.Consultar(user);
if (codigoUsuarioRetonornado != null)
{
string retorna = "Usuário já cadastrado.";
return(retorna);
}
return(null);
}
public ActionResult ConsultarUsuario(string CodigoUsuario)
{
Profissional usuarioProcurado = new Profissional();
usuarioProcurado.Codigo = CodigoUsuario;
if (usuarioProcurado.Codigo == null || usuarioProcurado.Codigo.Trim() == "")
{
ViewBag.Mensagem = "Informe o código";
return(View("ConsultarUsuario"));
}
IFachada <Profissional> fachada = new FachadaAdmWeb <Profissional>();
IList <Profissional> retorno = fachada.Consultar(usuarioProcurado);
if (retorno == null)
{
ViewBag.Message = "Usuário " + usuarioProcurado.Codigo + " não existe";
return(View("ConsultarUsuario"));
}
AlterarOuSalvarUsuarioView view = new AlterarOuSalvarUsuarioView();
view.PreencherDadosView(retorno[0]);
view.ActionDestino = "/Profissional/AlterarUsuario";
return(View("CadastrarUsuario", view));
}
} // CopiarAutorizações
#region Métodos privados
private AutorizarUsuarioViewModel PreencheModel(AutorizarUsuarioViewModel model)
{
string copia = model.UsuarioCopia;
Autorizacao auth = new Autorizacao();
auth.Usuario = new Profissional();
auth.Usuario.Codigo = model.NomeUsuario;
auth.UsuarioAutorizando = usuario;
auth.OrgaoAutorizado = new Orgao();
if (auth.UsuarioAutorizando.Perfil != Perfil.GERENTE)
{
auth.OrgaoAutorizado.Sigla = usuario.OrgaoAtual.Sigla;
}
IList <Autorizacao> autorizacoes = new List <Autorizacao>();
autorizacoes.Add(auth);
model.PreencherDadosView(autorizacoes);
model.UsuarioLiberacao = usuario;
model = new FachadaAdmWeb <AutorizarUsuarioViewModel>().Consultar(model)[0];
model.UsuarioCopia = copia;
return(model);
}
public ActionResult ConsultarAplicativo(string CodigoAplicativo)
{
Aplicativo aplicativoProcurado = new Aplicativo();
aplicativoProcurado.Nome = CodigoAplicativo;
if (aplicativoProcurado == null || aplicativoProcurado.Nome.Trim() == "")
{
ViewBag.Mensagem = "Informe o codigo";
return(View("ConsultarAplicativo"));
}
IFachada <Aplicativo> fachada = new FachadaAdmWeb <Aplicativo>();
IList <Aplicativo> retorno = fachada.Consultar(aplicativoProcurado);
if (retorno == null)
{
ViewBag.Message = "Aplicativo" + aplicativoProcurado.Nome + "Não Existe";
return(View("ConsultarAplicativo"));
}
AlterarOuSalvarAplicativoView view = new AlterarOuSalvarAplicativoView();
view.PreencherDadosView(retorno[0]);
view.ActionDestinos = "/Aplicativo/AlterarAplicativo";
return(View("CadastrarAplicativo", view));
}
/// <summary>
/// Método responsável por cumprir o requisito de Cadastrar Aplicativo.
/// Quando chamado em GET - Retorna a tela de Cadastrar Aplicativo
/// Quando chamado em POST - realiza o Cadastro de Aplicativos
/// </summary>
/// <returns>A tela de Cadastrar Aplicativo (GET) ou A tela de Index
/// podendo ou não conter uma mensamge de erro (Post)</returns>
public ActionResult CadastrarAplicativo(AlterarOuSalvarAplicativoView dados)
{
#region Decidir se deve proseguir com a requisição
ActionResult urlRetorno = DecideUrlFormulários("/Aplicativo/CadastrarAplicativo");
if (urlRetorno != null)
{
return(urlRetorno); // ação que deve ser retornada para o browser
}
#endregion
Aplicativo aplicativo = new Aplicativo();
aplicativo = dados.CriarModelo();
IFachada <Aplicativo> fachada = new FachadaAdmWeb <Aplicativo>();
string retorno = fachada.Salvar(aplicativo);
if (retorno != null) //se não retornar null, é porque ocorreu um erro de validação
{
ViewBag.Mensagem = retorno;
dados.ActionDestinos = "/Aplicativo/CadastrarAplicativo";
return(View("CadastrarAplicativo", dados));
}
ViewBag.Mensagem = "Cadastrado com sucesso !";
return(View("../Home/Index"));
}
/// <summary>
/// Método responsável por cumprir o requisito de Autorizar Usuários Cadastrados em Aplicativos
/// previamente cadastrados.
/// Quando chamado em GET - Retorna a tela de Autorizar Usuário
/// Quando chamado em POST - Retorna a tela de Cadastrar
/// </summary>
/// <returns>A tela de Cadastrar Aplicativo (GET) ou A tela de Index
/// podendo ou não conter uma mensamge de erro (Post)</returns>
public ActionResult AutorizarUsuario(AutorizarUsuarioViewModel dados)
{
#region Decidir se deve proseguir com a requisição
AutorizarUsuarioViewModel model = new AutorizarUsuarioViewModel();
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
IList <Autorizacao> autorizacoes = new List <Autorizacao>();
dados.UsuarioLiberacao = usuario;
autorizacoes = dados.CriarModelo();
IFachada <Autorizacao> fachada = new FachadaAdmWeb <Autorizacao>();
string retorno;
if (Request["Salvar"] != null)
{
retorno = fachada.SalvarTodos(autorizacoes);
}
else if (Request["Alterar"] != null)
{
retorno = fachada.AlterarTodos(autorizacoes);
}
else if (Request["Inativar"] != null)
{
Autorizacao auxiliar = new Autorizacao();
auxiliar.OrgaoAutorizado = autorizacoes[0].OrgaoAutorizado;
auxiliar.Usuario = autorizacoes[0].Usuario;
retorno = fachada.Excluir(autorizacoes[0]);
}
else
{
retorno = "Opção Inválida";
}
if (retorno != null) // se retornar null, é porque ocorreu tudo bem
{
ViewBag.Mensagem = retorno;
model = PreencheModel(autorizacoes, model);
return(View(model));
}
ViewBag.Mensagem = "Autorizado com sucesso!";
return(View("../Home/Index"));
} // AutorizarUsuario
public override string Executar(object entidade)
{
Aplicativo aplicativo = (Aplicativo)entidade;
IFachada <Aplicativo> fachada = new FachadaAdmWeb <Aplicativo>();
fachada.SalvaConexaoAtiva(this.conexao); // Manter conexão anterior
fachada.SalvaTransacaoAtiva(this.transacao); // Manter transação anterior
fachada.DefineTemQueFecharConexao(false); // Não fechar ao finalizar
IList <Aplicativo> codigoAplicacaoRetonornado = fachada.Consultar(aplicativo);
if (codigoAplicacaoRetonornado != null)//se não retornar null, é porque ocorreu um erro de validação
{
string retorna = "Aplicação já cadastrada.";
return(retorna);
}
return(null);
}
public override string Executar(object entidade)
{
Autorizacao auth = entidade as Autorizacao;
IFachada <Profissional> fachada = new FachadaAdmWeb <Profissional>();
fachada.SalvaConexaoAtiva(this.conexao); // Manter conexão anterior
fachada.SalvaTransacaoAtiva(this.transacao); // Manter transação anterior
fachada.DefineTemQueFecharConexao(false); // Não fechar ao finalizar
auth.Usuario.OrgaoAtual = auth.OrgaoAutorizado;
IList <Profissional> retorno = fachada.Consultar(auth.Usuario);
if (retorno == null)
{
return("O Usuário " + auth.Usuario.Codigo + " não trabalha para o órgão " +
auth.Usuario.OrgaoAtual.Codigo + " (" + auth.Usuario.OrgaoAtual.Sigla + ")");
}
return(null);
}
public override string Executar(object entidade)
{
Autorizacao auth = entidade as Autorizacao;
Profissional user = null;
if (auth == null)
{
auth = new Autorizacao();
user = entidade as Profissional;
auth.Usuario = user;
auth.OrgaoAutorizado = user.OrgaoAtual;
}
IFachada <Orgao> fachada = new FachadaAdmWeb <Orgao>();
fachada.SalvaConexaoAtiva(this.conexao); // Manter conexão anterior
fachada.SalvaTransacaoAtiva(this.transacao); // Manter transação anterior
fachada.DefineTemQueFecharConexao(false); // Não fechar ao finalizar
IList <Orgao> retorno;
retorno = fachada.Consultar(auth.OrgaoAutorizado);
if (retorno == null)
{
return("Orgão informado (" + auth.OrgaoAutorizado.Sigla + ") não existe");
}
auth.OrgaoAutorizado = retorno[0];
if (user != null)
{
user.OrgaoAtual = retorno[0];
}
return(null);
}
public override string Executar(object entidade)
{
Autorizacao autorizacao = (Autorizacao)entidade;
IList <Autorizacao> retorno;
IFachada <Autorizacao> fachada = new FachadaAdmWeb <Autorizacao>();
fachada.SalvaConexaoAtiva(this.conexao); // Manter conexão anterior
fachada.SalvaTransacaoAtiva(this.transacao); // Manter transação anterior
fachada.DefineTemQueFecharConexao(false); // Não fechar ao finalizar
string rotina = autorizacao.Aplicativo.Menus[0].SubMenus[0].Descricao;
if (autorizacoesAnteriores.Contains(rotina))
{
return("Autorização em rotinas repetidas");
}
autorizacoesAnteriores.Add(rotina);
retorno = fachada.Consultar(autorizacao);
if (retorno != null)
{
string mensagem = "Rotinas já autorizados previamente: \n";
mensagem += "Usuário: " + retorno[0].Usuario.Codigo;
mensagem += " no órgão: " + retorno[0].OrgaoAutorizado.Sigla + " \n";
Aplicativo app = retorno[0].Aplicativo;
mensagem += rotina;
return(mensagem); // retorna o erro
}
return(null);
}
public override string Executar(object entidade)
{
Autorizacao auth = entidade as Autorizacao;
string chave = auth.OrgaoAutorizado.Sigla;
Aplicativo a = auth.Aplicativo;
if (!valoresQueJaforam.ContainsKey(chave))
{
valoresQueJaforam.Add(auth.OrgaoAutorizado.Sigla, new List <string>());
}
if (valoresQueJaforam[chave].Contains(a.Menus[0].SubMenus[0].Descricao)) // Rotina repetida??
{
return("Rotina " + a.Menus[0].SubMenus[0].Descricao + " está informada repetidamente " +
"no Órgão " + auth.OrgaoAutorizado.Sigla);
}
valoresQueJaforam[chave].Add(a.Menus[0].SubMenus[0].Descricao);
IFachada <Aplicativo> fachada = new FachadaAdmWeb <Aplicativo>();
fachada.SalvaConexaoAtiva(this.conexao); // Manter conexão anterior
fachada.SalvaTransacaoAtiva(this.transacao); // Manter transação anterior
fachada.DefineTemQueFecharConexao(false); // Não fechar ao finalizar
IList <Aplicativo> retorno = fachada.Consultar(a);
if (retorno == null)
{
return("Rotina " + a.Menus[0].SubMenus[0].Descricao + " é inválida");
}
return(null);
}
public override string Executar(object entidade)
{
Autorizacao auth = (Autorizacao)entidade;
SubMenu liberacao = auth.Aplicativo.Menus[0].SubMenus[0];
if (liberacao.Liberacao.UsuarioLiberacao.Perfil == Perfil.GERENTE)
{
return(null); // não é necessário verificar
}
if (auth == null)
{
return("Autorização Inválida");
}
IFachada <SubMenu> fachada = new FachadaAdmWeb <SubMenu>();
fachada.SalvaConexaoAtiva(this.conexao); // Manter conexão anterior
fachada.SalvaTransacaoAtiva(this.transacao); // Manter transação anterior
fachada.DefineTemQueFecharConexao(false); // Não fechar ao finalizar
IList <SubMenu> liberacoesDoLogado = fachada.Consultar(liberacao);
if (liberacoesDoLogado == null)
{
return("Permissões inválidas");
}
IDictionary <string, SubMenu> MapaPermisoes = new Dictionary <string, SubMenu>();
foreach (SubMenu s in liberacoesDoLogado)
{
MapaPermisoes.Add(s.Descricao, s);
}
Aplicativo a = auth.Aplicativo;
// Verificar se as autorizações obedecem as permissões de inclusão, exclusão e alteração
foreach (Menu m in a.Menus)
{
foreach (SubMenu s in m.SubMenus)
{
if (!MapaPermisoes.ContainsKey(s.Descricao)) // permissão diferente do autorizador??
{
return("Somente podem ser dadas as mesmas permissões do autorizador.\n O " +
"autorizador não tem permissão de acesso à rotina " + s.Descricao);
}
SubMenu auxiliar = MapaPermisoes[s.Descricao];
string msgAuxiliar = "O autorizador só pode autorizar permissões que já tenha.\n";
if (auxiliar.Liberacao.Permissoes.PermissaoIncluir == false &&
s.Liberacao.Permissoes.PermissaoIncluir == true)
{
return(msgAuxiliar + "O autorizador não tem permissão de inclusão na " +
"rotina " + s.Descricao);
}
if (auxiliar.Liberacao.Permissoes.PermissaoExcluir == false &&
s.Liberacao.Permissoes.PermissaoExcluir == true)
{
return(msgAuxiliar + "O autorizador não tem permissão de exclusão na " +
"rotina " + s.Descricao);
}
if (auxiliar.Liberacao.Permissoes.PermissaoAlterar == false &&
s.Liberacao.Permissoes.PermissaoAlterar == true)
{
return(msgAuxiliar + "O autorizador não tem permissão de alteração na " +
"rotina " + s.Descricao);
}
} // foreach SubMenu
} // foreach Menu
return(null);
}
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
