public ActionResult DeleteConfirmed(int id)
{
var sessaoValida = validaSessaoPermissoes();
if (sessaoValida != null)
{
return(sessaoValida);
}
Funcionalidade funcionalidade = _funcionalidadeRepositorio.getFuncionalidadePorId(id);
string classificacaoPai = _funcionalidadeRepositorio.getFuncionalidadePorId((int)funcionalidade.id_pai) != null?_funcionalidadeRepositorio.getFuncionalidadePorId((int)funcionalidade.id_pai).classificacao : string.Empty;
try
{
if (ModelState.IsValid)
{
_funcionalidadeRepositorio.deletarFuncionalidade(id);
_funcionalidadeRepositorio.salvar();
atualizaFuncionalidadesFilhas((int)funcionalidade.id_pai, classificacaoPai);
_funcionalidadeRepositorio.salvar();
return(RedirectToAction("Index"));
}
}
catch (DataException ex)
{
ModelState.AddModelError("", "Erro ao deletar: " + ex.Message);
}
return(View(viewName: "Delete", model: funcionalidade));
}
private void btnSave_Click(object sender, EventArgs e)
{
Funcionalidade f = new Funcionalidade()
{
Nome = tbName.Text,
Url = tbUrl.Text,
IdPerfil = p.Id
};
FuncionalidadeDAO dao = new FuncionalidadeDAO();
dao.Add(f);
p.Funcionalidades.Add(f);
PerfilDAO dao2 = new PerfilDAO();
dao2.Edit(p);
listFuncionalidades.Clear();
listFuncionalidades.Columns.Insert(0, "Nome", 300, HorizontalAlignment.Center);
listFuncionalidades.Columns.Insert(1, "Url", 300, HorizontalAlignment.Center);
FuncionalidadeDAO dao3 = new FuncionalidadeDAO();
foreach (Funcionalidade funcionalidade in dao3.Select())
{
if (funcionalidade.IdPerfil == p.Id)
{
ListViewItem listItem = listFuncionalidades.Items.Add(funcionalidade.Nome);
listItem.SubItems.Add(new ListViewItem.ListViewSubItem(null, funcionalidade.Url));
}
}
}
public void Historia()
{
historia = new Historia("obter promessas")
.Para("poder gerar informações")
.Enquanto("serviço de promessas")
.EuQuero("pegar as novas promessas feitas");
}
public ActionResult Edit([Bind(Include = "id,nome,tipo,link,id_pai,nivel,classificacao")] Funcionalidade funcionalidade)
{
var sessaoValida = validaSessaoPermissoes();
if (sessaoValida != null)
{
return(sessaoValida);
}
try
{
if (ModelState.IsValid)
{
if (funcionalidade.id_pai == null)
{
funcionalidade.id_pai = 0;
}
_funcionalidadeRepositorio.atualizaFuncionalidade(funcionalidade);
_funcionalidadeRepositorio.salvar();
return(RedirectToAction("Index"));
}
}
catch (DataException)
{
ModelState.AddModelError("", "Não foi possível salvar! Tente novamente.");
}
return(View(funcionalidade));
}
public ActionResult Index(FormCollection f)
{
try
{
App.FuncionalidadeService.SetCurrentFilter(f, "Funcionalidade");
FuncionalidadeViewModel funcionalidadeViewModel = new FuncionalidadeViewModel();
List <Funcionalidade> list = new List <Funcionalidade>();
Funcionalidade obj = GetFiltro(f);
list = App.FuncionalidadeService.Buscar(obj);
var viewModels = funcionalidadeViewModel.GerarViewModels(list);
if (list.Count == 0)
{
ExibirMensagemErro("Registros não encontrados.");
}
return(View("Index", viewModels));
}
catch (Exception ex)
{
ExibirMensagemErro("Não foi possível concluir a consulta. " + ex.Message);
return(View("Index"));
}
}
/// <summary>
/// Salvar os dados do formulário. Serve tanto para cadastro quanto para edição
/// </summary>
/// <param name="funcionalidade">Funcionalidade a ser criada/alterada</param>
/// <returns></returns>
public IActionResult Salvar(Funcionalidade funcionalidade)
{
try
{
var mensagem = "";
if (funcionalidade.id != null)
{
unitOfWork.funcionalidadeService.alterar(funcionalidade);
mensagem = "Funcionalidade alterada com sucesso";
}
else
{
funcionalidade = unitOfWork.funcionalidadeService.adicionar(funcionalidade);
mensagem = "Funcionalidade incluída com sucesso";
}
unitOfWork.salvar();
return(RedirectToAction("Index", new { mensagem = mensagem, tipoMensagem = TipoMensagem.Sucesso }));
}
catch (Exception e)
{
exibirMensagem("Ops...", e.Message, TipoMensagem.Erro);
return(View("Form", funcionalidade));
}
}
/// <summary>
/// Metodo que retorna todas as funcionalidades de um usuario
/// </summary>
/// <param name="Usuario"></param>
/// <returns></returns>
public List <Funcionalidade> ObterFuncionalidade(string Usuario)
{
//Instânciando a Lista Tipada.
List <Funcionalidade> objFuncionalidadeColecao = new List <Funcionalidade>();
Database db = Microsoft.Practices.EnterpriseLibrary.Data.DatabaseFactory.CreateDatabase("BancoSistema");
using (DbCommand dbCommand = db.GetStoredProcCommand("STPCRJFuncionalidadeAplicacao02"))
{
//Parâmetros da Stored Procedure.
db.AddInParameter(dbCommand, "p_Usuario", DbType.String, Usuario);
using (DataSet ds = db.ExecuteDataSet(dbCommand))
{
if (ds != null && ds.Tables.Count > 0)
{
DataTable dtFuncionalidade = ds.Tables[0];
for (int i = 0; i < dtFuncionalidade.Rows.Count; i++)
{
Funcionalidade objFuncionalidade = PopularEntidade(dtFuncionalidade, i);
objFuncionalidadeColecao.Add(objFuncionalidade);
objFuncionalidade = null;
}
}
}
}
return(objFuncionalidadeColecao);
}
public async Task <IActionResult> Edit(int id, [Bind("Id,Nome,Descricao")] Funcionalidade funcionalidade)
{
if (id != funcionalidade.Id)
{
return(NotFound());
}
if (!ModelState.IsValid)
{
return(View(funcionalidade));
}
try
{
_funcionalidadeService.Atualizar(funcionalidade);
}
catch (DbUpdateConcurrencyException)
{
if (!FuncionalidadeExists(funcionalidade.Id).Result)
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
public void Salvar([FromBody] AcessoViewModel acessosViewModel)
{
this.acessoFuncionalidadeRepositorio
.ApagarAcessosDoAtor(acessosViewModel.PapelId, acessosViewModel.AtorId);
foreach (var funcionalidade in acessosViewModel.Funcionalidades)
{
if (funcionalidade.Marcado == false)
{
continue;
}
var acesso = new AcessoFuncionalidade
{
AtorId = acessosViewModel.AtorId,
Papel = Papel.FromInt32(acessosViewModel.PapelId),
Funcionalidade = Funcionalidade.FromInt32(funcionalidade.Id)
};
this.acessoFuncionalidadeRepositorio.Salvar(acesso);
}
this.logarAcaoSistema.Execute(
TipoTrilha.Alteracao,
"Segurança de Funcionalidade",
"Acesso às funcionalidades foi alterado para o papelId: " + acessosViewModel.PapelId + " e atorId: " + acessosViewModel.AtorId);
}
public ActionResult Edit(int id, [Bind("IdFuncionalidade,Nome,Descricao,IdPerfil")] Funcionalidade funcionalidade)
{
if (id != funcionalidade.IdFuncionalidade)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(funcionalidade);
_context.SaveChanges();
TempData["Message"] = "Funcionalidade alterada com sucesso";
}
catch (DbUpdateConcurrencyException)
{
if (!FuncionalidadeExists(funcionalidade.IdFuncionalidade))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
TempData["MessageError"] = "Ocorreu um erro ao editar funcionalidade";
return(View(funcionalidade));
}
public void CriandoCenariodeAcessoAnonimo()
{
ColecaoPersistencia colecao = new ColecaoPersistencia();
// INÍCIO: A exclusão do ambiente irá efetuar o processo de limpeza automática dos registros associados (cascata)
SuperGrupo objSuperGrupo = new SuperGrupo();
objSuperGrupo.Titulo = "Administrativo (Homologação)";
objSuperGrupo.Habilitado = Valor.Ativo;
objSuperGrupo.Ambiente = this.AmbienteEnvolvido;
AcessoController.Manter(objSuperGrupo, "usuario.teste", colecao);
Grupo objGrupo = new Grupo();
objGrupo.Titulo = "Segurança (Homologação)";
objGrupo.Habilitado = Valor.Ativo;
objGrupo.SuperGrupo = objSuperGrupo;
AcessoController.Manter(objGrupo, "usuario.teste", colecao);
Funcionalidade objFuncionalidade = new Funcionalidade();
objFuncionalidade.Titulo = "Manutenção de Usuários (Homologação)";
objFuncionalidade.Habilitado = Valor.Ativo;
objFuncionalidade.Grupo = objGrupo;
AcessoController.Manter(objFuncionalidade, "usuario.teste", colecao);
// FIM: A exclusão do ambiente irá efetuar o processo de limpeza automática dos registros associados (cascata)
colecao.Persistir();
Assert.IsTrue(Checar.MaiorQue(this.AmbienteEnvolvido.ID));
}
public void CriandoCenariodeAcessoAnonimo()
{
ColecaoPersistencia colecao = new ColecaoPersistencia();
// INÍCIO: A exclusão do ambiente irá efetuar o processo de limpeza automática dos registros associados (cascata)
SuperGrupo objSuperGrupo = new SuperGrupo();
objSuperGrupo.Titulo = "Administrativo (Homologação)";
objSuperGrupo.Habilitado = Valor.Ativo;
objSuperGrupo.Ambiente = this.AmbienteEnvolvido;
AcessoController.Manter(objSuperGrupo, "usuario.teste", colecao);
Grupo objGrupo = new Grupo();
objGrupo.Titulo = "Segurança (Homologação)";
objGrupo.Habilitado = Valor.Ativo;
objGrupo.SuperGrupo = objSuperGrupo;
AcessoController.Manter(objGrupo, "usuario.teste", colecao);
Funcionalidade objFuncionalidade = new Funcionalidade();
objFuncionalidade.Titulo = "Manutenção de Usuários (Homologação)";
objFuncionalidade.Habilitado = Valor.Ativo;
objFuncionalidade.Grupo = objGrupo;
AcessoController.Manter(objFuncionalidade, "usuario.teste", colecao);
// FIM: A exclusão do ambiente irá efetuar o processo de limpeza automática dos registros associados (cascata)
colecao.Persistir();
Assert.IsTrue(Checar.MaiorQue(this.AmbienteEnvolvido.ID));
}
public IEnumerable <Acao> FetchByUserAndFunctionality(Usuario user, Funcionalidade functionality)
{
return(DataHelper.List <Acao>("PR_GET_ACAO_POR_USUARIO_RECURSO",
new SqlParameter("@id_usuario", user.Codigo),
new SqlParameter("@id_recurso", functionality.Codigo)
));
}
public Funcionalidade getFuncionalidadeporID(int id)
{
Funcionalidade funcionalidade = null;
funcionalidade = _context.funcionalidade.Find(id);
return(funcionalidade);
}
public IList <Funcionalidade> Executar()
{
return(Funcionalidade.Relatorios()
.Where(relatorio => this.podeAcessarFuncionalidadeServico.Executar(relatorio))
.OrderBy(x => x.DisplayName)
.ToList());
}
public async Task <IActionResult> Edit(int id, [Bind("Id,Nome")] Funcionalidade funcionalidade)
{
if (id != funcionalidade.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(funcionalidade);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!FuncionalidadeExists(funcionalidade.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(funcionalidade));
}
public IEnumerable <FuncionalidadeAcao> FetchByFunctionality(Funcionalidade functionality)
{
return(DataHelper.List <FuncionalidadeAcao>("PR_RECURSO_ACAO_CONSULTAR",
new SqlParameter("@id_recurso_acao", null),
new SqlParameter("@id_recurso", functionality.Codigo),
new SqlParameter("@id_acao", null)
));
}
public void Delete(Funcionalidade funcionalidade)
{
Contexto contexto = new Contexto();
contexto.Funcionalidades.Remove(funcionalidade);
contexto.SaveChanges();
contexto.Dispose();
}
public void Add(Funcionalidade funcionalidade)
{
Contexto contexto = new Contexto();
contexto.Funcionalidades.Add(funcionalidade);
contexto.SaveChanges();
contexto.Dispose();
}
public async Task <IActionResult> Add([FromBody] Funcionalidade funcionalidade)
{
await ServicoCadastro.Add <Funcionalidade>(funcionalidade);
return(CreatedAtAction(nameof(Get),
new { id = funcionalidade.IdFuncionalidade,
funcionalidade }));
}
public int Salvar(Funcionalidade obj, List <FuncionalidadeAcao> funcionalidadeAcoes, int FuncionalidadeId, short actionId)
{
try
{
var funcionalidades = _funcionalidade.Fetch(new Funcionalidade {
Nome = obj.Nome
}).ToList();
int id = 0;
if (obj.Codigo == 0)
{
if (funcionalidades.Count(x => x.Nome == obj.Nome) > 0)
{
if (_menuItemService.Buscar(new MenuItem {
Menu = obj.MenuId, Rotulo = obj.Nome
}).Any())
{
throw new SidsException("Não é possível realizar cadastro, funcionalidade já cadastrada.");
}
}
PreInsertModel(obj);
id = _funcionalidade.Add(obj);
SalvarAcoes(id, funcionalidadeAcoes);
var arg = String.Format("Nome {0}", obj.Nome);
LogSucesso(actionId, FuncionalidadeId, arg.ToString());
}
else
{
if (funcionalidades.Count(x => x.Nome == obj.Nome && x.Codigo != obj.Codigo) > 0)
{
throw new SidsException("Nome de funcionalidade já cadastrada.");
}
_funcionalidade.Edit(obj);
if (funcionalidadeAcoes != null)
{
SalvarAcoes(obj.Codigo, funcionalidadeAcoes);
}
id = obj.Codigo;
var arg = String.Format("Nome {0}", obj.Nome);
LogSucesso(actionId, FuncionalidadeId, arg.ToString());
}
return(id);
}
catch (Exception ex)
{
throw SaveLog(ex, actionId, FuncionalidadeId);
}
}
public bool ExisteAcessoPorPerfilEFuncionalidade(
int perfilId,
Funcionalidade funcionalidade)
{
return(this.Session.QueryOver <Acesso>()
.Where(x => x.Perfil.Id == perfilId)
.Where(x => x.Funcionalidade == funcionalidade)
.List().Count > 0);
}
public void Edit(Funcionalidade funcionalidade)
{
Contexto contexto = new Contexto();
Funcionalidade f = contexto.Funcionalidades.FirstOrDefault(u => u.Id == funcionalidade.Id);
f = funcionalidade;
contexto.SaveChanges();
contexto.Dispose();
}
public CarregarPerfil(Perfil perfil, Modulo modulo, Funcionalidade funcionalidade,
Permissao_Funcionalidade permissaoFuncionalidade, Permissao permissao)
{
this._Perfil = perfil;
this._Modulo = modulo;
this._Funcionalidade = funcionalidade;
this._Permissao_Funcionalidade = permissaoFuncionalidade;
this._Permissao = permissao;
}
/// <summary>
/// Retorna se possui acesso a operação do recurso
/// </summary>
/// <returns>Retorna verdadeiro quando o Usuário possui acesso</returns>
private bool GetPermissaoPerfilUsuario(Funcionalidade r, Usuario u, string operacao)
{
var perfilAcoes = _perfilAcao.FetchByUserAndFunctionality(u, r).ToList();
var acao = _acao.Fetch(new Acao {
Descricao = operacao
}).FirstOrDefault();
return(perfilAcoes.Any(a => a.Acao == acao?.Id));
}
public async Task <IActionResult> Create([Bind("Id,Nome,Descricao")] Funcionalidade funcionalidade)
{
if (ModelState.IsValid)
{
_funcionalidadeService.Criar(funcionalidade);
return(RedirectToAction(nameof(Index)));
}
return(View(funcionalidade));
}
public async Task <IActionResult> Create([Bind("Id,Nome")] Funcionalidade funcionalidade)
{
if (ModelState.IsValid)
{
_context.Add(funcionalidade);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(funcionalidade));
}
public List <Acao> ObterAcaoPorFuncionalidade(Funcionalidade objModel)
{
try
{
return(_acao.FetchByFunctionality(objModel).ToList());
}
catch (Exception ex)
{
throw SaveLog(ex);
}
}
public void InsertOrUpdate(Funcionalidade obj)
{
try
{
db.Entry(obj).State = obj.FuncionalidadeId == 0 ? EntityState.Added : EntityState.Modified;
db.SaveChanges();
}
catch (Exception ex)
{
throw new Exception("Error ao cadastrar Objeto!" + ex.Message);
}
}
public IEnumerable <Funcionalidade> Fetch(Funcionalidade entity)
{
return(DataHelper.List <Funcionalidade>("PR_RECURSO_CONSULTAR",
new SqlParameter("@id_recurso", entity.Codigo),
new SqlParameter("@no_recurso", entity.Nome),
new SqlParameter("@ds_recurso", entity.Descricao),
new SqlParameter("@ds_keywords", entity.Keywords),
new SqlParameter("@ds_url", entity.URL),
new SqlParameter("@bl_publico", entity.Publico),
new SqlParameter("@bl_ativo", entity.Status)
));
}
public int Edit(Funcionalidade entity)
{
return(DataHelper.Get <int>("PR_RECURSO_ALTERAR",
new SqlParameter("@id_recurso", entity.Codigo),
new SqlParameter("@no_recurso", entity.Nome),
new SqlParameter("@ds_recurso", entity.Descricao),
new SqlParameter("@ds_keywords", entity.Keywords),
new SqlParameter("@ds_url", entity.URL),
new SqlParameter("@bl_publico", entity.Publico),
new SqlParameter("@bl_ativo", entity.Status),
new SqlParameter("@id_menu_url", entity.MenuUrlId)
));
}
public static Funcionalidade ToDomainModel(FuncionalidadeViewModel funcionalidadeViewModel)
{
var funcionalidade = new Funcionalidade
{
Id = funcionalidadeViewModel.Id,
Excluido = funcionalidadeViewModel.Excluido,
DataCadastro = funcionalidadeViewModel.DataCadastro,
DataAtualizacao = funcionalidadeViewModel.DataAtualizacao,
Nome = funcionalidadeViewModel.Nome,
};
return(funcionalidade);
}
public void ValidandoAcessoaUmaPaginaAnonima()
{
ColecaoPersistencia colecao = new ColecaoPersistencia();
this.Ambiente.Titulo = "Páginas Anônimas (Homologação)";
this.Ambiente.Habilitado = Valor.Ativo;
this.Ambiente.Restrito = Valor.Ativo;
this.Ambiente.CodigoInterno = EnumAcesso.CodigoInterno_Ambiente.Anonimo;
AcessoController.Manter(this.Ambiente, "usuario.testes", colecao);
// INÍCIO: A exclusão do ambiente irá efetuar o processo de limpeza automática dos registros associados (cascata)
SuperGrupo objSuperGrupo = new SuperGrupo();
objSuperGrupo.Titulo = "Aninhamento Padrão - Nível 1 (Homologação)";
objSuperGrupo.Ambiente = this.Ambiente;
objSuperGrupo.Habilitado = Valor.Ativo;
objSuperGrupo.CodigoInterno = EnumAcesso.CodigoInterno_Grupo.Individual;
AcessoController.Manter(objSuperGrupo, "usuario.testes", colecao);
Grupo objGrupo = new Grupo();
objGrupo.Titulo = "Aninhamento Padrão - Nível 2 (Homologação)";
objGrupo.SuperGrupo = objSuperGrupo;
objGrupo.Habilitado = Valor.Ativo;
objGrupo.CodigoInterno = EnumAcesso.CodigoInterno_Grupo.Individual;
AcessoController.Manter(objGrupo, "usuario.testes", colecao);
Funcionalidade objFuncionalidade = new Funcionalidade();
objFuncionalidade.Titulo = "Validação de Página (Homologação)";
objFuncionalidade.Grupo = objGrupo;
objFuncionalidade.Habilitado = Valor.Ativo;
AcessoController.Manter(objFuncionalidade, "usuario.testes", colecao);
// FIM: A exclusão do ambiente irá efetuar o processo de limpeza automática dos registros associados (cascata)
colecao.Persistir();
int paginaID = Valor.Dois; // Página DEFAULT (Fins de teste)
this.Mapeamento.Tipo = EnumAcesso.TipodeAcesso.Funcionalidade;
this.Mapeamento.IdAcesso = objFuncionalidade.ID;
this.Mapeamento.UrlMapID = paginaID; // Página DEFAULT (Fins de teste)
this.Mapeamento.Principal = Valor.Ativo;
AcessoController.Manter(this.Mapeamento, "usuario.testes", null);
bool isAnonymousPage = AnonymousPageFacade.IsTrue(paginaID);
Assert.IsTrue(isAnonymousPage, "Não foi possível localizar a associação com o cenário ANONIMO.");
}
/// <summary>
/// redireciona para a página de sucesso
/// </summary>
/// <param name="funcionalidade"></param>
/// <param name="operacao"></param>
public void ExibirMensagemSucesso(Funcionalidade funcionalidade, Operacao operacao)
{
Response.Redirect(string.Format("~/Pages/Mensagem.aspx?result={0}&func={1}&op={2}", Resultado.Sucesso, funcionalidade, operacao), true);
}
