public AuthService(AuthenticateRepository authenticateRepository,
SigningConfigurations signingConfigurations,
TokenConfiguration tokenConfiguration)
{
_authenticateRepository = authenticateRepository;
_signingConfigurations = signingConfigurations;
_tokenConfiguration = tokenConfiguration;
}
public async Task <List <TiposPerfiles> > ListarTiposPerfiles()
{
using (SportsGoEntities context = new SportsGoEntities(false))
{
AuthenticateRepository authenticateRepo = new AuthenticateRepository(context);
List <TiposPerfiles> listaTiposPerfiles = await authenticateRepo.ListarTiposPerfiles();
return(listaTiposPerfiles);
}
}
public async Task <WrapperSimpleTypesDTO> VerificarSiEmailYaExiste(Usuarios emailParaVerificar)
{
using (SportsGoEntities context = new SportsGoEntities(false))
{
AuthenticateRepository authenticateRepo = new AuthenticateRepository(context);
WrapperSimpleTypesDTO wrapperExisteEmail = await authenticateRepo.VerificarSiEmailYaExiste(emailParaVerificar);
return(wrapperExisteEmail);
}
}
public async Task <WrapperSimpleTypesDTO> VerificarSiCuentaEstaActiva(Usuarios usuarioParaVerificar)
{
using (SportsGoEntities context = new SportsGoEntities(false))
{
AuthenticateRepository authenticateRepo = new AuthenticateRepository(context);
WrapperSimpleTypesDTO wrapperVerificarCuentaActiva = await authenticateRepo.VerificarSiCuentaEstaActiva(usuarioParaVerificar);
return(wrapperVerificarCuentaActiva);
}
}
public async Task AuthenticateRepository_BuscarFormatoCorreoPorCodigoIdioma_ShouldSearch()
{
using (SportsGoEntities context = new SportsGoEntities(false))
{
AuthenticateRepository authenticateRepo = new AuthenticateRepository(context);
string formatoTexto = await authenticateRepo.BuscarFormatoCorreoPorCodigoIdioma(1, TipoFormatosEnum.ConfirmacionCuenta);
Assert.IsNotNull(formatoTexto);
}
}
public async Task <UsuariosDTO> VerificarUsuarioConEmailUsuarioYDeviceId(Usuarios usuarioParaVerificar)
{
using (SportsGoEntities context = new SportsGoEntities(false))
{
AuthenticateRepository authenticateRepo = new AuthenticateRepository(context);
UsuariosDTO usuarioExistente = await authenticateRepo.VerificarUsuarioConEmailUsuarioYDeviceId(usuarioParaVerificar);
if (usuarioExistente != null)
{
Usuarios usuarioModificado = await authenticateRepo.ActualizarFechaUltimoAcceso(usuarioExistente.Consecutivo);
await context.SaveChangesAsync();
}
return(usuarioExistente);
}
}
public async Task AuthenticateRepository_VerificarSiEmailYaExiste_ShouldVerify()
{
using (SportsGoEntities context = new SportsGoEntities(false))
{
AuthenticateRepository authenticateRepo = new AuthenticateRepository(context);
Usuarios usuarioParaCrear = new Usuarios
{
Email = "*****@*****.**"
};
WrapperSimpleTypesDTO wrapperExisteEmail = await authenticateRepo.VerificarSiEmailYaExiste(usuarioParaCrear);
Assert.IsNotNull(wrapperExisteEmail);
Assert.IsTrue(wrapperExisteEmail.Existe);
Assert.AreNotEqual(wrapperExisteEmail.NumeroRegistrosAfectados, 0);
}
}
public async Task AuthenticateRepository_VerificarUsuarios_ShouldVerify()
{
using (SportsGoEntities context = new SportsGoEntities(false))
{
AuthenticateRepository authenticateRepo = new AuthenticateRepository(context);
Usuarios usuarioParaVerificar = new Usuarios
{
Usuario = "Sergio",
Clave = "Sergio"
};
UsuariosDTO usuarioVerificado = await authenticateRepo.VerificarUsuario(usuarioParaVerificar);
Assert.IsNotNull(usuarioVerificado);
Assert.AreNotEqual(usuarioVerificado.Consecutivo, 0);
}
}
public async Task <WrapperSimpleTypesDTO> ModificarUsuario(Usuarios usuarioParaModificar)
{
using (SportsGoEntities context = new SportsGoEntities(false))
{
AuthenticateRepository authenticateRepo = new AuthenticateRepository(context);
Usuarios usuarioExistente = await authenticateRepo.ModificarUsuario(usuarioParaModificar);
WrapperSimpleTypesDTO wrapperModificarUsuario = new WrapperSimpleTypesDTO();
wrapperModificarUsuario.NumeroRegistrosAfectados = await context.SaveChangesAsync();
if (wrapperModificarUsuario.NumeroRegistrosAfectados > 0)
{
wrapperModificarUsuario.Exitoso = true;
}
return(wrapperModificarUsuario);
}
}
public async Task AuthenticateRepository_ActualizarFechaAcceso_ShouldUpdate()
{
using (SportsGoEntities context = new SportsGoEntities(false))
{
AuthenticateRepository authenticateRepo = new AuthenticateRepository(context);
Usuarios usuarioParaVerificar = new Usuarios
{
Usuario = "Sergio",
Clave = "Sergio"
};
UsuariosDTO usuarioVerificado = await authenticateRepo.VerificarUsuario(usuarioParaVerificar);
Usuarios usuarioExistente = await authenticateRepo.ActualizarFechaUltimoAcceso(usuarioParaVerificar.Consecutivo);
Assert.IsNotNull(usuarioVerificado);
Assert.AreNotEqual(usuarioVerificado.Consecutivo, 0);
Assert.AreEqual(usuarioVerificado.UltimoAcceso.Value.Date, DateTime.Today);
}
}
public ActionResult Login(AuthenticationViewModel model)
{
if (ModelState.IsValid)
{
bool AuthUsers = AuthenticateRepository.Authenticate(model);
if (AuthUsers == true)
{
FormsAuthentication.SetAuthCookie(model.Username, false);
Session["session"] = "test";
return(RedirectToAction("Index", "Home"));
}
else
{
return(PartialView(model));
}
}
{
return(PartialView(model));
}
}
public async Task <UsuariosDTO> VerificarUsuario(Usuarios usuarioParaVerificar)
{
using (SportsGoEntities context = new SportsGoEntities(false))
{
AuthenticateRepository authenticateRepo = new AuthenticateRepository(context);
UsuariosDTO usuarioVerificado = await authenticateRepo.VerificarUsuario(usuarioParaVerificar);
if (usuarioVerificado != null)
{
Usuarios usuarioExistente = await authenticateRepo.ActualizarFechaUltimoAcceso(usuarioVerificado.Consecutivo);
// Se vencio el plan
if (usuarioVerificado.PlanesUsuarios.Vencimiento < DateTime.Now && usuarioVerificado.TipoPerfil != TipoPerfil.Administrador)
{
PlanesBusiness planBusiness = new PlanesBusiness();
WrapperSimpleTypesDTO wrapperCambiarPlan = await planBusiness.CambiarPlanUsuarioADefaultPerfilPorVencimiento(usuarioVerificado.PlanesUsuarios);
usuarioVerificado = await authenticateRepo.VerificarUsuario(usuarioParaVerificar);
}
await context.SaveChangesAsync();
if (usuarioVerificado.TipoPerfil == TipoPerfil.Administrador)
{
AdministracionRepository adminRepo = new AdministracionRepository(context);
ImagenesPerfilAdministradores imagenPerfilBuscada = await adminRepo.BuscarImagenPerfilAdministrador(usuarioVerificado.Consecutivo);
if (imagenPerfilBuscada != null)
{
usuarioVerificado.CodigoImagenPerfilAdmin = imagenPerfilBuscada.CodigoArchivo;
}
}
}
return(usuarioVerificado);
}
}
public ActionResult <User> AuthenticateLogInCredentials(string userName, string password)
{
IAuthenticateRepository repository = new AuthenticateRepository();
{
if (userName != null && userName != "")
{
if (password != null && password != "")
{
bool authLogInResult = repository.AuthenticateLogInCredentials(userName, password);
if (authLogInResult)
{
return(Ok(authLogInResult));
}
else
{
return(Problem(title: "Auth Failure", type: "Error", detail: "Couldn't Authenticate Login Credentials."));
}
}
return(NotFound());
}
return(NotFound());
}
}
public async Task <WrapperSimpleTypesDTO> CrearGrupo(Grupos grupoParaCrear, string urlLogo, string urlBanner)
{
using (SportsGoEntities context = new SportsGoEntities(false))
{
PlanesRepository planRepo = new PlanesRepository(context);
int?codigoPlanDefault = await planRepo.BuscarCodigoPlanDefault(TipoPerfil.Representante);
if (!codigoPlanDefault.HasValue)
{
throw new InvalidOperationException("No existe un plan default para los grupo!.");
}
PlanesUsuarios planUsuarioDefault = new PlanesUsuarios
{
CodigoPlan = codigoPlanDefault.Value,
Adquisicion = DateTime.Now,
Vencimiento = DateTime.MaxValue
};
grupoParaCrear.Personas.Usuarios.CuentaActiva = 0;
grupoParaCrear.Personas.Usuarios.PlanesUsuarios = planUsuarioDefault;
grupoParaCrear.Personas.Usuarios.TipoPerfil = grupoParaCrear.Personas.TipoPerfil;
grupoParaCrear.Personas.Candidatos = null;
grupoParaCrear.Personas.Paises = null;
grupoParaCrear.Personas.Idiomas = null;
grupoParaCrear.Personas.Anunciantes = null;
grupoParaCrear.Personas.Grupos = null;
grupoParaCrear.Personas.Representantes = null;
grupoParaCrear.Personas.Usuarios.Personas = null;
grupoParaCrear.Personas.Paises = null;
grupoParaCrear.Personas.Idiomas = null;
foreach (var categoriaGrupo in grupoParaCrear.CategoriasGrupos)
{
categoriaGrupo.Categorias = null;
}
GruposRepository grupoRepository = new GruposRepository(context);
grupoRepository.CrearGrupo(grupoParaCrear);
WrapperSimpleTypesDTO wrapperCrearGrupo = new WrapperSimpleTypesDTO();
wrapperCrearGrupo.NumeroRegistrosAfectados = await context.SaveChangesAsync();
if (wrapperCrearGrupo.NumeroRegistrosAfectados > 0)
{
wrapperCrearGrupo.Exitoso = true;
wrapperCrearGrupo.ConsecutivoCreado = grupoParaCrear.Consecutivo;
wrapperCrearGrupo.ConsecutivoPersonaCreado = grupoParaCrear.Personas.Consecutivo;
wrapperCrearGrupo.ConsecutivoUsuarioCreado = grupoParaCrear.Personas.Usuarios.Consecutivo;
AuthenticateRepository authenticateRepo = new AuthenticateRepository(context);
string formatoEmail = await authenticateRepo.BuscarFormatoCorreoPorCodigoIdioma(grupoParaCrear.Personas.CodigoIdioma, TipoFormatosEnum.ConfirmacionCuenta);
if (!string.IsNullOrWhiteSpace(formatoEmail))
{
formatoEmail = formatoEmail.Replace(AppConstants.PlaceHolderNombre, grupoParaCrear.Personas.Nombres);
formatoEmail = formatoEmail.Replace(AppConstants.PlaceHolderImagenLogo, urlLogo);
formatoEmail = formatoEmail.Replace(AppConstants.PlaceHolderImagenBanner, urlBanner);
formatoEmail = formatoEmail.Replace(AppConstants.PlaceHolderUrlWeb, URL.UrlWeb);
string urlConfirmacionFormated = string.Format(URL.UrlWeb + @"Authenticate/ConfirmationOfRegistration?ID={0}&Language={1}", grupoParaCrear.Personas.Usuarios.Consecutivo, grupoParaCrear.Personas.CodigoIdioma);
formatoEmail = formatoEmail.Replace(AppConstants.PlaceHolderUrlPaginaConfirmacion, urlConfirmacionFormated);
string tema = string.Empty;
switch (grupoParaCrear.Personas.IdiomaDeLaPersona)
{
case Idioma.Español:
tema = "Confirmacion de registro";
break;
case Idioma.Ingles:
tema = "Confirmation of registration";
break;
case Idioma.Portugues:
tema = "Confirmação da inscrição";
break;
}
// Recordar configurar la cuenta Gmail en este caso para que permita el logeo de manera insegura y poder mandar correos
// https://myaccount.google.com/lesssecureapps?pli=1
CorreoHelper correoHelper = new CorreoHelper(grupoParaCrear.Personas.Usuarios.Email.Trim(), AppConstants.CorreoAplicacion, AppConstants.ClaveCorreoAplicacion);
wrapperCrearGrupo.Exitoso = correoHelper.EnviarCorreoConHTML(formatoEmail, Correo.Gmail, tema, "SportsGo");
}
else
{
throw new InvalidOperationException("No hay formatos parametrizados para la confirmacion de la clave");
}
}
return(wrapperCrearGrupo);
}
}
public async Task <WrapperSimpleTypesDTO> RecuperarClave(Usuarios usuarioParaRecuperar, string urlLogo, string urlBanner)
{
using (SportsGoEntities context = new SportsGoEntities(false))
{
AuthenticateRepository authenticateRepo = new AuthenticateRepository(context);
string nuevaClave = string.Empty;
bool exitoso = false;
UsuariosDTO usuarioExistente = await authenticateRepo.VerificarSiUsuarioExisteYPertenecesAlEmail(usuarioParaRecuperar);
if (usuarioExistente != null)
{
string formatoEmail = await authenticateRepo.BuscarFormatoCorreoPorCodigoIdioma(usuarioExistente.PersonaDelUsuario.CodigoIdioma, TipoFormatosEnum.RecuperacionClave);
if (!string.IsNullOrWhiteSpace(formatoEmail))
{
nuevaClave = Membership.GeneratePassword(10, 2);
Usuarios usuarioModificado = await authenticateRepo.ModificarClave(usuarioExistente.Consecutivo, nuevaClave);
usuarioModificado.CuentaActiva = (int)SiNoEnum.Si;
formatoEmail = formatoEmail.Replace(AppConstants.PlaceHolderNombre, usuarioExistente.PersonaDelUsuario.NombreYApellido);
formatoEmail = formatoEmail.Replace(AppConstants.PlaceHolderUsuario, usuarioExistente.Usuario);
formatoEmail = formatoEmail.Replace(AppConstants.PlaceHolderClave, nuevaClave);
formatoEmail = formatoEmail.Replace(AppConstants.PlaceHolderImagenLogo, urlLogo);
formatoEmail = formatoEmail.Replace(AppConstants.PlaceHolderImagenBanner, urlBanner);
formatoEmail = formatoEmail.Replace(AppConstants.PlaceHolderUrlWeb, URL.UrlWeb);
string tema = string.Empty;
switch (usuarioExistente.PersonaDelUsuario.IdiomaDeLaPersona)
{
case Idioma.Español:
tema = "Recuperacion Contraseña";
break;
case Idioma.Ingles:
tema = "Password Recovery";
break;
case Idioma.Portugues:
tema = "Recuperação de Senha";
break;
}
// Recordar configurar la cuenta Gmail en este caso para que permita el logeo de manera insegura y poder mandar correos
// https://myaccount.google.com/lesssecureapps?pli=1
CorreoHelper correoHelper = new CorreoHelper(usuarioExistente.Email.Trim(), AppConstants.CorreoAplicacion, AppConstants.ClaveCorreoAplicacion);
exitoso = correoHelper.EnviarCorreoConHTML(formatoEmail, Correo.Gmail, tema, "SportsGo");
}
else
{
throw new InvalidOperationException("No hay formatos parametrizados para recuperar la clave");
}
}
WrapperSimpleTypesDTO wrapperRecuperarClave = new WrapperSimpleTypesDTO();
if (exitoso)
{
wrapperRecuperarClave.NumeroRegistrosAfectados = await context.SaveChangesAsync();
}
if (wrapperRecuperarClave.NumeroRegistrosAfectados > 0 && exitoso)
{
wrapperRecuperarClave.ClaveCreada = nuevaClave;
wrapperRecuperarClave.Exitoso = true;
}
return(wrapperRecuperarClave);
}
}
public async Task <WrapperSimpleTypesDTO> CrearCandidato(Candidatos candidatoParaCrear, string urlLogo, string urlBanner)
{
using (SportsGoEntities context = new SportsGoEntities(false))
{
PlanesRepository planRepo = new PlanesRepository(context);
int?codigoPlanDefault = await planRepo.BuscarCodigoPlanDefault(TipoPerfil.Candidato);
if (!codigoPlanDefault.HasValue)
{
throw new InvalidOperationException("No existe un plan default para los candidatos!.");
}
PlanesUsuarios planUsuarioDefault = new PlanesUsuarios
{
CodigoPlan = codigoPlanDefault.Value,
Adquisicion = DateTime.Now,
Vencimiento = DateTime.MaxValue
};
candidatoParaCrear.Personas.Usuarios.CuentaActiva = 0;
candidatoParaCrear.Personas.Usuarios.PlanesUsuarios = planUsuarioDefault;
candidatoParaCrear.Personas.Usuarios.TipoPerfil = candidatoParaCrear.Personas.TipoPerfil;
bool soyMenorDeEdad = DateTimeHelper.DiferenciaEntreDosFechasAños(DateTime.Now, candidatoParaCrear.FechaNacimiento) < AppConstants.MayoriaEdad;
// Si soy menor de edad y no tengo tutor o el tutor no tiene email, explota
if (soyMenorDeEdad && (candidatoParaCrear.CandidatosResponsables == null || string.IsNullOrWhiteSpace(candidatoParaCrear.CandidatosResponsables.Email)))
{
throw new InvalidOperationException("Falta informacion para el tutor, esta persona es menor de edad!.");
}
// Si no requiero tutor no lo guardo
if (soyMenorDeEdad)
{
candidatoParaCrear.CandidatosResponsables.Candidatos = null;
}
else
{
candidatoParaCrear.CandidatosResponsables = null;
}
candidatoParaCrear.Personas.Candidatos = null;
candidatoParaCrear.Personas.Paises = null;
candidatoParaCrear.Personas.Idiomas = null;
candidatoParaCrear.Generos = null;
candidatoParaCrear.Personas.Anunciantes = null;
candidatoParaCrear.Personas.Grupos = null;
candidatoParaCrear.Personas.Representantes = null;
candidatoParaCrear.Personas.Usuarios.Personas = null;
foreach (var categoriaCandidato in candidatoParaCrear.CategoriasCandidatos)
{
categoriaCandidato.Categorias = null;
categoriaCandidato.Candidatos = null;
foreach (var habilidadCandidato in categoriaCandidato.HabilidadesCandidatos)
{
habilidadCandidato.Habilidades = null;
}
}
CandidatosRepository candidatosRepo = new CandidatosRepository(context);
candidatosRepo.CrearCandidato(candidatoParaCrear);
WrapperSimpleTypesDTO wrapperCrearCandidato = new WrapperSimpleTypesDTO();
wrapperCrearCandidato.NumeroRegistrosAfectados = await context.SaveChangesAsync();
if (wrapperCrearCandidato.NumeroRegistrosAfectados > 0)
{
wrapperCrearCandidato.ConsecutivoCreado = candidatoParaCrear.Consecutivo;
wrapperCrearCandidato.ConsecutivoPersonaCreado = candidatoParaCrear.Personas.Consecutivo;
wrapperCrearCandidato.ConsecutivoUsuarioCreado = candidatoParaCrear.Personas.Usuarios.Consecutivo;
AuthenticateRepository authenticateRepo = new AuthenticateRepository(context);
string formatoEmail = await authenticateRepo.BuscarFormatoCorreoPorCodigoIdioma(candidatoParaCrear.Personas.CodigoIdioma, TipoFormatosEnum.ConfirmacionCuenta);
if (!string.IsNullOrWhiteSpace(formatoEmail))
{
formatoEmail = formatoEmail.Replace(AppConstants.PlaceHolderNombre, candidatoParaCrear.Personas.Nombres);
formatoEmail = formatoEmail.Replace(AppConstants.PlaceHolderImagenLogo, urlLogo);
formatoEmail = formatoEmail.Replace(AppConstants.PlaceHolderImagenBanner, urlBanner);
formatoEmail = formatoEmail.Replace(AppConstants.PlaceHolderUrlWeb, URL.UrlWeb);
string urlConfirmacionFormated = string.Format(URL.UrlWeb + @"Authenticate/ConfirmationOfRegistration?ID={0}&Language={1}", candidatoParaCrear.Personas.Usuarios.Consecutivo, candidatoParaCrear.Personas.CodigoIdioma);
formatoEmail = formatoEmail.Replace(AppConstants.PlaceHolderUrlPaginaConfirmacion, urlConfirmacionFormated);
string tema = string.Empty;
switch (candidatoParaCrear.Personas.IdiomaDeLaPersona)
{
case Idioma.Español:
tema = "Confirmacion de registro";
break;
case Idioma.Ingles:
tema = "Confirmation of registration";
break;
case Idioma.Portugues:
tema = "Confirmação da inscrição";
break;
}
string emailParaEnviarConfirmacion = string.Empty;
// Si soy menor de edad el correo de confirmacion va hacia el tutor, si no va normal como siempre
if (soyMenorDeEdad)
{
emailParaEnviarConfirmacion = candidatoParaCrear.CandidatosResponsables.Email.Trim();
}
else
{
emailParaEnviarConfirmacion = candidatoParaCrear.Personas.Usuarios.Email.Trim();
}
// Recordar configurar la cuenta Gmail en este caso para que permita el logeo de manera insegura y poder mandar correos
// https://myaccount.google.com/lesssecureapps?pli=1
CorreoHelper correoHelper = new CorreoHelper(emailParaEnviarConfirmacion, AppConstants.CorreoAplicacion, AppConstants.ClaveCorreoAplicacion);
wrapperCrearCandidato.Exitoso = correoHelper.EnviarCorreoConHTML(formatoEmail, Correo.Gmail, tema, "SportsGo");
}
else
{
throw new InvalidOperationException("No hay formatos parametrizados para la confirmacion de la clave");
}
}
return(wrapperCrearCandidato);
}
}
