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> ReiniciarClaveAsync(CancellationToken cancelToken, String[] parametros)
{
Object objeto = null;
Boolean esCorrecto = 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();
if (usuario == String.Empty || clave == String.Empty || token == String.Empty)
{
objeto = new
{
codigo = Constante.CODIGO_NO_OK,
mensaje = Constante.MENSAJE_PARAMETROS_NO_PRESENTES
};
}
else
{
IdentityUserMO identityUserMO = await _userManager.FindByNameAsync(usuario);
IdentityResult identityResult = await _userManager.ResetPasswordAsync(identityUserMO, token, clave);
esCorrecto = identityResult.Succeeded;
String mensajeError = String.Empty;
if (!identityResult.Succeeded)
{
foreach (var item in identityResult.Errors)
{
mensajeError += String.Format("{0}{1}", item.Description, Environment.NewLine);
}
}
objeto = new
{
codigo = identityResult.Succeeded ? Constante.CODIGO_OK : Constante.CODIGO_NO_OK,
mensaje = identityResult.Succeeded ? Constante.MENSAJE_VOLVER_INICIAR_SESION : mensajeError,
url = Constante.URL_PUBLICO_LOGUEAR
};
esCorrecto = identityResult.Succeeded ? true : false;
}
String mensaje = esCorrecto == true ? Constante.MENSAJE_REINICIAR_CLAVE_ASYNC_OK : Constante.MENSAJE_REINICIAR_CLAVE_ASYNC_NO_OK;
await _bitacora.RegistrarEventoAsync(cancelToken, Constante.BITACORA_NOTIFICACION, Constante.PROYECTO_NEGOCIO, Constante.CLASE_CUENTA_NE, Constante.METODO_REINICIAR_CLAVE_ASYNC, mensaje);
}
catch (Exception e)
{
await _bitacora.RegistrarEventoAsync(cancelToken, Constante.BITACORA_ERROR, Constante.PROYECTO_NEGOCIO, Constante.CLASE_CUENTA_NE, Constante.METODO_REINICIAR_CLAVE_ASYNC, Constante.MENSAJE_REINICIAR_CLAVE_ASYNC_NO_OK, e.Message);
throw e;
}
return(objeto);
}
public async Task <Object> DesasignarRolAsync(CancellationToken cancelToken, String[] parametros)
{
Object objeto = null;
Boolean esCorrecto = false;
try
{
String usuario = parametros[0] == null ? String.Empty : parametros[0].ToString().Trim();
String rol = parametros[1] == null ? String.Empty : parametros[1].ToString().Trim();
if (usuario == String.Empty || rol == String.Empty)
{
objeto = new
{
codigo = Constante.CODIGO_NO_OK,
mensaje = Constante.MENSAJE_PARAMETROS_NO_PRESENTES
};
}
else
{
IdentityUserMO identityMO = await _userManager.FindByNameAsync(usuario);
IdentityResult identityResult = await _userManager.RemoveFromRoleAsync(identityMO, rol);
String mensajeError = String.Empty;
if (!identityResult.Succeeded)
{
foreach (IdentityError item in identityResult.Errors)
{
mensajeError += String.Format("{0}{1}", item.Description, Environment.NewLine);
}
}
objeto = new
{
codigo = identityResult.Succeeded ? Constante.CODIGO_OK : Constante.CODIGO_NO_OK,
mensaje = identityResult.Succeeded ? Constante.MENSAJE_DESASIGNAR_ROL_ASYNC_OK : mensajeError
};
esCorrecto = identityResult.Succeeded ? true : false;
}
String mensaje = esCorrecto == true ? Constante.MENSAJE_DESASIGNAR_ROL_ASYNC_OK : Constante.MENSAJE_DESASIGNAR_ROL_ASYNC_NO_OK;
await _bitacora.RegistrarEventoAsync(cancelToken, Constante.BITACORA_NOTIFICACION, Constante.PROYECTO_NEGOCIO, Constante.CLASE_ROL_NE, Constante.METODO_DESASIGNAR_ROL_ASYNC, mensaje);
}
catch (Exception e)
{
await _bitacora.RegistrarEventoAsync(cancelToken, Constante.BITACORA_ERROR, Constante.PROYECTO_NEGOCIO, Constante.CLASE_ROL_NE, Constante.METODO_DESASIGNAR_ROL_ASYNC, Constante.MENSAJE_DESASIGNAR_ROL_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> ListarRolesUsuarioAsync(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
{
IdentityUserMO identityMO = await _userManager.FindByNameAsync(usuario);
IList <String> listaRoles = await _userManager.GetRolesAsync(identityMO);
objeto = new
{
codigo = listaRoles.Count > 0 ? Constante.CODIGO_OK : Constante.CODIGO_OMISION,
mensaje = listaRoles.Count > 0 ? String.Empty : Constante.MENSAJE_USUARIO_SIN_ROLES,
listaRoles = listaRoles
};
esCorrecto = listaRoles != null && listaRoles.Count > 0 ? true : false;
}
String mensaje = esCorrecto == true ? Constante.MENSAJE_LISTAR_ROLES_USUARIO_ASYNC_OK : Constante.MENSAJE_LISTAR_ROLES_USUARIO_ASYNC_NO_OK;
await _bitacora.RegistrarEventoAsync(cancelToken, Constante.BITACORA_NOTIFICACION, Constante.PROYECTO_NEGOCIO, Constante.CLASE_ROL_NE, Constante.METODO_LISTAR_ROLES_USUARIO_ASYNC, mensaje);
}
catch (Exception e)
{
await _bitacora.RegistrarEventoAsync(cancelToken, Constante.BITACORA_ERROR, Constante.PROYECTO_NEGOCIO, Constante.CLASE_ROL_NE, Constante.METODO_LISTAR_ROLES_USUARIO_ASYNC, Constante.MENSAJE_LISTAR_ROLES_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> 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);
}
