//LOGICA DE NEGOCIOS
/// <summary>
/// OBTIENE UN USUARIO CON SUS RELACIONES, DEPENDIENDO SI DESEA UTILIZARLAS O NO.
/// </summary>
/// <param name="incluir"></param>
/// <param name="lstUsuarios"></param>
/// <returns>LISTA DE USUARIOS MAPEADOS CON DTO</returns>
private async Task <List <UsuariosDTO> > ObtenerUsuariosRelaciones(
IQueryable <UsuariosEntidad> lstUsuarios,
IncluirUsuariosDTO incluir = null)
{
Guid UsuarioActual = Guid.Empty;
List <UsuariosDTO> lstUsuariosDTO = new List <UsuariosDTO>();
if (lstUsuarios != null)
{
foreach (var usuario in lstUsuarios)
{
var usuarioDTO = new UsuariosDTO
{
Id = usuario.Id,
Usuario = usuario.UserName,
Email = usuario.Email,
FechaCreacion = usuario.FechaCreacion,
Estatus = usuario.Estatus
};
if (incluir.Role)
{
usuarioDTO.Roles = await ObtenerRolesUsuarioAsync(usuario);
}
lstUsuariosDTO.Add(usuarioDTO);
}
}
return(lstUsuariosDTO);
}
public List <UsuariosDTO> GetAll()
{
List <UsuariosDTO> toReturn = new List <UsuariosDTO>();
UsuariosDTO obj;
try
{
this.BEMEConnectionObj.Open();
OleDbCommand cmd = new OleDbCommand("SELECT IdUsuario, NombreUsuario FROM Usuarios", this.BEMEConnectionObj);
OleDbDataReader reader = cmd.ExecuteReader();
while (reader.Read())
{
obj = new UsuariosDTO();
obj.IdUsuario = Convert.ToInt32(reader["IdUsuario"]);
obj.NombreUsuario = Convert.ToString(reader["NombreUsuario"]);
toReturn.Add(obj);
}
reader.Close();
this.BEMEConnectionObj.Close();
}
catch (OleDbException ex)
{
toReturn = null;
throw ex;
}
return(toReturn);
}
public IActionResult PostRegister([FromBody] RegisterDTO Register,
[FromServices] UsuariosDAO usuariosDAO,
[FromServices] TreinosDAO treinosDAO)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
try
{
UsuariosDTO _usuario = usuariosDAO.SelectUsuarioPorEmail(Register.Email);
if (_usuario != null)
{
return(BadRequest(new { msg = "Email já cadastrado" }));
}
int _IDUsuario = usuariosDAO.InsertUsuario(Register);
}
catch (Exception ex)
{
return(BadRequest(JsonConvert.SerializeObject(ex)));
}
return(Ok(new { msg = "Registro efetuado com sucesso!" }));
}
public List <UsuariosDTO> getList()
{
try
{
List <Usuarios> periodosModel = db.Usuarios.Include(x => x.rol).Where(x => x.estado == true).ToList();
List <UsuariosDTO> responseList = new List <UsuariosDTO>();
//Mapeo de clase
periodosModel.ForEach(x =>
{
UsuariosDTO response = new UsuariosDTO();
response.nombre = x.nombre;
response.apellido = x.apellido;
response.ciudad = x.ciudad;
response.correo = x.correo;
response.telefono = x.telefono;
response.rol.nombre = x.rol.nombre;
response.rol.id = x.rol.id;
responseList.Add(response);
});
return(responseList);
}
catch (Exception)
{
throw;
}
}
private UsuarioViewModel DtoToViewModel(UsuariosDTO m_usuarioDTO)
{
UsuarioViewModel m_usuarioVM = new UsuarioViewModel();
m_usuarioVM.UsuarioId = m_usuarioDTO.UsuarioId;
m_usuarioVM.Login = m_usuarioDTO.Login;
m_usuarioVM.TipoUsuarioId = m_usuarioDTO.TipoUsuarioId;
m_usuarioVM.Password = m_usuarioDTO.Password;
m_usuarioVM.ApePaterno = m_usuarioDTO.ApePaterno;
m_usuarioVM.ApeMaterno = m_usuarioDTO.ApeMaterno;
m_usuarioVM.Nombres = m_usuarioDTO.Nombres;
m_usuarioVM.DocumentoIdentidadId = m_usuarioDTO.DocumentoIdentidadId;
m_usuarioVM.NumeroDoc = m_usuarioDTO.NumeroDoc;
m_usuarioVM.FechaNacimiento = m_usuarioDTO.FechaNacimiento;
m_usuarioVM.Email = m_usuarioDTO.Email;
m_usuarioVM.Celular = m_usuarioDTO.Celular;
m_usuarioVM.DocReferencia = m_usuarioDTO.DocReferencia;
m_usuarioVM.FinVigencia = m_usuarioDTO.FinVigencia;
m_usuarioVM.FechaUltimoLogueo = m_usuarioDTO.FechaUltimoLogueo;
m_usuarioVM.EstadoId = m_usuarioDTO.EstadoId;
m_usuarioVM.EstadoNombre = m_usuarioDTO.EstadoNombre;
m_usuarioVM.UsuarioRegistro = m_usuarioDTO.UsuarioRegistro;
m_usuarioVM.FechaRegistro = m_usuarioDTO.FechaRegistro;
m_usuarioVM.UsuarioModificacionRegistro = m_usuarioDTO.UsuarioModificacionRegistro;
m_usuarioVM.FechaModificacionRegistro = m_usuarioDTO.FechaModificacionRegistro;
m_usuarioVM.UbigeoNavalId = m_usuarioDTO.UbigeoNavalId;
m_usuarioVM.ZonaNaval = m_usuarioDTO.ZonaNaval;
m_usuarioVM.Dependencia = m_usuarioDTO.Dependencia;
m_usuarioVM.AvatarPath = m_usuarioDTO.AvatarPath;
return(m_usuarioVM);
}
public override async Task GrantResourceOwnerCredentials(OAuthGrantResourceOwnerCredentialsContext context)
{
context.OwinContext.Response.Headers.Add("Access-Control-Allow-Origin", new[] { "*" });
UsuariosDTO _usuario = new UsuariosDTO();
try
{
_usuario = (new UsuariosDAO()).SelectUsuarioPorCredenciais(context.UserName, context.Password);
}
catch (Exception ex)
{
context.SetError("error", ex.InnerException.ToString());
}
if (_usuario == null)
{
context.SetError("Falha no login!", "Usuário ou senha inválidos. Caso não se lembre, entre em contato com o administrador!");
return;
}
var identity = new ClaimsIdentity(context.Options.AuthenticationType);
identity.AddClaim(new Claim("idusuario", _usuario.idusuario.ToString()));
identity.AddClaim(new Claim("role", "user"));
context.Validated(identity);
}
public override void Init(object initData)
{
base.Init(initData);
_usuario = initData as UsuariosDTO;
_viejoEmail = _usuario.Email;
_viejoUsuario = _usuario.Usuario;
if (!_usuario.EsRecuperarClave)
{
Clave = _usuario.Clave;
VerificacionClave = _usuario.Clave;
}
Usuario = _usuario.Usuario;
Email = _usuario.Email;
if (!string.IsNullOrWhiteSpace(_usuario.DeviceId))
{
AgregarDeviceId = _usuario.DeviceId.Trim() == App.DeviceId.Trim();
}
//AsociaDeviceId = await CrossFingerprint.Current.IsAvailableAsync();
AsociaDeviceId = false;
}
public async Task <UsuariosDTO> VerificarSiUsuarioExisteYPertenecesAlEmail(Usuarios usuarioParaVerificar)
{
UsuariosDTO usuarioExistente = await(from usuario in _context.Usuarios
where usuario.Usuario.Trim() == usuarioParaVerificar.Usuario.Trim() &&
usuario.Email.Trim().ToUpper() == usuarioParaVerificar.Email.Trim().ToUpper()
select new UsuariosDTO
{
Consecutivo = usuario.Consecutivo,
Usuario = usuario.Usuario,
Creacion = usuario.Creacion,
CodigoTipoPerfil = usuario.CodigoTipoPerfil,
Email = usuario.Email,
CodigoPlanUsuario = usuario.CodigoPlanUsuario,
Personas = usuario.Personas.Where(x => x.CodigoUsuario == usuario.Consecutivo)
.Select(x => new PersonasDTO
{
Consecutivo = x.Consecutivo,
Nombres = x.Nombres,
Apellidos = x.Apellidos,
CodigoIdioma = x.CodigoIdioma,
}).ToList(),
})
.AsNoTracking()
.FirstOrDefaultAsync();
return(usuarioExistente);
}
public async Task <IActionResult> InsertAsync(UsuariosDTO modelDto)
{
Response <bool> response = new Response <bool>();
try
{
if (modelDto == null)
{
return(BadRequest());
}
response = await _Application.InsertAsync(modelDto);
if (response.IsSuccess)
{
response.ReponseCode = response.ReponseCode = (int)HttpStatusCode.OK;
return(Ok(response));
}
else
{
response.ReponseCode = response.ReponseCode = (int)HttpStatusCode.PreconditionFailed;
return(BadRequest(response));
}
}
catch (Exception ex)
{
response.Data = false;
response.IsSuccess = false;
response.ReponseCode = (int)HttpStatusCode.InternalServerError;
response.Message = ex.Message;
return(BadRequest(response));
}
}
public List <UsuariosDTO> Listar_grilla_inicial(UsuariosDTO ent)
{
List <UsuariosDTO> lst = new List <UsuariosDTO>();
using (SqlConnection connection = Conectar())
{
try
{
ComandoSP("usp_UsuariosConsultarListaInicial", connection);
using (SqlDataReader reader = comando.ExecuteReader())
{
while (reader.Read())
{
lst.Add(new UsuariosDTO(reader));
}
}
}
catch (SqlException ex)
{
throw new Exception("Clase DataAccess: " + Nombre_Clase + "\r\n" + "Descripción: " + ex.Message);
}
finally
{
connection.Dispose();
}
}
return(lst);
}
public async Task <UsuariosDTO> VerificarUsuarioConDeviceID(Usuarios usuarioParaVerificar)
{
UsuariosDTO usuarioVerificado = await(from usuario in _context.Usuarios
where usuario.DeviceId.Trim() == usuarioParaVerificar.DeviceId.Trim()
select new UsuariosDTO
{
Consecutivo = usuario.Consecutivo,
Usuario = usuario.Usuario,
Clave = usuario.Clave,
Creacion = usuario.Creacion,
CodigoTipoPerfil = usuario.CodigoTipoPerfil,
Email = usuario.Email,
CodigoPlanUsuario = usuario.CodigoPlanUsuario,
DeviceId = usuario.DeviceId,
CuentaActiva = usuario.CuentaActiva,
Personas = usuario.Personas.Where(x => x.CodigoUsuario == usuario.Consecutivo)
.Select(x => new PersonasDTO
{
Consecutivo = x.Consecutivo,
CodigoIdioma = x.CodigoIdioma,
CodigoPais = x.CodigoPais,
}).ToList(),
PlanesUsuarios = new PlanesUsuariosDTO
{
Consecutivo = usuario.PlanesUsuarios.Consecutivo,
CodigoPlan = usuario.PlanesUsuarios.CodigoPlan,
Adquisicion = usuario.PlanesUsuarios.Adquisicion,
Vencimiento = usuario.PlanesUsuarios.Vencimiento,
NumeroCategoriasUsadas = usuario.PlanesUsuarios.NumeroCategoriasUsadas,
Planes = new PlanesDTO
{
Consecutivo = usuario.PlanesUsuarios.Planes.Consecutivo,
Creacion = usuario.PlanesUsuarios.Planes.Creacion,
Precio = usuario.PlanesUsuarios.Planes.Precio,
CodigoPeriodicidad = usuario.PlanesUsuarios.Planes.CodigoPeriodicidad,
PlanDefault = usuario.PlanesUsuarios.Planes.PlanDefault,
VideosPerfil = usuario.PlanesUsuarios.Planes.VideosPerfil,
ServiciosChat = usuario.PlanesUsuarios.Planes.ServiciosChat,
ConsultaCandidatos = usuario.PlanesUsuarios.Planes.ConsultaCandidatos,
DetalleCandidatos = usuario.PlanesUsuarios.Planes.DetalleCandidatos,
ConsultaGrupos = usuario.PlanesUsuarios.Planes.ConsultaGrupos,
DetalleGrupos = usuario.PlanesUsuarios.Planes.DetalleGrupos,
ConsultaEventos = usuario.PlanesUsuarios.Planes.ConsultaEventos,
CreacionAnuncios = usuario.PlanesUsuarios.Planes.CreacionAnuncios,
EstadisticasAnuncios = usuario.PlanesUsuarios.Planes.EstadisticasAnuncios,
Modificacion = usuario.PlanesUsuarios.Planes.Modificacion,
CodigoTipoPerfil = usuario.PlanesUsuarios.Planes.CodigoTipoPerfil,
TiempoPermitidoVideo = usuario.PlanesUsuarios.Planes.TiempoPermitidoVideo,
NumeroCategoriasPermisibles = usuario.PlanesUsuarios.Planes.NumeroCategoriasPermisibles,
CodigoArchivo = usuario.PlanesUsuarios.Planes.CodigoArchivo,
NumeroAparicionesAnuncio = usuario.PlanesUsuarios.Planes.NumeroAparicionesAnuncio,
NumeroDiasVigenciaAnuncio = usuario.PlanesUsuarios.Planes.NumeroDiasVigenciaAnuncio,
DescripcionIdiomaBuscado = usuario.PlanesUsuarios.Planes.PlanesContenidos.Where(y => y.CodigoIdioma == usuario.Personas.Where(x => x.CodigoUsuario == usuario.Consecutivo).Select(x => x.CodigoIdioma).FirstOrDefault()).Select(y => y.Descripcion).FirstOrDefault(),
}
}
}).AsNoTracking()
.FirstOrDefaultAsync();
return(usuarioVerificado);
}
public async Task <Response <bool> > UpdateAsync(UsuariosDTO modelDto)
{
var response = new Response <bool>();
try
{
var resp = _mapper.Map <Usuarios>(modelDto);
response.Data = await _Domain.UpdateAsync(resp);
if (response.Data)
{
response.IsSuccess = true;
response.Message = "Registro Exitoso!";
}
}
catch (Exception ex)
{
response.Data = false;
response.IsSuccess = false;
response.Message = ex.Message;
_logger.LogError(ex.Message, ex);
}
return(response);
}
/// <summary>
/// Método que consulta si un correo ya se encuentra registrado en la tabla usuarios
/// </summary>
/// <param name="modelDto">Se manda los datos para el logueo en la app</param>
/// <returns>Retorna una entidad de Usuarios</returns>
public async Task <Response <UsuariosDTO> > LoginAsync(UsuariosDTO modelDto)
{
var response = new Response <UsuariosDTO>();
try
{
var resp = _mapper.Map <Usuarios>(modelDto);
var model = await _Domain.LoginAsync(resp);
response.Data = _mapper.Map <UsuariosDTO>(model);
if (response.Data != null)
{
response.IsSuccess = true;
response.Message = "Consulta Exitosa!";
}
}
catch (Exception ex)
{
response.Data = null;
response.IsSuccess = false;
response.Message = ex.Message;
//Manejo de excepciones en el Log
_logger.LogError(ex.Message, ex);
}
return(response);
}
/// <summary>
/// Método que nos permite registrar un nuevo usuario en el sistema.
/// </summary>
/// <param name="usuarioNew">Objeto tipo usuario a registrar</param>
/// <returns>Id del usuario registrado</returns>
public static async Task <int> RegistrarUsuario(UsuariosDTO usuarioNew)
{
Usuarios user = null;
int result = 0;
try
{
using (OneCoreAdminRepository _repo = new OneCoreAdminRepository())
{
user = new Usuarios()
{
usuario = usuarioNew.usuario,
contrasena = Encrypting.Encrypt(usuarioNew.contrasena),
estatus = usuarioNew.estatus,
sexo = usuarioNew.sexo,
correo = usuarioNew.correo,
fechaCreacion = DateTime.Now
};
result = await _repo.AddUserAsync(user);
Loggers.WriteInfo(string.Format("SeguridadBL.RegistrarUsuario: Se registro el usuario {0} de forma exitosa", usuarioNew.usuario));
return(result);
}
}
catch (Exception ex)
{
throw ex;
}
}
/// <summary>
/// Método que nos permite actualizar la información de un usuario en particular.
/// </summary>
/// <param name="usuarioUpdate">Objeto tipo usuario por actualizar</param>
/// <returns>Número de registros actualizados</returns>
public static async Task <int> ActualizarUsuario(UsuariosDTO usuarioUpdate)
{
Usuarios user = null;
int result = 0;
try
{
using (OneCoreAdminRepository _repo = new OneCoreAdminRepository())
{
user = new Usuarios()
{
idUsuario = usuarioUpdate.idUsuario,
usuario = usuarioUpdate.usuario,
contrasena = Encrypting.Encrypt(usuarioUpdate.contrasena),
estatus = usuarioUpdate.estatus,
sexo = usuarioUpdate.sexo,
correo = usuarioUpdate.correo
};
result = await _repo.UpdateUserAsync(user);
Loggers.WriteInfo(string.Format("SeguridadBL.RegistrarUsuario: Se actualizo el usuario {0} de forma exitosa", usuarioUpdate.usuario));
return(result);
}
}
catch (Exception ex)
{
throw ex;
}
}
public UsuariosDTO confirmUser(dynamic result, string correo, string rol)
{
try
{
UsuariosDTO response = new UsuariosDTO();
if (result.Succeeded)
{
int rolId = Int32.Parse(rol);
var role = db.Roles.FirstOrDefault(x => x.id == rolId);
var userModel = db.Usuarios.Where(x => x.correo.Equals(correo)).FirstOrDefault();
Usuarios model = RegisterRole(userModel, role);
model = db.Usuarios.FirstOrDefault(x => x.correo.Equals(model.correo));
response = Find(model.id);
}
return(response);
//else
//{
// List<string> errors = new List<string>();
// foreach (var error in result.Errors)
// {
// errors.Add(error);
// }
//}
}
catch (Exception)
{
throw;
}
}
public IActionResult CreateUsuario([FromBody] UsuariosDTO usuariosDTO)
{
if (usuariosDTO == null)
{
return(BadRequest(ModelState));
}
else if (_UsuariosRepo.ExisteUsuario(usuariosDTO.Correo))
{
ModelState.AddModelError("", "El usuario ya existe");
return(StatusCode(404, ModelState));
}
var usuario = _Mapper.Map <Usuarios>(usuariosDTO);
int idUser = _UsuariosRepo.CreateUsuario(usuario);
if (idUser == 0)
{
ModelState.AddModelError("", "El usuario" + usuariosDTO.Correo + "no se pudo crear");
return(StatusCode(500, ModelState));
}
return(Ok(idUser));
}
public UsuariosDTO ObtenerDatosUsuario(string usu, string pass)
{
UsuariosDTO usuario = new UsuariosDTO();
Dictionary <String, object> parametros = new Dictionary <string, object>();
parametros.Add("@usuario", usu);
parametros.Add("@pass", pass);
List <Dictionary <string, object> > resultados = new DBConexion().consultarSP(new ConexionDTO()
{
procedimiento = "UsuariosSession",
Parametros = parametros
});
usuario = (from q in resultados
select new UsuariosDTO()
{
UsuarioId = (int)q["UsuarioId"],
UsuarioRol = (int)q["UsuarioRol"],
UsuarioNombre = (string)q["UsuarioNombre"],
UsuarioApellido = (string)q["UsuarioApellido"]
}).FirstOrDefault();
return(usuario);
}
/// <summary>
/// OBTIENE UN USUARIO CON SUS RELACIONES, DEPENDIENDO SI DESEA UTILIZARLAS O NO.
/// </summary>
/// <param name="incluir"></param>
/// <param name="lstUsuarios"></param>
/// <returns>LISTA DE USUARIOS MAPEADOS CON DTO</returns>
private async Task <UsuariosDTO> ObtenerUsuariosRelaciones(
UsuariosEntidad usuario,
IncluirUsuariosDTO incluir = null)
{
Guid UsuarioActual = Guid.Empty;
UsuariosDTO usuarioDTO = new UsuariosDTO();
if (usuario != null)
{
usuarioDTO = new UsuariosDTO
{
Id = usuario.Id,
Usuario = usuario.UserName,
Email = usuario.Email,
FechaCreacion = usuario.FechaCreacion,
Estatus = usuario.Estatus,
Roles = new List <RolesDTO>(),
};
if (incluir.Role)
{
usuarioDTO.Roles = await ObtenerRolesUsuarioAsync(usuario);
}
}
return(usuarioDTO);
}
public async Task <ActionResult> ConfirmRegistration(UsuariosDTO userToValidate)
{
Result <Object> result = new Result <Object>();
try
{
AuthenticateServices service = new AuthenticateServices();
WrapperSimpleTypesDTO emailExist = await service.VerificarSiEmailYaExiste(userToValidate);
if (emailExist == null || emailExist.Existe)
{
result.Success = false;
result.Message = "NOTI_EMAIL_REGISTERED";
return(Json(result, JsonRequestBehavior.AllowGet));
}
WrapperSimpleTypesDTO userExist = await service.VerificarSiUsuarioYaExiste(userToValidate);
if (userExist == null || userExist.Existe)
{
result.Success = false;
result.Message = "NOTI_USER_REGISTERED";
return(Json(result, JsonRequestBehavior.AllowGet));
}
return(Json(result, JsonRequestBehavior.AllowGet));
}
catch (Exception ex)
{
result.Success = false;
result.Message = ex.Message;
return(Json(result, JsonRequestBehavior.AllowGet));
}
}
async Task IniciarSesionUsuarioRegistrado(UsuariosDTO usuario)
{
if (IsNotConnected)
{
return;
}
UsuariosDTO usuarioVerificado = await _authService.VerificarUsuario(usuario);
if (usuarioVerificado != null && (usuarioVerificado.TipoPerfil == TipoPerfil.Anunciante || usuarioVerificado.TipoPerfil == TipoPerfil.Administrador))
{
await CoreMethods.DisplayAlert(SportsGoResources.TituloAlerta, SportsGoResources.UsuarioNoExiste, "OK");
return;
}
if (usuarioVerificado != null && usuarioVerificado.Consecutivo != 0)
{
if (usuarioVerificado.CuentaActiva == 0)
{
await CoreMethods.DisplayAlert(SportsGoResources.TituloAlerta, SportsGoResources.CuentaNoActiva, "OK");
return;
}
await ConfigurarTabPrincipal(usuarioVerificado);
}
else
{
await CoreMethods.DisplayAlert(SportsGoResources.TituloAlerta, SportsGoResources.UsuarioNoExiste, "OK");
}
}
public HttpResponseMessage postUsuario([FromBody] UsuariosDTO Usuario)
{
// Inicializando mensagem.
HttpResponseMessage _response = new HttpResponseMessage();
// Validando modelo de dados
if (!ModelState.IsValid)
{
//Criando error response se o modelo estiver inválido.
_response = Request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState);
return(_response);
}
try
{
//Inserindo usuário no banco de dados
string msg = (new UsuariosDAO().InsertUsuario(Usuario));
//Criando mensagem de sucesso!
_response = Request.CreateResponse(HttpStatusCode.OK, msg);
}
//Pegando error
catch (Exception ex)
{
// Criando mensagem de erro!
_response = Request.CreateErrorResponse(HttpStatusCode.BadRequest, ex);
}
//Retornando mensagem de sucesso!
return(_response);
}
public HttpResponseMessage getUsuario()
{
// Inicializando mensagem.
HttpResponseMessage _response = new HttpResponseMessage();
try
{
//Obtendo idUsuario
int idUsuario = (new SessaoDAO().SelectIdUsuario());
// Obtendo usuário pelo o id.
UsuariosDTO _usuario = (new UsuariosDAO().SelectUsuario(idUsuario));
// Criando response de sucesso com o usuário.
_response = Request.CreateResponse(HttpStatusCode.OK, _usuario);
}
//Pegando erro.
catch (Exception ex)
{
//Criando mensagem de erro
_response = Request.CreateErrorResponse(HttpStatusCode.BadRequest, ex);
}
//Retornando mensagem.
return(_response);
}
public async Task <IHttpActionResult> Registrar(RequestUsuariosViewModel requestRegistrar)
{
try
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
UsuariosDTO usuarioNew = new UsuariosDTO()
{
usuario = requestRegistrar.usuario,
contrasena = requestRegistrar.contrasena,
estatus = requestRegistrar.estatus,
sexo = requestRegistrar.sexo,
correo = requestRegistrar.correo
};
int result = await SeguridadBL.RegistrarUsuario(usuarioNew);
ResponseProcessViewModel response = new ResponseProcessViewModel()
{
mensaje = result > 0 ? MENSAJE_EXITO : MENSAJE_FALLO,
idUsuario = result
};
return(Ok(response));
}
catch (Exception ex)
{
return(InternalServerError(ex));
}
}
public UsuariosDTO GetPk(int i)
{
UsuariosDTO uD = new UsuariosDTO();
usuarios u = db.usuarios.Where(t => t.codigo == i).FirstOrDefault();
Mapper.Map(u, uD);
return(uD);
}
public int InsertUsuario(RegisterDTO Register)
{
UsuariosDTO _usuario = PreparaUsuario(Register);
DbTreino.Add(_usuario);
DbTreino.SaveChanges();
return(_usuario.IDUsuario);
}
public void Delete(UsuariosDTO user)
{
//var user = Authenticate(model.Login,model.Password);
// user.SetPassword(newPassword, confirmNewPassword);
// user.Validate();
_repository.Delete(user);
}
public async Task <IActionResult> Login(UsuariosDTO usuariosDTO)
{
//usar en la view un validationsummary
//Submit
if (!ModelState.IsValid)
{
return(RedirectToAction("Index"));
}
string sMailInput;
string sPasswordInput;
string sMailBase;
string sPasswordBase;
string sNombreBase;
string sIdEmpresa;
sMailInput = usuariosDTO.Mail;
sPasswordInput = usuariosDTO.Password;
var cliente = new RestSharp.RestClient("https://localhost:44331/api/Empresas/GetEmpresasByMail/" + sMailInput);
var request = new RestSharp.RestRequest(RestSharp.Method.GET);
//var dto = cliente.Execute<EmpresasDTO>(request, Method.OPTIONS).Data; romero porque no me mapeo el objeto tuve que sacarlo asi
var dto = cliente.Execute <object>(request, Method.GET).Data;
var x = JsonConvert.SerializeObject(dto);
var jsonObj = JsonConvert.DeserializeObject <EmpresasDTO>(x);
ViewBag.MensajeLogin = "******";
if (jsonObj != null)
{
sMailBase = jsonObj.Email;
sPasswordBase = jsonObj.Password;
sNombreBase = jsonObj.Nombre;
sIdEmpresa = jsonObj.IdEmpresa.ToString();
if ((sMailBase == sMailInput) && (sPasswordBase == sPasswordInput))
{
ViewBag.MensajeLogin = "******";
await Autenticar(sMailInput, sNombreBase, sIdEmpresa);
return(RedirectToAction("Edit", "Empresas"));
}
else
{
ViewBag.MensajeLogin = "******";
}
}
return(View());
}
//Query para retornar todos usuários.
public UsuariosDTO SelectUsuarioPorCredenciais(string usuario, string senha)
{
//Selecinando o usuário e colocando em um array.
UsuariosDTO _usuario = dbCurso.Usuarios
.Where((x => x.usuario == usuario && x.senha == senha))
.FirstOrDefault();
//Retornando array de usuário.
return(_usuario);
}
//Query para retornar um usuário
public UsuariosDTO SelectUsuario(int idusuario)
{
//Selecinando o usuário e colocando em um array.
UsuariosDTO _usuario = dbCurso.Usuarios
.Where((x => x.idusuario == idusuario))
.FirstOrDefault();
//Retornando array de usuário.
return(_usuario);
}
