/// <summary>
/// Verifica se o usuario é Membro da lista
/// </summary>
/// <param name="usuario"></param>
private async Task <bool> ValidaPermissaoModeradorAsync(int listaId)
{
// Recupera permissao do usuario atual
GrupoUsuario permissaoUsuario = await RecuperaPermissao(listaId);
return(permissaoUsuario.PermissaoId == (int)API.Permissao.Moderador);
}
public async Task <IActionResult> PutGrupoUsuario([FromRoute] int id, [FromBody] GrupoUsuario grupoUsuario)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != grupoUsuario.idGrupoUsuario)
{
return(BadRequest());
}
_context.Entry(grupoUsuario).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!GrupoUsuarioExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public void CriandoeExcluindoPermissaoParaUmGrupo()
{
ColecaoPersistencia colecao = new ColecaoPersistencia();
Swarm.Core.Library.Seguranca.Grupo objGrupo = GrupoController.Create();
objGrupo.Descricao = "Grupo de teste #1";
GrupoController.Manter(objGrupo, this.Usuario.Login, colecao);
GrupoUsuario objGrupoUsuario = GrupoUsuarioController.Create();
objGrupoUsuario.Usuario = this.Usuario;
objGrupoUsuario.Grupo = objGrupo;
GrupoUsuarioController.Manter(objGrupoUsuario, this.Usuario.Login, colecao);
Permissao objPermissao = PermissaoController.Create();
objPermissao.Grupo = objGrupoUsuario;
objPermissao.GUID = this.Ambiente.GUID;
PermissaoController.Manter(objPermissao, this.Usuario.Login, colecao);
PermissaoController.Excluir(objPermissao, colecao);
GrupoUsuarioController.Excluir(objGrupoUsuario, colecao);
GrupoController.Excluir(objGrupo, colecao);
colecao.Persistir();
Assert.IsTrue(Checar.MenorouIgual(objPermissao.ID));
}
public void GuardarGrupoUsuario(GrupoUsuario grupoUsuario)
{
DataBaseModelContext db = new DataBaseModelContext();
try
{
grupoUsuario.Descripcion = grupoUsuario.Descripcion.Trim();
if (db.GrupoUsuario.Any(a => a.Descripcion == grupoUsuario.Descripcion && a.IdTipoGrupo == grupoUsuario.IdTipoGrupo && a.IdTipoUsuario == grupoUsuario.IdTipoUsuario))
{
throw new Exception("Ya existe un Grupo con esta descripcion");
}
db.ContextOptions.ProxyCreationEnabled = _proxy;
//TODO: Cambiar habilitado por el que viene embebido
grupoUsuario.Habilitado = true;
grupoUsuario.TieneSupervisor = grupoUsuario.SubGrupoUsuario.Any(a => a.IdSubRol == (int)BusinessVariables.EnumSubRoles.Supervisor);
if (grupoUsuario.Id == 0)
{
grupoUsuario.EstatusTicketSubRolGeneral = GeneraEstatusGrupoDefault(grupoUsuario);
grupoUsuario.EstatusAsignacionSubRolGeneral = GeneraEstatusAsignacionGrupoDefault(grupoUsuario);
db.GrupoUsuario.AddObject(grupoUsuario);
}
db.SaveChanges();
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
finally
{
db.Dispose();
}
}
private List <EstatusTicketSubRolGeneral> GeneraEstatusGrupoDefault(GrupoUsuario grupo)
{
List <EstatusTicketSubRolGeneral> result = new List <EstatusTicketSubRolGeneral>();
DataBaseModelContext db = new DataBaseModelContext();
try
{
db.ContextOptions.ProxyCreationEnabled = _proxy;
if (grupo.IdTipoGrupo == (int)BusinessVariables.EnumTiposGrupos.Agente)
{
result.AddRange(from subgpo in grupo.SubGrupoUsuario
where subgpo != null
from statusDefault in db.EstatusTicketSubRolGeneralDefault.Where(w => w.IdSubRolSolicita == subgpo.IdSubRol && w.TieneSupervisor == grupo.TieneSupervisor)
select new EstatusTicketSubRolGeneral
{
IdRolSolicita = statusDefault.IdRolSolicita,
IdSubRolSolicita = statusDefault.IdSubRolSolicita,
IdRolPertenece = statusDefault.IdRolPertenece,
IdSubRolPertenece = statusDefault.IdSubRolPertenece,
IdEstatusTicketActual = statusDefault.IdEstatusTicketActual,
IdEstatusTicketAccion = statusDefault.IdEstatusTicketAccion,
ComentarioObligado = statusDefault.ComentarioObligado,
TieneSupervisor = statusDefault.TieneSupervisor,
Propietario = statusDefault.Propietario,
LevantaTicket = statusDefault.LevantaTicket,
Habilitado = statusDefault.Habilitado
});
}
else if (grupo.IdTipoGrupo == (int)BusinessVariables.EnumTiposGrupos.AccesoCentroSoporte)
{
int idRol = (int)BusinessVariables.EnumRoles.AccesoCentroSoporte;
var qry = from statusDefault in db.EstatusTicketSubRolGeneralDefault.Where(
w => w.IdRolSolicita == idRol)
select statusDefault;
foreach (EstatusTicketSubRolGeneralDefault generalDefault in qry.ToList())
{
result.Add(new EstatusTicketSubRolGeneral
{
IdRolSolicita = generalDefault.IdRolSolicita,
IdSubRolSolicita = generalDefault.IdSubRolSolicita,
IdRolPertenece = generalDefault.IdRolPertenece,
IdSubRolPertenece = generalDefault.IdSubRolPertenece,
IdEstatusTicketActual = generalDefault.IdEstatusTicketActual,
IdEstatusTicketAccion = generalDefault.IdEstatusTicketAccion,
TieneSupervisor = generalDefault.TieneSupervisor,
Propietario = generalDefault.Propietario,
LevantaTicket = generalDefault.LevantaTicket,
Habilitado = generalDefault.Habilitado
});
}
}
}
catch (Exception e)
{
throw new Exception(e.Message);
}
finally { db.Dispose(); }
return(result);
}
private List <EstatusTicketSubRolGeneral> GeneraEstatusGrupoDefault(GrupoUsuario grupo)
{
List <EstatusTicketSubRolGeneral> result = new List <EstatusTicketSubRolGeneral>();
DataBaseModelContext db = new DataBaseModelContext();
try
{
result.AddRange(from subgpo in grupo.SubGrupoUsuario
where subgpo != null
from statusDefault in db.EstatusTicketSubRolGeneralDefault.Where(w => w.IdSubRol == subgpo.IdSubRol && w.TieneSupervisor == grupo.TieneSupervisor)
select new EstatusTicketSubRolGeneral
{
IdRol = statusDefault.IdRol,
IdSubRol = statusDefault.IdSubRol,
IdEstatusTicket = statusDefault.IdEstatusTicket,
Orden = statusDefault.Orden,
TieneSupervisor = statusDefault.TieneSupervisor,
Propietario = statusDefault.Propietario,
Habilitado = statusDefault.Habilitado
});
}
catch (Exception e)
{
throw new Exception(e.Message);
}
finally { db.Dispose(); }
return(result);
}
public ActionResult MiPerfil()
{
Session["user_name"] = Session["user_name"];
Session["IDG"] = Session["IDG"];
Session["ID"] = Session["ID"];
Usuario usuario = new Usuario();
GrupoUsuario GUser = new GrupoUsuario();
usuario = usuario.obtenerUsuarioPorID(int.Parse(Session["ID"].ToString()));
ViewBag.NombreUsuario = usuario.nombre;
ViewBag.Edad = usuario.ObtenerEdad(int.Parse(Session["ID"].ToString()));
ViewBag.Sexo = usuario.sexo;
ViewBag.NComentarios = usuario.cantidad_comentarios;
ViewBag.FechaRegistro = usuario.fecha_registro;
ViewBag.AvatarUrl = usuario.avatar_url;
ViewBag.TipoUsuario = GUser.obtenerNombreGrupoPorID(int.Parse(Session["IDG"].ToString()));
List <ViewTemasCreados> VTC2 = new List <ViewTemasCreados>();
ViewTemasCreados VTC = new ViewTemasCreados();
VTC2 = VTC.ObtenerTemasCreados(usuario.id);
ViewBag.TemasCreados = VTC2;
List <ViewUltimosComentarios> VUC2 = new List <ViewUltimosComentarios>();
ViewUltimosComentarios VUC = new ViewUltimosComentarios();
VUC2 = VUC.ObtenerComentariosRealizados(usuario.id);
ViewBag.ComentariosRealizados = VUC2;
return(View());
}
private void Recarrega()
{
if (tbCodGrupoUsuario.Text.Length <= 0)
{
return;
}
if (editando)
{
if (MessageBox.Show("Tem certeza que deseja perder os dados alterados?",
"Aviso de alteração",
MessageBoxButtons.YesNo,
MessageBoxIcon.Warning) == DialogResult.No)
{
return;
}
}
if (grupousuario != null)
{
grupousuario = grupousuarioDAO.BuscaByID(grupousuario.GrupoUsuarioID);
PreencheCampos(grupousuario);
if (editando)
{
Editando(false);
}
}
else
{
ignoraCheckEvent = true;
LimpaCampos(true);
ignoraCheckEvent = false;
Editando(false);
}
}
public Boolean VerificaUsuarioDoGrupo(GrupoUsuario grupoUsuario) //procura usuario existene em um grupo
{
Boolean retorno = true;
try
{
SqlCommand comando = new SqlCommand();
comando.CommandType = CommandType.Text;
comando.CommandText = "SELECT usuario_fk FROM [ExtranetFenix].[dbo].[usuarioXGrupo] WHERE grupoUsuario_fk = @grupoUsuario_fk";
comando.Parameters.AddWithValue("@grupoUsuario_fk", grupoUsuario.id);
SqlDataReader dr = ConexaoBanco.Selecionar(comando);
UsuarioDAO usuarioDao = new UsuarioDAO();
GrupoUsuarioDAO grupoDao = new GrupoUsuarioDAO();
if (dr.HasRows) //verifica se o dr tem alguma coisa
{
retorno = true;
}
else
{
retorno = false;
}
}
catch
{
retorno = true;
throw;
}
return(retorno);
}
public IHttpActionResult PostGrupoUsuario(GrupoUsuario grupoUsuario)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
db.GrupoUsuario.Add(grupoUsuario);
try
{
db.SaveChanges();
}
catch (DbUpdateException)
{
if (GrupoUsuarioExists(grupoUsuario.Id))
{
return(Conflict());
}
else
{
throw;
}
}
return(CreatedAtRoute("DefaultApi", new { id = grupoUsuario.Id }, grupoUsuario));
}
private void Proximo()
{
if (tbCodGrupoUsuario.Text.Length <= 0)
{
return;
}
var controls = (ControlCollection)this.Controls;
if (editando)
{
if (MessageBox.Show("Tem certeza que deseja perder os dados alterados?",
"Aviso de alteração",
MessageBoxButtons.YesNo,
MessageBoxIcon.Warning) == DialogResult.No)
{
return;
}
}
validacao.despintarCampos(controls);
var newgrupousuario = grupousuarioDAO.Proximo(tbCodGrupoUsuario.Text);
if (newgrupousuario != null)
{
grupousuario = newgrupousuario;
codigo = grupousuario.GrupoUsuarioID;
PreencheCampos(grupousuario);
if (editando)
{
Editando(false);
}
}
}
public IHttpActionResult PutGrupoUsuario(int id, GrupoUsuario grupoUsuario)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != grupoUsuario.Id)
{
return(BadRequest());
}
db.Entry(grupoUsuario).State = EntityState.Modified;
try
{
db.SaveChanges();
}
catch (DbUpdateConcurrencyException)
{
if (!GrupoUsuarioExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(StatusCode(HttpStatusCode.NoContent));
}
public static IList <PermissionView> GetPermissionsViews(GrupoUsuario ug)
{
IList <PermissionView> perviews = new List <PermissionView>();
foreach (Permiso per in ug.Permisos)
{
PermissionView pw = new PermissionView();
pw.PermissionId = per.PermisoId;
pw.Name = per.Proceso.Descripcion;
pw.ProcessId = per.Proceso.Nombre;
if (per.Proceso.ProcesoPadre != null)
{
pw.ParentProcessId = per.Proceso.ProcesoPadre.Nombre;
}
else
{
pw.ParentProcessId = "";
}
pw.View = per.Ver;
pw.Create = per.Crear;
pw.Modify = per.Modificar;
pw.Execute = per.Especial;
perviews.Add(pw);
}
return(perviews);
}
public static Permiso GetPermiso(GrupoUsuario grupoUsuario, Proceso proc, LainsaSci ctx)
{
return((from p in ctx.Permisos
where p.GrupoUsuario.GrupoUsuarioId == grupoUsuario.GrupoUsuarioId &&
p.Proceso.Nombre == proc.Nombre
select p).FirstOrDefault <Permiso>());
}
protected void btnAccept_Click(object sender, ImageClickEventArgs e)
{
try
{
if (!DataOk())
{
return;
}
if (newRecord)
{
UsuarioGroup = new GrupoUsuario();
}
UnloadData(UsuarioGroup);
if (newRecord)
{
ctx.Add(UsuarioGroup);
}
ctx.SaveChanges();
if (newRecord)
{
RadAjaxManager1.ResponseScripts.Add(String.Format("closeWindowRefreshGrid('{0}', 'new');"
, caller));
}
else
{
RadAjaxManager1.ResponseScripts.Add(String.Format("closeWindowRefreshGrid('{0}', 'edit');"
, caller));
}
}
catch (Exception ex)
{
ControlDeError(ex);
}
}
/// <summary>
/// Criar grupo com usuarios
/// </summary>
/// <returns>Grupo criado</returns>
public async Task <GrupoResponse> CriarComUsuarios(GrupoComUsuariosRequest model)
{
using (var scope = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled))
{
Grupo entidadeGrupo = this.mapper.Map <Grupo>(model.Grupo);
List <IdentityUser> entidadeUsuarios = this.mapper.Map <List <IdentityUser> >(model.Usuarios);
// Cria um novo grupo e recupera o usuario atual
Task <IdentityUser> usuarioTask = RecuperaUsuarioAtualAsync();
Task <Grupo> entidadeTask = this.repositorio.InserirAsync(entidadeGrupo);
IdentityUser usuario = await usuarioTask;
entidadeGrupo = await entidadeTask;
entidadeUsuarios = RecuperaUsuarios(entidadeUsuarios, usuario);
foreach (IdentityUser item in entidadeUsuarios)
{
GrupoUsuario relacionamento;
if (item.UserName.ToUpper() == usuario.UserName.ToUpper())
{
relacionamento = new GrupoUsuario(entidadeGrupo.Id, item.Id, (int)API.Permissao.Dono); // usuario Dono
}
else
{
relacionamento = new GrupoUsuario(entidadeGrupo.Id, item.Id, (int)API.Permissao.Membro); // Usuario contribuidor
}
// Adiciona o usuario no proprio grupo que está sendo criando
await this.repositorioGrupoUsuario.InserirAsync(relacionamento);
}
scope.Complete();
return(this.mapper.Map <GrupoResponse>(entidadeGrupo));
}
}
public async Task <IActionResult> Edit(long id, [Bind("GrupoUsuarioId,Nome,Descricao,Ativo,Visivel")] GrupoUsuario grupoUsuario)
{
if (id != grupoUsuario.GrupoUsuarioId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
}
catch (DbUpdateConcurrencyException)
{
if (!GrupoUsuarioExists(grupoUsuario.GrupoUsuarioId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(grupoUsuario));
}
/// <summary>
/// Altera permissao do usuario em um grupo
/// </summary>
public async Task AlterarPermissao(int grupoId, Usuario usuario)
{
using (var scope = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled))
{
await ValidaUsuarioPermissaoAsync(grupoId, usuario);
// Recupera usuario pelo Nome
IdentityUser entidadeUsuario = await RecuperaUsuarioPeloNome(usuario.Nome);
// Altera a permissao do usuario no Grupo
GrupoUsuario relacionamento = await this.repositorioGrupoUsuario.ObterAsync(x => x.UsuarioId == entidadeUsuario.Id &&
x.GrupoId == grupoId &&
x.Excluido == false);
if (relacionamento == null)
{
throw new ApiExcecao(422, "Usuario não pertence ao grupo");
}
relacionamento.PermissaoId = (int)usuario.Permissao;
// Atualiza a permissao do usuario
await this.repositorioGrupoUsuario.AtualizarAsync(relacionamento);
// Commita a transacao
scope.Complete();
}
}
public ActionResult Excluir(int id) //
{
Usuario usr = Session["UsuarioAtual"] as Usuario;
ViewBag.UsuarioLogado = usr.nome;
GrupoUsuario gu = new GrupoUsuario();
gu.id = id;
GrupoUsuarioBO gub = new GrupoUsuarioBO();
Boolean NaoDeletado = gub.Delete(gu);
if (NaoDeletado == true)
{
return(Json(new { success = false, responseText = "Existe(m) usuario(s) associado(s) ao grupo!!" }, JsonRequestBehavior.AllowGet));
}
else
{
return(Json(new { success = true }, JsonRequestBehavior.AllowGet));
}
}
/// <summary>
/// Atualiza grupo
/// </summary>
public async Task Atualizar(int id, GrupoRequest model)
{
Grupo entidade = this.mapper.Map <Grupo>(model);
entidade.Id = id;
IdentityUser usuarioAtual = await RecuperaUsuarioAtualAsync();
// Verifica permissao do usuario atual
GrupoUsuario grupoUsuario = await this.repositorioGrupoUsuario.ObterAsync(x => x.UsuarioId == usuarioAtual.Id &&
x.GrupoId == id &&
x.Excluido == false);
if (grupoUsuario == null)
{
throw new ApiExcecao(403, "Usuario não pode excluir permissao pois não é membro do grupo");
}
if (grupoUsuario.PermissaoId != (int)API.Permissao.Dono &&
grupoUsuario.PermissaoId != (int)API.Permissao.Moderador) // Apenas o dono ou moderador pode alterar o grupo
{
throw new ApiExcecao(403, "Usuario não pode alterar o grupo pois não é dono ou moderador do grupo");
}
await this.repositorio.AtualizarAsync(entidade);
}
public GrupoUsuario ObtenerGrupoDefaultRol(int idRol, int idTipoUsuario)
{
GrupoUsuario result = null;
DataBaseModelContext db = new DataBaseModelContext();
try
{
db.ContextOptions.ProxyCreationEnabled = _proxy;
RolTipoGrupo rolTipoGrupo = db.RolTipoGrupo.SingleOrDefault(w => w.IdRol == idRol);
if (rolTipoGrupo != null)
{
if (db.GrupoUsuario.Any(f => f.IdTipoGrupo == rolTipoGrupo.IdTipoGrupo && f.IdTipoUsuario == idTipoUsuario && f.Sistema))
{
result = db.GrupoUsuario.First(f => f.IdTipoGrupo == rolTipoGrupo.IdTipoGrupo && f.IdTipoUsuario == idTipoUsuario && f.Sistema);
db.LoadProperty(result, "SubGrupoUsuario");
}
}
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
finally
{
db.Dispose();
}
return(result);
}
public void RestDelete(GrupoUsuario item)
{
request = new RestRequest("GrupoUsuario/{id}", Method.DELETE);
request.AddParameter("id", item.Id);
client.Execute(request);
}
public void HabilitarGrupo(int idGrupo, bool habilitado)
{
DataBaseModelContext db = new DataBaseModelContext();
try
{
if (db.GrupoUsuario.Single(s => s.Id == idGrupo).IdTipoGrupo == (int)BusinessVariables.EnumTiposGrupos.Administrador)
{
if (db.GrupoUsuario.Count(w => w.IdTipoGrupo == (int)BusinessVariables.EnumTiposGrupos.Administrador && w.Habilitado && w.Id != idGrupo && w.UsuarioGrupo.Count(ug => ug.IdGrupoUsuario == w.Id) > 0) <= 0)
{
throw new Exception("Debe tener otro usuario activo para este tipo de grupo.");
}
}
GrupoUsuario grpo = db.GrupoUsuario.SingleOrDefault(w => w.Id == idGrupo);
if (grpo != null)
{
grpo.Habilitado = habilitado;
}
db.SaveChanges();
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
finally
{
db.Dispose();
}
}
public void RestUpdate(int id, GrupoUsuario item)
{
var request = new RestRequest("GrupoUsuario/" + id.ToString(), Method.PUT);
request.AddJsonBody(item);
client.Execute(request);
}
public Usuario BuscaByID(int cod)
{
Usuario usuario = new Usuario();
GrupoUsuario grupousuario = new GrupoUsuario();
using (MySQLConn sql = new MySQLConn(Configuracao.Conecta))
{
sql.Query = @"SELECT *, g.nome AS nomegrupo
FROM usuario
INNER JOIN grupo_usuario g
WHERE idusuario = @idusuario LIMIT 1";
sql.addParam("@idusuario", cod);
var data = sql.selectQueryForSingleRecord();
if (data == null)
{
return(null);
}
grupousuario = new GrupoUsuario
{
GrupoUsuarioID = Convert.ToInt32(data["idgrupousuario"]),
Nome = (string)data["nomegrupo"]
};
usuario = new Usuario
{
UsuarioID = Convert.ToInt32(data["idusuario"]),
Senha = (string)data["senha"],
Grupousuario = grupousuario,
Nome = (string)data["nome"],
Sobrenome = (string)data["sobrenome"],
Email = (string)data["email"],
Telefone = (string)data["telefone"]
};
}
return(usuario);
}
protected void btnAddUsuario_Click(object sender, EventArgs e)
{
var grupoUsuarioDelete = new GrupoUsuario();
grupoUsuarioDelete.IDGrupo = int.Parse(txtId.Text);
grupoUsuarioDelete.Delete();
foreach (ListItem item in listUsuarios.Items)
{
if (item.Selected)
{
var grupoUsuario = new GrupoUsuario();
grupoUsuario.IDUsuario = int.Parse(item.Value);
grupoUsuario.IDGrupo = int.Parse(txtId.Text);
grupoUsuario.Get();
grupoUsuario.Save();
}
}
foreach (ListItem item in listUsuariosAdd.Items)
{
var grupoUsuario = new GrupoUsuario();
grupoUsuario.IDUsuario = int.Parse(item.Value);
grupoUsuario.IDGrupo = int.Parse(txtId.Text);
grupoUsuario.Get();
grupoUsuario.Save();
}
GetAddUsuarios((int)grupoUsuarioDelete.IDGrupo);
}
protected void ChekPermissions(GrupoUsuario gu, RadMenuItemCollection col)
{
foreach (RadMenuItem i in col)
{
Proceso proceso = CntLainsaSci.GetProceso(i.Value, ctx);
if (proceso != null)
{
Permiso permiso = CntLainsaSci.GetPermiso(gu, proceso, ctx);
if (permiso != null)
{
if (!permiso.Ver)
{
i.Visible = false;
}
}
else
{
i.Visible = false; // If no permission not show
}
}
else
{
i.Visible = false; // If doesn't exits not show
}
// recursive call if there are submenus or items in it
if (i.Items.Count > 0)
{
ChekPermissions(gu, i.Items);
}
}
}
protected void Page_Init(object sender, EventArgs e)
{
// it gets an appropiate context (LainsaSciCTX -> web.config)
ctx = new LainsaSci("LainsaSciCTX");
// verify if a Usuario is logged
Usuario = CntWinWeb.IsSomeoneLogged(this, ctx);
if (Usuario == null)
{
Response.Redirect("Default.aspx");
}
else
{
Session["UsuarioId"] = Usuario.UsuarioId;
}
// Is it a new record or not?
if (Request.QueryString["PermisoId"] != null)
{
permiso = CntLainsaSci.GetPermiso(int.Parse(Request.QueryString["PermisoId"]), ctx);
LoadData(permiso);
newRecord = false;
}
if (Request.QueryString["Caller"] != null)
{
caller = Request.QueryString["Caller"];
}
if (Request.QueryString["GrupoUsuarioId"] != null)
{
grupoUsuario = CntLainsaSci.GetGrupoUsuario(int.Parse(Request.QueryString["GrupoUsuarioId"]), ctx);
}
if (Request.QueryString["Nombre"] != null)
{
proceso = CntLainsaSci.GetProceso(Request.QueryString["Nombre"].ToString(), ctx);
}
}
public void Atualizar(GrupoUsuarioTO to)
{
_Contexto = ControladorAcesso.ObterContexto();
if (to.Identificador == 0 || to == null)
{
to.Valido = false;
to.Mensagem = Mensagem.Atualizacao("GrupoUsuario", false);
return;
}
GrupoUsuario entidade = _Contexto.GrupoUsuario.FirstOrDefault(x => x.Identificador == to.Identificador);
if (entidade == null)
{
to.Valido = false;
to.Mensagem = Mensagem.Obter("GrupoUsuario", false);
return;
}
to.PreencherEntidade(entidade);
_Contexto.SaveChanges();
to.PreencherTO(entidade);
to.Valido = true;
to.Mensagem = Mensagem.Atualizacao("GrupoUsuario", true);
return;
}
public List <GrupoUsuario> ConsultarUsuario(GrupoAcessos grupo)
{
ConexaoOracle objConexao = new ConexaoOracle();
List <GrupoUsuario> list = new List <GrupoUsuario>();
GrupoUsuario objU;
try
{
objConexao.AdicionarParametro("P_ID_USUARIO", grupo.usuarios[0].matricula);
objConexao.AdicionarParametro("P_NOME", grupo.usuarios[0].nome == null ? grupo.usuarios[0].nome : grupo.usuarios[0].nome.ToUpper());
objConexao.AdicionarParametroCursor("dados");
OracleDataReader leitor = objConexao.ObterLeitor("FUN_PKG_GRUPO.CONSULTAR_USUARIO");
while (leitor.Read())
{
objU = new GrupoUsuario();
objU.matricula = int.Parse(leitor["MATRICULA"].ToString());
objU.nome = leitor["IDENTIFICACAO"].ToString();
list.Add(objU);
}
leitor.Dispose();
}
catch (Exception ex)
{
throw new Exception("Problemas contate o administrador do sistema: \\n" + ex.Message);
}
finally
{
objConexao.Dispose();
}
return(list);
}
