public async Task <JsonResult> ActualizarDatosAsync([FromBody] UsuarioMO usuarioMO)
{
Object objeto = null;
try
{
Boolean isAuthenticated = _httpContextAccessor.HttpContext.User.Identity.IsAuthenticated;
if (isAuthenticated)
{
objeto = await _cuentaNE.EditarUsuarioAsync(new CancellationToken(false), usuarioMO);
}
else
{
objeto = new
{
codigo = Constante.CODIGO_NO_AUTENTICADO,
mensaje = Constante.MENSAJE_NO_AUTENTICADO,
url = Constante.URL_PUBLICO_LOGUEAR
};
}
}
catch (Exception e)
{
objeto = new
{
codigo = Constante.CODIGO_ERROR,
mensaje = e.Message
};
return(Json(objeto));
}
return(Json(objeto));
}
public async Task <IActionResult> InicializarUsuario()
{
UsuarioMO usuarioMO = new UsuarioMO();
usuarioMO.ApePaterno = Constante.POR_DEFECTO_APE_PATERNO;
usuarioMO.ApeMaterno = Constante.POR_DEFECTO_APE_MATERNO;
usuarioMO.Nombres = Constante.POR_DEFECTO_NOMBRES;
usuarioMO.Usuario = Constante.POR_DEFECTO_USUARIO;
usuarioMO.Correo = Constante.POR_DEFECTO_CORREO;
usuarioMO.Celular = Constante.POR_DEFECTO_CELULAR;
await _cuentaNE.CrearUsuarioDesconectadoAsync(new CancellationToken(false), usuarioMO);
// Define the default user.
IdentityUserMO identityMO = new IdentityUserMO
{
IdUsuario = Constante.POR_DEFECTO_ID_USUARIO,
UserName = Constante.POR_DEFECTO_USUARIO,
NormalizedUserName = Constante.POR_DEFECTO_USUARIO.ToUpper(),
Email = Constante.POR_DEFECTO_CORREO,
NormalizedEmail = Constante.POR_DEFECTO_CORREO.ToUpper(),
EmailConfirmed = true,
PhoneNumber = Constante.POR_DEFECTO_CELULAR,
PhoneNumberConfirmed = true,
TwoFactorEnabled = false,
LockoutEnabled = false,
AccessFailedCount = Constante._20
};
// Get the list of the roles from enum.
Role[] roles = (Role[])Enum.GetValues(typeof(Role));
// Create the default user if it doesn't already exist.
if (await _userManager.FindByNameAsync(identityMO.UserName) == null)
{
// Do not check for credentials of any kind yet.
IdentityResult result = await _userManager.CreateAsync(identityMO, password : Constante.POR_DEFECTO_CLAVE);
// Return 500 if it fails
if (!result.Succeeded)
{
return(StatusCode(StatusCodes.Status500InternalServerError));
}
// Asign all roles to the default user.
result = await _userManager.AddToRolesAsync(identityMO, roles.Where(r => r.getRoleName() != Constante.ROL_ADMINISTRADOR).Select(r => r.getRoleName()));
// Return 500 if it fails
if (!result.Succeeded)
{
return(StatusCode(StatusCodes.Status500InternalServerError));
}
}
// All good, Ok.
return(Ok());
}
public async Task <Object> ListarNombresUsuariosAsync(CancellationToken cancelToken)
{
Object objeto = null;
Boolean esCorrecto = false;
try
{
if (cancelToken == null)
{
objeto = new
{
codigo = Constante.CODIGO_NO_OK,
mensaje = Constante.MENSAJE_PARAMETROS_NO_PRESENTES
};
}
else
{
var users = _userManager.Users.ToList();
if (users != null && users.Count > 0)
{
List <UsuarioMO> listaUsuarios = new List <UsuarioMO>();
foreach (var item in users)
{
UsuarioMO usuarioMO = new UsuarioMO();
usuarioMO.IdUsuario = item.IdUsuario;
usuarioMO.Usuario = item.UserName;
listaUsuarios.Add(usuarioMO);
}
objeto = new
{
codigo = listaUsuarios != null && listaUsuarios.Count > 0 ? Constante.CODIGO_OK : Constante.CODIGO_NO_OK,
mensaje = listaUsuarios != null && listaUsuarios.Count > 0 ? Constante.MENSAJE_LISTAR_USUARIOS_ASYNC_OK : Constante.MENSAJE_LISTAR_USUARIOS_ASYNC_NO_OK,
listaUsuarios = listaUsuarios
};
esCorrecto = listaUsuarios != null && listaUsuarios.Count > 0 ? true : false;
}
}
String mensaje = esCorrecto == true ? Constante.MENSAJE_LISTAR_USUARIOS_ASYNC_OK : Constante.MENSAJE_LISTAR_USUARIOS_ASYNC_NO_OK;
await _bitacora.RegistrarEventoAsync(cancelToken, Constante.BITACORA_NOTIFICACION, Constante.PROYECTO_NEGOCIO, Constante.CLASE_ROL_NE, Constante.METODO_LISTAR_USUARIOS_ASYNC, mensaje);
}
catch (Exception e)
{
await _bitacora.RegistrarEventoAsync(cancelToken, Constante.BITACORA_ERROR, Constante.PROYECTO_NEGOCIO, Constante.CLASE_ROL_NE, Constante.METODO_LISTAR_USUARIOS_ASYNC, Constante.MENSAJE_LISTAR_USUARIOS_ASYNC_NO_OK, e.Message);
throw e;
}
return(objeto);
}
public async Task <Object> SolicitarCodigoTokenAsync(CancellationToken cancelToken, String usuario)
{
Object objeto = null;
Boolean esCorrecto = false;
try
{
if (usuario == String.Empty)
{
objeto = new
{
codigo = Constante.CODIGO_NO_OK,
mensaje = Constante.MENSAJE_PARAMETROS_NO_PRESENTES
};
}
else
{
UsuarioMO usuarioMO = await _cuentaRE.ConsultarUsuariosAsync(cancelToken, usuario);
if (usuarioMO == null)
{
objeto = new
{
codigo = Constante.CODIGO_NO_OK,
mensaje = Constante.MENSAJE_USUARIO_CLAVE_INCORRECTAS
};
}
else
{
ObjetoUsuarioMO objetoUsuarioMO = await _cuentaRE.SolicitarCodigoTokenAsync(cancelToken, usuarioMO.IdUsuario);
objeto = new
{
codigo = objetoUsuarioMO.Codigo,
mensaje = objetoUsuarioMO.Mensaje
};
esCorrecto = objetoUsuarioMO.Codigo == Constante.CODIGO_OK ? true : false;
}
}
String mensaje = esCorrecto == true ? Constante.MENSAJE_SOLICITAR_CODIGO_TOKEN_ASYNC_OK : Constante.MENSAJE_SOLICITAR_CODIGO_TOKEN_ASYNC_NO_OK;
await _bitacora.RegistrarEventoAsync(cancelToken, Constante.BITACORA_NOTIFICACION, Constante.PROYECTO_NEGOCIO, Constante.CLASE_CUENTA_NE, Constante.METODO_SOLICITAR_CODIGO_TOKEN_ASYNC, mensaje);
}
catch (Exception e)
{
await _bitacora.RegistrarEventoAsync(cancelToken, Constante.BITACORA_ERROR, Constante.PROYECTO_NEGOCIO, Constante.CLASE_CUENTA_NE, Constante.METODO_SOLICITAR_CODIGO_TOKEN_ASYNC, Constante.MENSAJE_SOLICITAR_CODIGO_TOKEN_ASYNC_NO_OK, e.Message);
throw e;
}
return(objeto);
}
public async Task <Object> ConsultarNombreUsuarioAsync(CancellationToken cancelToken, String usuario)
{
Object objeto = null;
Boolean esCorrecto = false;
try
{
if (usuario == String.Empty)
{
objeto = new
{
codigo = Constante.CODIGO_NO_OK,
mensaje = Constante.MENSAJE_PARAMETROS_NO_PRESENTES
};
}
else
{
UsuarioMO usuarioMO = await _cuentaRE.ConsultarUsuariosAsync(new CancellationToken(false), usuario);
objeto = new
{
codigo = usuarioMO != null ? Constante.CODIGO_OK : Constante.CODIGO_NO_OK,
nombres = usuarioMO != null ? usuarioMO.Nombres : Constante.MENSAJE_PARAMETROS_NO_PRESENTES
};
esCorrecto = usuarioMO != null ? true : false;
}
String mensaje = esCorrecto == true ? Constante.MENSAJE_CONSULTAR_NOMBRE_USUARIO_ASYNC_OK : Constante.MENSAJE_CONSULTAR_NOMBRE_USUARIO_ASYNC_NO_OK;
await _bitacora.RegistrarEventoAsync(cancelToken, Constante.BITACORA_NOTIFICACION, Constante.PROYECTO_NEGOCIO, Constante.CLASE_CUENTA_NE, Constante.METODO_CONSULTAR_NOMBRE_USAURIO_ASYNC, mensaje);
}
catch (Exception e)
{
await _bitacora.RegistrarEventoAsync(cancelToken, Constante.BITACORA_ERROR, Constante.PROYECTO_NEGOCIO, Constante.CLASE_CUENTA_NE, Constante.METODO_CONSULTAR_NOMBRE_USAURIO_ASYNC, Constante.MENSAJE_CONSULTAR_NOMBRE_USUARIO_ASYNC_NO_OK, e.Message);
throw e;
}
return(objeto);
}
private IdentityUserMO MapearModeloUsuarioHaciaModeloIdentity(UsuarioMO usuarioMO)
{
IdentityUserMO identityMO = new IdentityUserMO();
try
{
identityMO.IdUsuario = String.Empty;
identityMO.UserName = usuarioMO.Usuario;
identityMO.NormalizedUserName = usuarioMO.Usuario.ToUpper();
identityMO.Email = usuarioMO.Correo;
identityMO.NormalizedEmail = usuarioMO.Correo.ToUpper();
identityMO.EmailConfirmed = true;
identityMO.PhoneNumber = usuarioMO.Celular;
identityMO.PhoneNumberConfirmed = true;
identityMO.TwoFactorEnabled = false;
identityMO.LockoutEnabled = false;
identityMO.AccessFailedCount = 20;
}
catch (Exception e)
{
throw e;
}
return(identityMO);
}
public async Task <Object> IniciarSesionAsync(CancellationToken cancelToken, String[] parametros)
{
Object objeto = null;
Boolean esParametrosConforme = false, esUsuarioConforme = false, esTokenConforme = false, esLogueadoConforme = false;
try
{
String usuario = parametros[0] == null ? String.Empty : parametros[0].ToString().Trim();
String clave = parametros[1] == null ? String.Empty : parametros[1].ToString().Trim();
String token = parametros[2] == null ? String.Empty : parametros[2].ToString().Trim();
String mensaje = String.Empty;
if (usuario != String.Empty && clave != String.Empty && token != String.Empty)
{
esParametrosConforme = true;
UsuarioMO usuarioMO = await _cuentaRE.ConsultarUsuariosAsync(new CancellationToken(false), usuario);
if (usuarioMO != null)
{
esUsuarioConforme = true;
ObjetoUsuarioMO objetoUsuarioMO = await _cuentaRE.ValidarCodigoTokenAsync(cancelToken, usuarioMO.IdUsuario, token);
if (objetoUsuarioMO != null && objetoUsuarioMO.Codigo == Constante.CODIGO_OK)
{
esTokenConforme = true;
SignInResult signInResult = await _signInManager.PasswordSignInAsync(usuario, clave, Constante.IS_PERSISTENT_FALSE, Constante.IS_LOCKOUT_ON_FAILURE_FALSE);
mensaje = objetoUsuarioMO.Mensaje;
if (signInResult.Succeeded == false)
{
if (signInResult.IsLockedOut)
{
mensaje = Constante.MENSAJE_USUARIO_BLOQUEADO;
}
else if (signInResult.IsNotAllowed)
{
mensaje = Constante.MENSAJE_USUARIO_NO_PERMITIDO;
}
else if (signInResult.RequiresTwoFactor)
{
mensaje = Constante.MENSAJE_DOBLE_AUTENTICACION;
}
else
{
mensaje = Constante.MENSAJE_USUARIO_CLAVE_INCORRECTAS;
}
}
else
{
esLogueadoConforme = true;
}
}
}
}
if (!esParametrosConforme)
{
objeto = new
{
codigo = Constante.CODIGO_NO_OK,
mensaje = Constante.MENSAJE_USUARIO_CLAVE_TOKEN_NO_INGRESADAS
};
}
else if (!esUsuarioConforme)
{
objeto = new
{
codigo = Constante.CODIGO_NO_OK,
mensaje = Constante.MENSAJE_USUARIO_CLAVE_INCORRECTAS
};
}
else if (!esTokenConforme)
{
objeto = new
{
codigo = Constante.CODIGO_NO_OK,
mensaje = mensaje
};
}
else if (!esLogueadoConforme)
{
objeto = new
{
codigo = Constante.CODIGO_NO_OK,
mensaje = mensaje
};
}
else
{
objeto = new
{
codigo = Constante.CODIGO_OK,
url = Constante.URL_PRIVADO_INICIO
};
}
mensaje = esLogueadoConforme == true ? Constante.MENSAJE_INICIAR_SESION_ASYNC_OK : Constante.MENSAJE_INICIAR_SESION_ASYNC_NO_OK;
await _bitacora.RegistrarEventoAsync(cancelToken, Constante.BITACORA_NOTIFICACION, Constante.PROYECTO_NEGOCIO, Constante.CLASE_CUENTA_NE, Constante.METODO_INICIAR_SESION_ASYNC, mensaje);
}
catch (Exception e)
{
await _bitacora.RegistrarEventoAsync(cancelToken, Constante.BITACORA_ERROR, Constante.PROYECTO_NEGOCIO, Constante.CLASE_CUENTA_NE, Constante.METODO_INICIAR_SESION_ASYNC, Constante.MENSAJE_INICIAR_SESION_ASYNC_NO_OK, e.Message);
throw e;
}
return(objeto);
}
public async Task <Object> CrearUsuarioAsync(CancellationToken cancelToken, UsuarioMO usuarioMO)
{
Object objeto = null;
Boolean esParametrosConforme = false, esInexistenteConforme = false, esCreadoConforme = false, esRegistradoConforme = false;
try
{
String mensaje = String.Empty;
if (usuarioMO != null)
{
esParametrosConforme = true;
IdentityUserMO usuarioPorNombre = await _userManager.FindByNameAsync(usuarioMO.Usuario);
IdentityUserMO usuarioPorCorreo = await _userManager.FindByEmailAsync(usuarioMO.Correo);
if (usuarioPorNombre == null && usuarioPorCorreo == null)
{
esInexistenteConforme = true;
ObjetoUsuarioMO objetoUsuarioMO = await _cuentaRE.CrearUsuarioAsync(cancelToken, usuarioMO);
if (objetoUsuarioMO != null && objetoUsuarioMO.Codigo == Constante.CODIGO_OK)
{
esCreadoConforme = true;
mensaje = objetoUsuarioMO.Mensaje;
IdentityUserMO identityMO = MapearModeloUsuarioHaciaModeloIdentity(usuarioMO);
identityMO.IdUsuario = objetoUsuarioMO.IdUsuario;
IdentityResult identityResult = await _userManager.CreateAsync(identityMO, usuarioMO.Clave);
esRegistradoConforme = identityResult.Succeeded;
if (!identityResult.Succeeded)
{
await _cuentaRE.EliminarUsuarioAsync(cancelToken, objetoUsuarioMO.IdUsuario);
foreach (IdentityError item in identityResult.Errors)
{
mensaje += String.Format("{0}{1}", item.Description, Environment.NewLine);
}
}
}
}
}
if (!esParametrosConforme)
{
objeto = new
{
codigo = Constante.CODIGO_NO_OK,
mensaje = Constante.MENSAJE_USUARIO_CLAVE_TOKEN_NO_INGRESADAS
};
}
else if (!esInexistenteConforme)
{
objeto = new
{
codigo = Constante.CODIGO_USUARIO_DUPLICADO,
mensaje = Constante.MENSAJE_USUARIO_DUPLICADO
};
}
else if (!esCreadoConforme)
{
objeto = new
{
codigo = Constante.CODIGO_NO_OK,
mensaje = Constante.MENSAJE_RECARGAR_PAGINA
};
}
else if (!esRegistradoConforme)
{
objeto = new
{
codigo = Constante.CODIGO_NO_OK,
mensaje = mensaje
};
}
else
{
objeto = new
{
codigo = Constante.CODIGO_OK,
mensaje = mensaje
};
}
mensaje = esRegistradoConforme == true ? Constante.MENSAJE_CREAR_USUARIO_ASYNC_OK : Constante.MENSAJE_CREAR_USUARIO_ASYNC_NO_OK;
await _bitacora.RegistrarEventoAsync(cancelToken, Constante.BITACORA_NOTIFICACION, Constante.PROYECTO_NEGOCIO, Constante.CLASE_CUENTA_NE, Constante.METODO_CREAR_USUARIO_ASYNC, mensaje);
}
catch (Exception e)
{
await _bitacora.RegistrarEventoAsync(cancelToken, Constante.BITACORA_ERROR, Constante.PROYECTO_NEGOCIO, Constante.CLASE_CUENTA_NE, Constante.METODO_CREAR_USUARIO_ASYNC, Constante.MENSAJE_CREAR_USUARIO_ASYNC_NO_OK, e.Message);
throw e;
}
return(objeto);
}
public async Task <Object> CrearUsuarioDesconectadoAsync(CancellationToken cancelToken, UsuarioMO usuarioMO)
{
Object objeto = null;
Boolean esCorrecto = false;
try
{
if (usuarioMO == null)
{
objeto = new
{
codigo = Constante.CODIGO_NO_OK,
mensaje = Constante.MENSAJE_PARAMETROS_NO_PRESENTES
};
}
else
{
ObjetoUsuarioMO objetoUsuarioMO = await _cuentaRE.CrearUsuarioAsync(cancelToken, usuarioMO);
objeto = new
{
codigo = objetoUsuarioMO.Codigo,
mensaje = objetoUsuarioMO.Mensaje
};
esCorrecto = objetoUsuarioMO.Codigo == Constante.CODIGO_OK ? true : false;
}
String mensaje = esCorrecto == true ? Constante.MENSAJE_CREAR_USUARIO_ASYNC_OK : Constante.MENSAJE_CREAR_USUARIO_ASYNC_NO_OK;
await _bitacora.RegistrarEventoAsync(cancelToken, Constante.BITACORA_NOTIFICACION, Constante.PROYECTO_NEGOCIO, Constante.CLASE_CUENTA_NE, Constante.METODO_CREAR_USUARIO_ASYNC, mensaje);
}
catch (Exception e)
{
await _bitacora.RegistrarEventoAsync(cancelToken, Constante.BITACORA_ERROR, Constante.PROYECTO_NEGOCIO, Constante.CLASE_CUENTA_NE, Constante.METODO_CREAR_USUARIO_ASYNC, Constante.MENSAJE_CREAR_USUARIO_ASYNC_NO_OK, e.Message);
throw e;
}
return(objeto);
}
public async Task <UsuarioMO> ConsultarUsuariosAsync(CancellationToken cancelToken, String usuario)
{
UsuarioMO usuarioMO = null;
try
{
using (_con = new SqlConnection(_conexionHostToHost))
{
using (_cmd = new SqlCommand(Constante.SPW_HTH_CONSULTAR_USUARIO, _con))
{
_cmd.CommandType = System.Data.CommandType.StoredProcedure;
SqlParameter par1 = _cmd.Parameters.Add(Constante.USUARIO, System.Data.SqlDbType.NVarChar, Constante._20);
par1.Direction = System.Data.ParameterDirection.Input;
par1.Value = usuario;
await _con.OpenAsync(cancelToken);
_reader = await _cmd.ExecuteReaderAsync(System.Data.CommandBehavior.SingleResult, cancelToken);
if (_reader != null && _reader.HasRows)
{
if (await _reader.ReadAsync(cancelToken))
{
usuarioMO = new UsuarioMO();
usuarioMO.IdUsuario = await _reader.IsDBNullAsync(Constante._0, cancelToken) ? String.Empty : _reader.GetString(Constante._0);
usuarioMO.Usuario = await _reader.IsDBNullAsync(Constante._1, cancelToken) ? String.Empty : _reader.GetString(Constante._1);
usuarioMO.ApePaterno = await _reader.IsDBNullAsync(Constante._2, cancelToken) ? String.Empty : _reader.GetString(Constante._2);
usuarioMO.ApeMaterno = await _reader.IsDBNullAsync(Constante._3, cancelToken) ? String.Empty : _reader.GetString(Constante._3);
usuarioMO.Nombres = await _reader.IsDBNullAsync(Constante._4, cancelToken) ? String.Empty : _reader.GetString(Constante._4);
usuarioMO.Correo = await _reader.IsDBNullAsync(Constante._5, cancelToken) ? String.Empty : _reader.GetString(Constante._5);
usuarioMO.Celular = await _reader.IsDBNullAsync(Constante._6, cancelToken) ? String.Empty : _reader.GetString(Constante._6);
usuarioMO.FechaCreacion = await _reader.IsDBNullAsync(Constante._7, cancelToken) ? String.Empty : _reader.GetString(Constante._7);
}
}
_reader.Close();
_con.Close();
String mensaje = usuarioMO != null ? Constante.MENSAJE_CONSULTAR_USUARIO_ASYNC_OK : Constante.MENSAJE_CONSULTAR_USUARIO_ASYNC_NO_OK;
await _bitacora.RegistrarEventoAsync(cancelToken, Constante.BITACORA_NOTIFICACION, Constante.PROYECTO_REPOSITORIO, Constante.CLASE_CUENTA_RE, Constante.METODO_CONSULTAR_USUARIO_ASYNC, mensaje);
}
}
}
catch (Exception e)
{
await _bitacora.RegistrarEventoAsync(cancelToken, Constante.BITACORA_ERROR, Constante.PROYECTO_REPOSITORIO, Constante.CLASE_CUENTA_RE, Constante.METODO_CONSULTAR_USUARIO_ASYNC, Constante.MENSAJE_CONSULTAR_USUARIO_ASYNC_NO_OK, e.Message);
throw e;
}
finally
{
if (_con != null && _con.State != System.Data.ConnectionState.Closed)
{
_con.Close();
}
}
return(usuarioMO);
}
public async Task <ObjetoUsuarioMO> EditarUsuarioAsync(CancellationToken cancelToken, UsuarioMO usuarioMO)
{
ObjetoUsuarioMO objetoUsuarioMO = new ObjetoUsuarioMO();
try
{
using (_con = new SqlConnection(_conexionHostToHost))
{
using (_cmd = new SqlCommand(Constante.SPW_HTH_EDITAR_USUARIO, _con))
{
_cmd.CommandType = System.Data.CommandType.StoredProcedure;
SqlParameter par1 = _cmd.Parameters.Add(Constante.ID_USUARIO, System.Data.SqlDbType.NChar, Constante._6);
par1.Direction = System.Data.ParameterDirection.Input;
par1.Value = usuarioMO.IdUsuario;
SqlParameter par2 = _cmd.Parameters.Add(Constante.APE_PATERNO, System.Data.SqlDbType.NVarChar, Constante._50);
par2.Direction = System.Data.ParameterDirection.Input;
par2.Value = usuarioMO.ApePaterno;
SqlParameter par3 = _cmd.Parameters.Add(Constante.APE_MATERNO, System.Data.SqlDbType.NVarChar, Constante._50);
par3.Direction = System.Data.ParameterDirection.Input;
par3.Value = usuarioMO.ApeMaterno;
SqlParameter par4 = _cmd.Parameters.Add(Constante.NOMBRES, System.Data.SqlDbType.NVarChar, Constante._50);
par4.Direction = System.Data.ParameterDirection.Input;
par4.Value = usuarioMO.Nombres;
SqlParameter par7 = _cmd.Parameters.Add(Constante.CORREO, System.Data.SqlDbType.NVarChar, Constante._50);
par7.Direction = System.Data.ParameterDirection.Input;
par7.Value = usuarioMO.Correo;
SqlParameter par8 = _cmd.Parameters.Add(Constante.CELULAR, System.Data.SqlDbType.NVarChar, Constante._15);
par8.Direction = System.Data.ParameterDirection.Input;
par8.Value = usuarioMO.Celular;
await _con.OpenAsync(cancelToken);
_reader = await _cmd.ExecuteReaderAsync(System.Data.CommandBehavior.SingleRow, cancelToken);
if (_reader != null && _reader.HasRows)
{
if (await _reader.ReadAsync(cancelToken))
{
objetoUsuarioMO.Codigo = await _reader.IsDBNullAsync(Constante._0, cancelToken) ? 0 : _reader.GetInt32(Constante._0);
objetoUsuarioMO.Mensaje = await _reader.IsDBNullAsync(Constante._1, cancelToken) ? String.Empty : _reader.GetString(Constante._1);
}
}
_reader.Close();
_con.Close();
String mensaje = _reader != null ? Constante.MENSAJE_EDITAR_USUARIO_ASYNC_OK : Constante.MENSAJE_EDITAR_USUARIO_ASYNC_NO_OK;
await _bitacora.RegistrarEventoAsync(cancelToken, Constante.BITACORA_NOTIFICACION, Constante.PROYECTO_REPOSITORIO, Constante.CLASE_CUENTA_RE, Constante.METODO_EDITAR_USUARIO_ASYNC, mensaje);
}
}
}
catch (Exception e)
{
await _bitacora.RegistrarEventoAsync(cancelToken, Constante.BITACORA_ERROR, Constante.PROYECTO_REPOSITORIO, Constante.CLASE_CUENTA_RE, Constante.METODO_EDITAR_USUARIO_ASYNC, Constante.MENSAJE_EDITAR_USUARIO_ASYNC_NO_OK, e.Message);
throw e;
}
finally
{
if (_con != null && _con.State != System.Data.ConnectionState.Closed)
{
_con.Close();
}
}
return(objetoUsuarioMO);
}
public async Task <ObjetoUsuarioMO> ListarUsuariosAsync(CancellationToken cancelToken, Int32 pagina, Int32 filas)
{
ObjetoUsuarioMO objetoUsuarioMO = new ObjetoUsuarioMO();
List <UsuarioMO> listaUsuarios = null;
try
{
using (_con = new SqlConnection(_conexionHostToHost))
{
using (_cmd = new SqlCommand(Constante.SPW_HTH_LISTAR_USUARIOS, _con))
{
_cmd.CommandType = System.Data.CommandType.StoredProcedure;
SqlParameter par1 = _cmd.Parameters.Add(Constante.PAGINA, System.Data.SqlDbType.Int);
par1.Direction = System.Data.ParameterDirection.Input;
par1.Value = pagina;
SqlParameter par2 = _cmd.Parameters.Add(Constante.FILAS, System.Data.SqlDbType.Int);
par2.Direction = System.Data.ParameterDirection.Input;
par2.Value = filas;
SqlParameter par3 = _cmd.Parameters.Add(Constante.TOTAL_REGISTROS, System.Data.SqlDbType.Int);
par3.Direction = System.Data.ParameterDirection.Output;
await _con.OpenAsync(cancelToken);
_reader = await _cmd.ExecuteReaderAsync(System.Data.CommandBehavior.SingleResult, cancelToken);
if (_reader != null && !_reader.HasRows)
{
objetoUsuarioMO.Codigo = Constante.CODIGO_OMISION;
objetoUsuarioMO.Mensaje = Constante.MENSAJE_SIN_RESULTADOS;
}
else if (_reader != null && _reader.HasRows)
{
listaUsuarios = new List <UsuarioMO>();
while (await _reader.ReadAsync(cancelToken))
{
UsuarioMO usuarioMO = new UsuarioMO();
usuarioMO.IdUsuario = await _reader.IsDBNullAsync(Constante._0, cancelToken) ? String.Empty : _reader.GetString(Constante._0);
usuarioMO.Usuario = await _reader.IsDBNullAsync(Constante._1, cancelToken) ? String.Empty : _reader.GetString(Constante._1);
usuarioMO.ApePaterno = await _reader.IsDBNullAsync(Constante._2, cancelToken) ? String.Empty : _reader.GetString(Constante._2);
usuarioMO.ApeMaterno = await _reader.IsDBNullAsync(Constante._3, cancelToken) ? String.Empty : _reader.GetString(Constante._3);
usuarioMO.Nombres = await _reader.IsDBNullAsync(Constante._4, cancelToken) ? String.Empty : _reader.GetString(Constante._4);
usuarioMO.Correo = await _reader.IsDBNullAsync(Constante._5, cancelToken) ? String.Empty : _reader.GetString(Constante._5);
usuarioMO.Celular = await _reader.IsDBNullAsync(Constante._6, cancelToken) ? String.Empty : _reader.GetString(Constante._6);
usuarioMO.Estado = await _reader.IsDBNullAsync(Constante._7, cancelToken) ? String.Empty : _reader.GetString(Constante._7);
usuarioMO.UsuarioCreacion = await _reader.IsDBNullAsync(Constante._8, cancelToken) ? String.Empty : _reader.GetString(Constante._8);
DateTime?fechaCreacion = await _reader.IsDBNullAsync(Constante._9, cancelToken) ? (DateTime?)null : _reader.GetDateTime(Constante._9);
usuarioMO.FechaCreacion = fechaCreacion == null ? String.Empty : fechaCreacion.Value.ToShortDateString();
usuarioMO.HoraCreacion = fechaCreacion == null ? String.Empty : fechaCreacion.Value.ToShortTimeString();
listaUsuarios.Add(usuarioMO);
}
objetoUsuarioMO.Codigo = Constante.CODIGO_OK;
}
_reader.Close();
_con.Close();
objetoUsuarioMO.Codigo = _reader != null ? objetoUsuarioMO.Codigo : Constante.CODIGO_NO_OK;
objetoUsuarioMO.Mensaje = _reader != null ? objetoUsuarioMO.Mensaje : Constante.MENSAJE_RECARGAR_PAGINA;
objetoUsuarioMO.ListaUsuarios = listaUsuarios;
objetoUsuarioMO.TotalRegistros = par3.Value == null ? 0 : Convert.ToInt32(par3.Value);
String mensaje = _reader != null ? Constante.MENSAJE_LISTAR_USUARIOS_ASYNC_OK : Constante.MENSAJE_LISTAR_USUARIOS_ASYNC_NO_OK;
await _bitacora.RegistrarEventoAsync(cancelToken, Constante.BITACORA_NOTIFICACION, Constante.PROYECTO_REPOSITORIO, Constante.CLASE_CUENTA_RE, Constante.METODO_LISTAR_USUARIOS_ASYNC, mensaje);
}
}
}
catch (Exception e)
{
await _bitacora.RegistrarEventoAsync(cancelToken, Constante.BITACORA_ERROR, Constante.PROYECTO_REPOSITORIO, Constante.CLASE_CUENTA_RE, Constante.METODO_LISTAR_USUARIOS_ASYNC, Constante.MENSAJE_LISTAR_USUARIOS_ASYNC_NO_OK, e.Message);
throw e;
}
finally
{
if (_con != null && _con.State != System.Data.ConnectionState.Closed)
{
_con.Close();
}
}
return(objetoUsuarioMO);
}
