public async Task <ObjetoUsuarioMO> RecuperarClaveAsync(CancellationToken cancelToken, String idUsuario, String enlace)
{
ObjetoUsuarioMO objetoUsuarioMO = new ObjetoUsuarioMO();
try
{
using (_con = new SqlConnection(_conexionHostToHost))
{
using (_cmd = new SqlCommand(Constante.SPW_HTH_RECUPERAR_CLAVE, _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 = idUsuario;
SqlParameter par2 = _cmd.Parameters.Add(Constante.ENLACE, System.Data.SqlDbType.NVarChar, Constante._2000);
par2.Direction = System.Data.ParameterDirection.Input;
par2.Value = enlace;
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_RECUPERAR_CLAVE_ASYNC_OK : Constante.MENSAJE_RECUPERAR_CLAVE_ASYNC_NO_OK;
await _bitacora.RegistrarEventoAsync(cancelToken, Constante.BITACORA_NOTIFICACION, Constante.PROYECTO_REPOSITORIO, Constante.CLASE_CUENTA_RE, Constante.METODO_RECUPERAR_CLAVE_ASYNC, mensaje);
}
}
}
catch (Exception e)
{
await _bitacora.RegistrarEventoAsync(cancelToken, Constante.BITACORA_ERROR, Constante.PROYECTO_REPOSITORIO, Constante.CLASE_CUENTA_RE, Constante.METODO_RECUPERAR_CLAVE_ASYNC, Constante.MENSAJE_RECUPERAR_CLAVE_ASYNC_NO_OK, e.Message);
throw e;
}
finally
{
if (_con.State != System.Data.ConnectionState.Closed)
{
_con.Close();
}
}
return(objetoUsuarioMO);
}
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> RecuperarClaveAsync(CancellationToken cancelToken, String usuario, String correo)
{
Object objeto = null;
Boolean esCorrecto = false;
try
{
usuario = usuario ?? String.Empty;
correo = correo ?? String.Empty;
if (usuario == String.Empty && correo == String.Empty)
{
objeto = new
{
codigo = Constante.CODIGO_NO_OK,
mensaje = Constante.MENSAJE_PARAMETROS_NO_PRESENTES
};
}
else
{
IdentityUserMO identityUserMO = usuario != String.Empty ? await _userManager.FindByNameAsync(usuario) : await _userManager.FindByEmailAsync(correo);
String token = await _userManager.GeneratePasswordResetTokenAsync(identityUserMO);
var callbackUrl = String.Format(Constante.URL_RECUPERAR_CLAVE, identityUserMO.UserName, token);
ObjetoUsuarioMO objetoUsuarioMO = await _cuentaRE.RecuperarClaveAsync(cancelToken, identityUserMO.IdUsuario, callbackUrl);
objeto = new
{
codigo = objetoUsuarioMO.Codigo,
mensaje = objetoUsuarioMO.Mensaje
};
esCorrecto = objetoUsuarioMO.Codigo == Constante.CODIGO_OK ? true : false;
}
String mensaje = esCorrecto == true ? Constante.MENSAJE_RECUPERAR_CLAVE_ASYNC_OK : Constante.MENSAJE_RECUPERAR_CLAVE_ASYNC_NO_OK;
await _bitacora.RegistrarEventoAsync(cancelToken, Constante.BITACORA_NOTIFICACION, Constante.PROYECTO_NEGOCIO, Constante.CLASE_CUENTA_NE, Constante.METODO_RECUPERAR_CLAVE_ASYNC, mensaje);
}
catch (Exception e)
{
await _bitacora.RegistrarEventoAsync(cancelToken, Constante.BITACORA_ERROR, Constante.PROYECTO_NEGOCIO, Constante.CLASE_CUENTA_NE, Constante.METODO_RECUPERAR_CLAVE_ASYNC, Constante.MENSAJE_RECUPERAR_CLAVE_ASYNC_NO_OK, e.Message);
throw e;
}
return(objeto);
}
public async Task <Object> BuscarUsuariosAsync(CancellationToken cancelToken, String usuario, String apePaterno, String nombres)
{
Object objeto = null;
Boolean esCorrecto = false;
try
{
if (cancelToken == null)
{
objeto = new
{
codigo = Constante.CODIGO_NO_OK,
mensaje = Constante.MENSAJE_PARAMETROS_NO_PRESENTES
};
}
else
{
usuario = usuario ?? String.Empty;
apePaterno = apePaterno ?? String.Empty;
nombres = nombres ?? String.Empty;
ObjetoUsuarioMO objetoUsuarioMO = await _cuentaRE.BuscarUsuariosAsync(cancelToken, usuario, apePaterno, nombres);
objeto = new
{
codigo = objetoUsuarioMO.Codigo,
mensaje = objetoUsuarioMO.Mensaje,
listaUsuarios = objetoUsuarioMO.ListaUsuarios,
totalRegistros = objetoUsuarioMO.TotalRegistros
};
esCorrecto = objetoUsuarioMO.Codigo != Constante.CODIGO_NO_OK ? true : false;
}
String mensaje = esCorrecto ? Constante.MENSAJE_BUSCAR_USUARIOS_ASYNC_OK : Constante.MENSAJE_BUSCAR_USUARIOS_ASYNC_NO_OK;
await _bitacora.RegistrarEventoAsync(cancelToken, Constante.BITACORA_NOTIFICACION, Constante.PROYECTO_NEGOCIO, Constante.CLASE_CUENTA_NE, Constante.METODO_BUSCAR_USUARIOS_ASYNC, mensaje);
}
catch (Exception e)
{
await _bitacora.RegistrarEventoAsync(cancelToken, Constante.BITACORA_ERROR, Constante.PROYECTO_NEGOCIO, Constante.CLASE_CUENTA_NE, Constante.METODO_BUSCAR_USUARIOS_ASYNC, Constante.MENSAJE_BUSCAR_USUARIOS_ASYNC_NO_OK, e.Message);
throw e;
}
return(objeto);
}
public async Task <Object> ListarUsuariosAsync(CancellationToken cancelToken, Int32 pagina, Int32 filas)
{
Object objeto = null;
Boolean esCorrecto = false;
try
{
if (pagina == 0 || filas == 0)
{
objeto = new
{
codigo = Constante.CODIGO_NO_OK,
mensaje = Constante.MENSAJE_PARAMETROS_NO_PRESENTES
};
}
else
{
ObjetoUsuarioMO objetoUsuarioMO = await _cuentaRE.ListarUsuariosAsync(cancelToken, pagina, filas);
objeto = new
{
codigo = objetoUsuarioMO.Codigo,
mensaje = objetoUsuarioMO.Mensaje,
listaUsuarios = objetoUsuarioMO.ListaUsuarios,
totalRegistros = objetoUsuarioMO.TotalRegistros
};
esCorrecto = objetoUsuarioMO.Codigo != Constante.CODIGO_NO_OK ? true : false;
}
String mensaje = esCorrecto ? 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_CUENTA_NE, Constante.METODO_LISTAR_USUARIOS_ASYNC, mensaje);
}
catch (Exception e)
{
await _bitacora.RegistrarEventoAsync(cancelToken, Constante.BITACORA_ERROR, Constante.PROYECTO_NEGOCIO, Constante.CLASE_CUENTA_NE, Constante.METODO_LISTAR_USUARIOS_ASYNC, Constante.MENSAJE_LISTAR_USUARIOS_ASYNC_NO_OK, e.Message);
throw e;
}
return(objeto);
}
public async Task <Object> InactivarUsuarioAsync(CancellationToken cancelToken, String idUsuario)
{
Object objeto = null;
Boolean esCorrecto = false;
try
{
if (idUsuario == String.Empty)
{
objeto = new
{
codigo = Constante.CODIGO_NO_OK,
mensaje = Constante.MENSAJE_PARAMETROS_NO_PRESENTES
};
}
else
{
ObjetoUsuarioMO objetoUsuarioMO = await _cuentaRE.InactivarUsuarioAsync(cancelToken, idUsuario);
objeto = new
{
codigo = objetoUsuarioMO.Codigo,
mensaje = objetoUsuarioMO.Mensaje
};
esCorrecto = objetoUsuarioMO.Codigo == Constante.CODIGO_OK ? true : false;
}
String mensaje = esCorrecto == true ? Constante.MENSAJE_INACTIVAR_USUARIO_ASYNC_OK : Constante.MENSAJE_INACTIVAR_USUARIO_ASYNC_NO_OK;
await _bitacora.RegistrarEventoAsync(cancelToken, Constante.BITACORA_NOTIFICACION, Constante.PROYECTO_NEGOCIO, Constante.CLASE_CUENTA_NE, Constante.METODO_INACTIVAR_USUARIO_ASYNC, mensaje);
}
catch (Exception e)
{
await _bitacora.RegistrarEventoAsync(cancelToken, Constante.BITACORA_ERROR, Constante.PROYECTO_NEGOCIO, Constante.CLASE_CUENTA_NE, Constante.METODO_INACTIVAR_USUARIO_ASYNC, Constante.MENSAJE_INACTIVAR_USUARIO_ASYNC_NO_OK, e.Message);
throw e;
}
return(objeto);
}
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 <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);
}
