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 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 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));
}
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));
}
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));
}
