public ModificarRol(RolDTO unRol)
{
InitializeComponent();
this.rol = unRol;
this.Agregar = new List <FuncionalidadDTO>();
this.Eliminar = new List <FuncionalidadDTO>();
}
public async Task <RolDTO> Create(RolDTO dto, UsuarioDTO userLogged)
{
var rol = _mapper.Map <Rol>(dto);
rol.Active = true;
rol.CreationDate = DateTime.Now;
rol.UpdateDate = DateTime.Now;
rol.CreationUserId = userLogged.Id;
rol.UpdateUserId = userLogged.Id;
rol.IdEmpresa = userLogged.IdEmpresa;
rol = await _rolRepository.Insert(rol);
foreach (var item in dto.Permisos)
{
PermisoRol entity = new PermisoRol
{
RolId = rol.Id,
PermisoId = (int)item,
Active = true,
CreationDate = DateTime.Now,
UpdateDate = DateTime.Now,
CreationUserId = userLogged.Id,
UpdateUserId = userLogged.Id
};
await _permisoRolRepository.Insert(entity);
}
var rolDTO = _mapper.Map <RolDTO>(rol);
var permisosRoles = await _permisoRolRepository.ListBy(s => s.RolId == rol.Id);
rolDTO.Permisos = permisosRoles.Select(s => s.Id).ToArray();
return(rolDTO);
}
private void GuardarButton_Click(object sender, EventArgs e)
{
if (validar())
{
return;
}
RolDTO rol = new RolDTO();
//RolxFuncDTO rolxfun = new RolxFuncDTO();
rol.NombreRol = NombreText.Text;
rol.Estado = ActivoCheck.Checked;
//rol.ListaFunc.Add(this.FuncionalidadesCombo.SelectedItem as FuncionalidadDTO);
//rolxfun.funcionalidad = (this.FuncionalidadesCombo.SelectedItem as FuncionalidadDTO).IdFuncionalidad;
//rolxfun.rol = rol.IdRol;
if (RolDAO.GetByNombre(rol) == null)
{
if (RolDAO.insertarRol(rol))
{
rol = RolDAO.GetByNombre(rol);
FuncionalidadDAO.InsertarFuncionalidades(this.Agregar, rol.IdRol);
MessageBox.Show("Los datos se guardaron con exito");
this.Close();
}
else
{
MessageBox.Show("Error al guardar los datos. El Cliente ya existe");
}
}
else
{
MessageBox.Show(string.Format("Ya existe un rol con el nombre : {0}", rol.NombreRol));
}
}
private void dataGridView1_CellContentClick(object sender, DataGridViewCellEventArgs e)
{
//Ignora los clicks que no son sobre los elementos de la columna de botones
if (e.RowIndex < 0 || dataGridView1.RowCount == e.RowIndex + 1 || (e.ColumnIndex != dataGridView1.Columns.IndexOf(dataGridView1.Columns["Seleccionar"]) && e.ColumnIndex != dataGridView1.Columns.IndexOf(dataGridView1.Columns["Eliminar"])))
{
return;
}
RolDTO rol = (RolDTO)dataGridView1.Rows[e.RowIndex].DataBoundItem;
if (e.ColumnIndex == dataGridView1.Columns.IndexOf(dataGridView1.Columns["Seleccionar"]))
{
ModificarRol vent = new ModificarRol(rol);
vent.ShowDialog(this);
}
else
{
var confirmResult = MessageBox.Show("Seguro que quieres eliminar este rol?",
"Confirmar Delete",
MessageBoxButtons.YesNo);
if (confirmResult == DialogResult.Yes)
{
RolDAO.delete(rol);
MessageBox.Show("El rol fue dado de baja con exito");
Reload();
}
}
}
/// <summary>
///
/// </summary>
/// <param name="usuario"></param>
/// <returns></returns>
public static UsuarioDTO TransferirUsuario(Usuario usuario)
{
RolDTO rolDTO = new RolDTO(usuario.Rol.Id,
usuario.Rol.Nombre, usuario.Rol.Descripcion);
UsuarioDTO usuarioDTO = new UsuarioDTO(usuario.Id,
"", usuario.Correo, rolDTO);
return(usuarioDTO);
}
public async Task <ActionResult> Put(int id, [FromForm] RolDTO rolDTO)
{
var rol = _mapper.Map <Rol>(rolDTO);
rol.Id = id;
await _rolService.UpdateRol(rol);
return(NoContent());
}
public async Task <IActionResult> InsertRol(RolDTO rolDTO)
{
var rol = _mapper.Map <Rol>(rolDTO);
await _rolService.InsertRol(rol);
rolDTO = _mapper.Map <RolDTO>(rol);
var response = new APIResponse <RolDTO>(rolDTO);
return(Ok(response));
}
public async Task <ActionResult> Post([FromForm] RolDTO rolDTO)
{
var rol = _mapper.Map <Rol>(rolDTO);
await _rolService.InsertRol(rol);
rolDTO = _mapper.Map <RolDTO>(rol);
var response = new ApiResponse <RolDTO>(rolDTO);
return(Created(nameof(Get), new { id = rol.Id, response }));
}
public static Rol DTOToObject(RolDTO dto)
{
return(new Rol
{
description = dto.description,
value = dto.value,
name = dto.name,
timestamp = DataConvert.StringJsonToDateTime(dto.timestamp),
updated = DataConvert.StringJsonToDateTime(dto.updated)
});
}
//Crear rol
public static bool insertarRol(RolDTO rol)
{
int retorno = 0;
using (SqlConnection Conn = Conexion.Conexion.obtenerConexion())
{
SqlCommand Comando = new SqlCommand(string.Format("INSERT INTO [NORMALIZADOS].Rol(Nombre, Activo)VALUES('{0}', '{1}')", rol.NombreRol, rol.Estado), Conn);
retorno = Comando.ExecuteNonQuery();
return(retorno > 0);
}
}
public static BindingSource getDataGrid(RolDTO rol)
{
using (SqlConnection conn = Conexion.Conexion.obtenerConexion())
{
using (SqlCommand com = new SqlCommand(string.Format("SELECT R.Id, R.Nombre, R.Activo, RxF.Funcionalidad, F.Descripcion FROM [NORMALIZADOS].Rol R, [NORMALIZADOS].RolxFuncionalidad RxF, [NORMALIZADOS].Funcionalidad F WHERE R.Id = RxF.Rol AND RxF.Funcionalidad = F.Id AND R.Nombre = '{0}'", rol.NombreRol), conn))
{
SqlDataReader dataReader = com.ExecuteReader();
return(getRoles(dataReader));
}
}
}
/*
* public static bool FuncionalidadHabilitada(ClaseFuncionalidad funcionalidad)
* {
* return RolActual.tienePermiso(funcionalidad);
* }
*/
public static void Start(RolDTO rol)
{
if (rol == null)
{
StartAsClient();
}
else
{
StartAsUser(rol);
}
}
public static bool update(RolDTO rol)
{
int retorno = 0;
using (SqlConnection Conn = Conexion.Conexion.obtenerConexion())
{
SqlCommand Comando = new SqlCommand(string.Format("UPDATE [NORMALIZADOS].Rol SET Nombre = '{0}', Activo = '{1}' WHERE Id = {2}", rol.NombreRol, rol.Estado, rol.IdRol), Conn);
retorno = Comando.ExecuteNonQuery();
return(retorno > 0);
}
}
public async Task <IActionResult> Put(long Id, RolDTO rolDTO)
{
var rol = _mapper.Map <Rol>(rolDTO);
rol.Id = Id;
var result = await _rolService.UpdateRol(rol);
rolDTO = _mapper.Map <RolDTO>(rol);
var response = new APIResponse <RolDTO>(rolDTO);
return(Ok(response));
}
public static List <FuncionalidadDTO> selectByRol(RolDTO rol)
{
using (SqlConnection conn = Conexion.Conexion.obtenerConexion())
{
using (SqlCommand com = new SqlCommand("SELECT F.Id,F.Descripcion FROM [NORMALIZADOS].Funcionalidad F JOIN [NORMALIZADOS].RolxFuncionalidad RxF ON RxF.Funcionalidad=F.Id AND RxF.Rol=" + rol.IdRol, conn))
{
SqlDataReader reader = com.ExecuteReader();
List <FuncionalidadDTO> funcionalidades = readerToListFunc(reader);
return(funcionalidades);
}
}
}
public static IList <RolDTO> ObjectsToDTOs(IList <Rol> objs)
{
IList <RolDTO> list = new List <RolDTO>();
foreach (Rol obj in objs)
{
RolDTO dto = ObjectToDTO(obj);
list.Add(dto);
}
return(list);
}
public MensajeDTO InicioSesion(UsuarioDTO usuario)
{
MensajeDTO mensajeEstado = new MensajeDTO();
Models.EntidadesUsuarioUABC.Usuario usuarioUABC = usuarioRepositorioUABC.BuscarUsuarioUABC(usuario.Correo);
if (usuarioUABC != null)
{
if (usuario.Contrasenia.Equals(usuarioUABC.Contraseña))
{
Models.EntidadesUsuarioFIAD.Usuario usuarioFIAD = usuarioRepositorioUABC.BuscarUsuarioFIAD(usuario.Correo);
if (usuarioFIAD != null)
{
Models.EntidadesSolicitud.Usuario usuarioSS = usuarioRepositorioSS.BuscarPorCorreo(usuario.Correo);
if (usuarioSS != null)
{
UsuarioDTO usuarioAdministrativo = new UsuarioDTO();
RolDTO rol = new RolDTO();
usuarioAdministrativo.Nombre = usuarioUABC.Nombre;
usuarioAdministrativo.Apellido = usuarioUABC.Apellido;
rol.Nombre = usuarioSS.Rol.Nombre;
usuarioAdministrativo.Rol = rol;
mensajeEstado.Respuesta.Add("Mensaje", "Se ha iniciado sesion como Administrativo");
mensajeEstado.Respuesta.Add("Entidad", usuarioAdministrativo);
}
else
{
UsuarioDTO usuarioProfesor = new UsuarioDTO();
usuarioProfesor.Nombre = usuarioUABC.Nombre;
usuarioProfesor.Apellido = usuarioUABC.Apellido;
mensajeEstado.Respuesta.Add("Mensaje", "Se ha iniciado sesion como Profesor");
mensajeEstado.Respuesta.Add("Entidad", usuarioProfesor);
}
}
else
{
mensajeEstado.Respuesta.Add(null, "El usuario no pertenece a la Facultad de Ingenieria, Arquitectura y Diseño");
}
}
else
{
mensajeEstado.Respuesta.Add(null, "La contraseña introducida es incorrecta");
}
}
else
{
mensajeEstado.Respuesta.Add(null, "El usuario no pertenece a el dominio de UABC");
}
return(mensajeEstado);
}
public IList <String> SaveInfo(RolDTO obj)
{
List <String> list = new List <String>();
try
{
using (Conn = new Connection().Conexion)
{
IDbCommand comm = Conn.CreateCommand();
IDbDataParameter dp = comm.CreateParameter();
comm.Connection = Conn;
comm.CommandType = CommandType.StoredProcedure;
comm.CommandText = "guardarRol";
//AÑADIR PARAMETROS AL PROCEDIMIENTO ALMACENADO
dp = comm.CreateParameter();
dp.ParameterName = "@Id";
dp.Value = obj.id;
comm.Parameters.Add(dp);
dp = comm.CreateParameter();
dp.ParameterName = "@Nombre";
dp.Value = obj.nombre;
comm.Parameters.Add(dp);
dp = comm.CreateParameter();
dp.ParameterName = "@Descripcion";
dp.Value = obj.descripcion;
comm.Parameters.Add(dp);
Conn.Open();
IDataReader dr = comm.ExecuteReader(CommandBehavior.CloseConnection);
int columns = dr.FieldCount;
while (dr.Read())
{
for (int i = 0; i < columns; i++)
{
list.Add(dr.GetValue(i).ToString().Trim());
}
}
}
}
catch (Exception ex)
{
list.Add(String.Format("Error: {0}", ex.Message));
}
return(list);
}
public async Task <IActionResult> Create(RolDTO dto)
{
if (ModelState.IsValid)
{
dto = await _rolService.Create(dto, this.Usuario);
return(Ok(dto));
}
else
{
return(BadRequest(ModelState));
}
}
private UsuarioDTO TransferirDatosEntidad(Usuario usuario)
{
UsuarioDTO usuarioDTO = new UsuarioDTO();
usuarioDTO.Id = usuario.Id;
usuarioDTO.Correo = usuario.Correo;
RolDTO rolDTO = new RolDTO();
rolDTO.Id = usuario.Rol.Id;
rolDTO.Nombre = usuario.Rol.Nombre;
usuarioDTO.Rol = rolDTO;
return(usuarioDTO);
}
public static bool delete(RolDTO rol)
{
int retorno = 0;
using (SqlConnection Conn = Conexion.Conexion.obtenerConexion())
{
SqlCommand com = new SqlCommand("[NORMALIZADOS].[SP_Baja_Rol]", Conn);
com.CommandType = CommandType.StoredProcedure;
com.Parameters.AddWithValue("@Rol", rol.IdRol);
retorno = com.ExecuteNonQuery();
return(retorno > 0);
}
}
public async Task <IActionResult> Update(int id, RolDTO rol)
{
if (ModelState.IsValid)
{
rol = await _rolService.Update(id, rol, this.Usuario);
return(Ok(rol));
}
else
{
return(BadRequest(ModelState));
}
}
// GET: Rollen/Details/5
public async Task <IActionResult> Details(int?id)
{
RolDTO rolDTO = null;
if (id.HasValue)
{
rolDTO = await _rolRepository.GetByIdAsync(id.Value);
}
else
{
return(NotFound());
}
return(View(rolDTO));
}
private void botonBaja_Click_1(object sender, EventArgs e)
{
if (tablaListado.RowCount == 0)
{
MessageBox.Show("Debe buscar y seleccionar un rol para darlo de baja");
return;
}
if (tablaListado.RowCount > 0)
{
int index = tablaListado.SelectedRows[0].Index;
RolDTO rol = rolList.ElementAt(index);
RolDAO.deleteRol(rol.id);
loadRoles();
}
}
//// GET: Rol/Edit/5
public async Task <IActionResult> Edit(int?id)
{
if (id == null)
{
return(NotFound());
}
RolDTO rolDTO = await _rolRepository.GetByIdAsync(id.Value);
if (rolDTO == null)
{
return(NotFound());
}
return(View(rolDTO));
}
public static RolDTO GetByNombre(RolDTO unRol)
{
using (SqlConnection conn = Conexion.Conexion.obtenerConexion())
{
using (SqlCommand com = new SqlCommand(string.Format("SELECT Id, Nombre, Activo FROM [NORMALIZADOS].Rol WHERE Nombre = '{0}'", unRol.NombreRol), conn))
{
SqlDataReader dataReader = com.ExecuteReader();
List <RolDTO> Roles = ReaderToListClaseRol(dataReader);
if (Roles.Count == 0)
{
return(null);
}
return(Roles[0]);
}
}
}
private void botonModificacion_Click_1(object sender, EventArgs e)
{
if (tablaListado.RowCount == 0)
{
MessageBox.Show("Debe buscar y seleccionar un rol para modificarlo");
return;
}
if (tablaListado.RowCount > 0)
{
int index = tablaListado.SelectedRows[0].Index;
RolDTO rol = rolList.ElementAt(index);
AltaRol altaRol = new AltaRol(rol, this);
altaRol.ShowDialog();
}
}
public async Task <EmpresaDTO> Create(UsuarioDTO userLogged, EmpresaDTO dto)
{
//relleno el entity con los datos de la empresa
var entity = _mapper.Map <Empresa>(dto);
entity.Active = true;
entity.CreationDate = DateTime.Now;
entity.CreationUserId = userLogged.Id;
entity.UpdateDate = DateTime.Now;
entity.UpdateUserId = userLogged.Id;
//creo la empresa
entity = await _empresaRepository.Insert(entity);
//genero un nuevo rol con permiso de manager
int[] Permisos = { 2 };
RolDTO rol = new RolDTO
{
Nombre = "Manager",
Descripcion = "Administrador de la Empresa",
Permisos = Permisos,
};
var userLoggedRol = userLogged;
userLoggedRol.IdEmpresa = entity.Id;
//creo el rol
rol = await _rolService.Create(rol, userLoggedRol);
//genero el usuario con los datos
var usuarioDTO = new UsuarioDTO
{
Nombre = dto.NombreManager,
Apellido = dto.ApellidoManager,
Email = dto.EmailManager,
IdRol = rol.Id,
IdEmpresa = entity.Id
};
//creo el usuario
await _usuarioService.Insert(userLogged, usuarioDTO);
return(_mapper.Map <EmpresaDTO>(entity));
}
public ActionResult SaveInfo(int id, String nombre, String descripcion)
{
/*Se define el DTO (Clase que solo define datos, no funciones que lo diferencia del modelo)*/
RolDTO objDTO = new RolDTO(id, nombre, descripcion);
/*Se recibe en una lista generica el resultado del login definida en el service y obligada por el contract*/
IEnumerable <String> info = ContractService.SaveInfo(objDTO);
/*Lista temporal que contendra la respuesta que se le dara al cliente*/
IList <String> res = new List <String>();
/*Se valida si la consulta SQL retorno valores*/
if (info != null && info.Count() > 0)
{
res.Add("Status");
res.Add("Success");
}
/*Se para la lista de la respuesta a JSON*/
return(Json(new { d = res }));
}
public async Task <ActionResult <RolDTO> > Crear([FromBody] RolDTO model)
{
var rol = new IdentityRole {
ConcurrencyStamp = Guid.NewGuid().ToString(), Name = model.Name, NormalizedName = model.Name
};
var result = await rolManager.CreateAsync(rol);
if (result.Succeeded)
{
return(new RolDTO {
Name = rol.Name
});
}
else
{
return(BadRequest("Nombre de usuario o contraseña no válidos."));
}
}
