public async Task <PlanesUsuarios> ModificarNumeroCategoriasUsadas(int codigoPlanUsuario, int numeroParaAumentarODisminuir)
{
PlanesUsuarios planUsuarioExistente = await _context.PlanesUsuarios.Where(x => x.Consecutivo == codigoPlanUsuario).FirstOrDefaultAsync();
planUsuarioExistente.NumeroCategoriasUsadas += numeroParaAumentarODisminuir;
return(planUsuarioExistente);
}
public async Task <DateTime> CalcularFechaVencimientoPlanUsuario(PlanesUsuarios planParaCalcular)
{
int numeroDiasPeriodicidad = await _context.Planes.Where(x => x.Consecutivo == planParaCalcular.CodigoPlanDeseado)
.Select(x => x.Periodicidades.NumeroDias)
.FirstOrDefaultAsync();
DateTime fechaVencimiento = DateTime.Now.AddDays(numeroDiasPeriodicidad);
return(fechaVencimiento);
}
public async Task <PlanesUsuarios> CambiarDePlanUsuario(PlanesUsuarios planParaModificar)
{
PlanesUsuarios planExistente = await _context.PlanesUsuarios.Where(x => x.Consecutivo == planParaModificar.Consecutivo).FirstOrDefaultAsync();
planExistente.Adquisicion = DateTime.Now;
planExistente.Vencimiento = planParaModificar.Vencimiento;
planExistente.CodigoPlan = planParaModificar.CodigoPlanDeseado;
return(planExistente);
}
public async Task PlanesBusiness_VerificarSiPlanSoportaLaOperacion_ShouldVerify()
{
PlanesBusiness planBusiness = new PlanesBusiness();
PlanesUsuarios planUsuario = new PlanesUsuarios
{
Consecutivo = 2,
TipoOperacionBase = TipoOperacion.MultiplesCategorias
};
WrapperSimpleTypesDTO wrapper = await planBusiness.VerificarSiPlanSoportaLaOperacion(planUsuario);
Assert.IsNotNull(wrapper);
}
public async Task PlanesBusiness_BuscarPlanUsuario_ShouldSearch()
{
PlanesBusiness planesBusiness = new PlanesBusiness();
PlanesUsuarios plan = new PlanesUsuarios
{
Consecutivo = 13,
IdiomaBase = Idioma.Español
};
PlanesUsuariosDTO planUsuario = await planesBusiness.BuscarPlanUsuario(plan);
Assert.IsNotNull(planUsuario);
}
public async Task <WrapperSimpleTypesDTO> VerificarSiPlanSoportaLaOperacion(PlanesUsuarios planUsuarioParaBuscar)
{
using (SportsGoEntities context = new SportsGoEntities(false))
{
PlanesRepository planRepository = new PlanesRepository(context);
bool esPosible = await planRepository.VerificarSiPlanSoportaLaOperacion(planUsuarioParaBuscar, planUsuarioParaBuscar.TipoOperacionBase);
WrapperSimpleTypesDTO wrapperVerificarPlanOperacion = new WrapperSimpleTypesDTO
{
EsPosible = esPosible
};
return(wrapperVerificarPlanOperacion);
}
}
public async Task <IHttpActionResult> BuscarPlanUsuario(PlanesUsuarios planUsuarioParaBuscar)
{
if (planUsuarioParaBuscar == null || planUsuarioParaBuscar.Consecutivo <= 0 || planUsuarioParaBuscar.IdiomaBase == Idioma.SinIdioma)
{
return(BadRequest("planUsuarioParaBuscar vacio y/o invalido!."));
}
try
{
PlanesUsuariosDTO planUsuarioExistente = await _planesBusiness.BuscarPlanUsuario(planUsuarioParaBuscar);
return(Ok(planUsuarioExistente));
}
catch (Exception ex)
{
return(InternalServerError(ex));
}
}
public async Task <IHttpActionResult> VerificarSiPlanSoportaLaOperacion(PlanesUsuarios planUsuarioParaValidar)
{
if (planUsuarioParaValidar == null || planUsuarioParaValidar.Consecutivo <= 0 || planUsuarioParaValidar.TipoOperacionBase == TipoOperacion.SinOperacion)
{
return(BadRequest("planUsuarioParaValidar vacio y/o invalido!."));
}
try
{
WrapperSimpleTypesDTO wrapperVerificarPlanOperacion = await _planesBusiness.VerificarSiPlanSoportaLaOperacion(planUsuarioParaValidar);
return(Ok(wrapperVerificarPlanOperacion));
}
catch (Exception ex)
{
return(InternalServerError(ex));
}
}
public async Task <IHttpActionResult> CambiarDePlanUsuario(PlanesUsuarios planParaCambiar)
{
if (planParaCambiar == null || planParaCambiar.Consecutivo <= 0 || planParaCambiar.CodigoPlanDeseado <= 0)
{
return(BadRequest("planParaCambiar vacio y/o invalido!."));
}
try
{
WrapperSimpleTypesDTO wrapperCambiarDePlanUsuario = await _planesBusiness.CambiarDePlanUsuario(planParaCambiar);
return(Ok(wrapperCambiarDePlanUsuario));
}
catch (Exception ex)
{
return(InternalServerError(ex));
}
}
public async Task <WrapperSimpleTypesDTO> EliminarCategoriaCandidato(CategoriasCandidatos categoriaCandidatoParaBorrar)
{
using (SportsGoEntities context = new SportsGoEntities(false))
{
HabilidadesRepository habilidadesRepo = new HabilidadesRepository(context);
HabilidadesCandidatos habilidadParaBorrar = new HabilidadesCandidatos
{
CodigoCategoriaCandidato = categoriaCandidatoParaBorrar.Consecutivo
};
habilidadesRepo.EliminarMultiplesHabilidadesCandidatosPorCodigoCandidato(habilidadParaBorrar);
CategoriasRepository categoriasRepo = new CategoriasRepository(context);
int?codigoCandidato = await categoriasRepo.BuscarCodigoCandidatoDeUnaCategoriaCandidato(categoriaCandidatoParaBorrar.Consecutivo);
if (!codigoCandidato.HasValue)
{
throw new InvalidOperationException("No se pudo hallar el codigo del candidato para borrar la categoria y modificar el plan!.");
}
categoriasRepo.EliminarCategoriaCandidato(categoriaCandidatoParaBorrar);
PlanesRepository planRepo = new PlanesRepository(context);
int?codigoPlanExistente = await planRepo.BuscarCodigoPlanUsuarioPorCodigoCandidato(codigoCandidato.Value);
if (!codigoPlanExistente.HasValue)
{
throw new InvalidOperationException("No se pudo hallar el plan del candidato para crear la categoria para el!.");
}
// Se "BAJA" el contador de categorias 1
PlanesUsuarios planUsuarioExistente = await planRepo.ModificarNumeroCategoriasUsadas(codigoPlanExistente.Value, -1);
WrapperSimpleTypesDTO wrapperEliminarCategoriaCandidato = new WrapperSimpleTypesDTO();
wrapperEliminarCategoriaCandidato.NumeroRegistrosAfectados = await context.SaveChangesAsync();
if (wrapperEliminarCategoriaCandidato.NumeroRegistrosAfectados > 0)
{
wrapperEliminarCategoriaCandidato.Exitoso = true;
}
return(wrapperEliminarCategoriaCandidato);
}
}
public async Task <PlanesUsuariosDTO> BuscarPlanUsuario(PlanesUsuarios planParaBuscar)
{
IQueryable <PlanesUsuarios> queryPlanUsuario = _context.PlanesUsuarios.Where(x => x.Consecutivo == planParaBuscar.Consecutivo).AsQueryable();
PlanesUsuariosDTO planUsuarioBuscado = await queryPlanUsuario
.Select(x => new PlanesUsuariosDTO
{
Consecutivo = x.Consecutivo,
CodigoPlan = x.CodigoPlan,
Adquisicion = x.Adquisicion,
Vencimiento = x.Vencimiento,
NumeroCategoriasUsadas = x.NumeroCategoriasUsadas,
Planes = new PlanesDTO
{
Consecutivo = x.Planes.Consecutivo,
Creacion = x.Planes.Creacion,
CodigoArchivo = x.Planes.CodigoArchivo,
Precio = x.Planes.Precio,
PrecioEnMonedaFantasma = x.Planes.Precio,
CodigoPeriodicidad = x.Planes.CodigoPeriodicidad,
PlanDefault = x.Planes.PlanDefault,
VideosPerfil = x.Planes.VideosPerfil,
ServiciosChat = x.Planes.ServiciosChat,
ConsultaCandidatos = x.Planes.ConsultaCandidatos,
DetalleCandidatos = x.Planes.DetalleCandidatos,
ConsultaGrupos = x.Planes.ConsultaGrupos,
DetalleGrupos = x.Planes.DetalleGrupos,
ConsultaEventos = x.Planes.ConsultaEventos,
CreacionAnuncios = x.Planes.CreacionAnuncios,
EstadisticasAnuncios = x.Planes.EstadisticasAnuncios,
Modificacion = x.Planes.Modificacion,
TiempoPermitidoVideo = x.Planes.TiempoPermitidoVideo,
CodigoTipoPerfil = x.Planes.CodigoTipoPerfil,
NumeroCategoriasPermisibles = x.Planes.NumeroCategoriasPermisibles,
NumeroAparicionesAnuncio = x.Planes.NumeroAparicionesAnuncio,
NumeroDiasVigenciaAnuncio = x.Planes.NumeroDiasVigenciaAnuncio,
DescripcionIdiomaBuscado = x.Planes.PlanesContenidos.Where(z => z.CodigoIdioma == planParaBuscar.CodigoIdiomaUsuarioBase).Select(y => y.Descripcion).FirstOrDefault()
}
})
.AsNoTracking()
.FirstOrDefaultAsync();
return(planUsuarioBuscado);
}
public async Task <PlanesUsuariosDTO> BuscarPlanUsuario(PlanesUsuarios planUsuarioParaBuscar)
{
using (SportsGoEntities context = new SportsGoEntities(false))
{
PlanesRepository planRepository = new PlanesRepository(context);
PlanesUsuariosDTO planUsuarioExistente = await planRepository.BuscarPlanUsuario(planUsuarioParaBuscar);
int?codigoUsuario = await planRepository.BuscarCodigoUsuarioPorCodigoPlanUsuario(planUsuarioExistente.Consecutivo);
PagosRepository pagosRepo = new PagosRepository(context);
Monedas monedaDelUsuario = await pagosRepo.BuscarMonedaDeUnUsuario(codigoUsuario.Value);
if (monedaDelUsuario.MonedaEnum != MonedasEnum.PesosColombianos)
{
Monedas monedaColombiana = await pagosRepo.BuscarMonedaColombiana();
QueryMoneyExchanger queryExchanger = new QueryMoneyExchanger();
YahooExchangeEntity exchangeEntity = await queryExchanger.QueryMoneyExchange(monedaColombiana.AbreviaturaMoneda, monedaDelUsuario.AbreviaturaMoneda);
if (exchangeEntity != null)
{
monedaDelUsuario.CambioMoneda = exchangeEntity.Query.Results.Rate.Rate;
}
planUsuarioExistente.Planes.Precio *= monedaDelUsuario.CambioMoneda;
}
try
{
// No es obligatorio para el paso que actualize el cambio de moneda
await context.SaveChangesAsync();
}
catch (Exception)
{
}
return(planUsuarioExistente);
}
}
public async Task <WrapperSimpleTypesDTO> CrearCategoriaCandidatos(CategoriasCandidatos categoriaCandidatoParaCrear)
{
using (SportsGoEntities context = new SportsGoEntities(false))
{
PlanesRepository planRepo = new PlanesRepository(context);
int?codigoPlanExistente = await planRepo.BuscarCodigoPlanUsuarioPorCodigoCandidato(categoriaCandidatoParaCrear.CodigoCandidato);
if (!codigoPlanExistente.HasValue)
{
throw new InvalidOperationException("No se pudo hallar el plan del candidato para crear la categoria para el!.");
}
// Se "SUBE" el contador de categorias 1
PlanesUsuarios planUsuarioExistente = await planRepo.ModificarNumeroCategoriasUsadas(codigoPlanExistente.Value, 1);
if (categoriaCandidatoParaCrear.HabilidadesCandidatos != null && categoriaCandidatoParaCrear.HabilidadesCandidatos.Count > 0)
{
categoriaCandidatoParaCrear.HabilidadesCandidatos = categoriaCandidatoParaCrear.HabilidadesCandidatos.Where(x => x.NumeroEstrellas > 0).ToList();
}
CategoriasRepository categoriasRepo = new CategoriasRepository(context);
categoriasRepo.CrearCategoriaCandidatos(categoriaCandidatoParaCrear);
WrapperSimpleTypesDTO wrapperCrearCategoriaCandidato = new WrapperSimpleTypesDTO();
wrapperCrearCategoriaCandidato.NumeroRegistrosAfectados = await context.SaveChangesAsync();
if (wrapperCrearCategoriaCandidato.NumeroRegistrosAfectados > 0)
{
wrapperCrearCategoriaCandidato.Exitoso = true;
wrapperCrearCategoriaCandidato.ConsecutivoCreado = categoriaCandidatoParaCrear.Consecutivo;
}
return(wrapperCrearCategoriaCandidato);
}
}
internal async Task <WrapperSimpleTypesDTO> CambiarPlanUsuarioADefaultPerfilPorVencimiento(PlanesUsuariosDTO planesUsuariosVencidoParaCambiar)
{
using (SportsGoEntities context = new SportsGoEntities(false))
{
PlanesRepository planesRepo = new PlanesRepository(context);
Planes planParaBuscar = new Planes
{
Consecutivo = planesUsuariosVencidoParaCambiar.CodigoPlan
};
int?codigoPerfil = await planesRepo.BuscarCodigoTipoPerfilDeUnPlan(planParaBuscar);
if (!codigoPerfil.HasValue)
{
throw new InvalidOperationException("No se pudo hallar el codigo de perfil!. BUUUUG");
}
TipoPerfil tipoPerfil = codigoPerfil.Value.ToEnum <TipoPerfil>();
int? codigoPlanDefault = await planesRepo.BuscarCodigoPlanDefault(tipoPerfil);
if (!codigoPlanDefault.HasValue)
{
throw new InvalidOperationException("No se pudo hallar el codigo del plan default para este perfil!. BUUUUG");
}
PlanesUsuarios planParaCambiar = new PlanesUsuarios
{
Consecutivo = planesUsuariosVencidoParaCambiar.Consecutivo,
CodigoPlanDeseado = codigoPlanDefault.Value
};
WrapperSimpleTypesDTO wrapper = await CambiarDePlanUsuario(planParaCambiar);
return(wrapper);
}
}
public async Task <WrapperSimpleTypesDTO> CambiarDePlanUsuario(PlanesUsuarios planParaCambiar)
{
using (SportsGoEntities context = new SportsGoEntities(false))
{
PlanesRepository planRepository = new PlanesRepository(context);
DateTime fechaVencimientoPlan = await planRepository.CalcularFechaVencimientoPlanUsuario(planParaCambiar);
planParaCambiar.Vencimiento = fechaVencimientoPlan;
PlanesUsuarios planUsuarioExistente = await planRepository.CambiarDePlanUsuario(planParaCambiar);
WrapperSimpleTypesDTO wrapperCambiarDePlanUsuario = new WrapperSimpleTypesDTO();
wrapperCambiarDePlanUsuario.NumeroRegistrosAfectados = await context.SaveChangesAsync();
if (wrapperCambiarDePlanUsuario.NumeroRegistrosAfectados > 0)
{
wrapperCambiarDePlanUsuario.Exitoso = true;
wrapperCambiarDePlanUsuario.Vencimiento = fechaVencimientoPlan;
}
return(wrapperCambiarDePlanUsuario);
}
}
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);
}
}
public async Task <Tuple <WrapperSimpleTypesDTO, TimeLineNotificaciones> > ModificarEstadoPagoPersona(HistorialPagosPersonas historialPagoParaModificar)
{
using (SportsGoEntities context = new SportsGoEntities(false))
{
PagosRepository pagosRepo = new PagosRepository(context);
Notificaciones notificacion = null;
// Modifico el estado y la fecha de pago de este historial
HistorialPagosPersonas historialPagoExistente = await pagosRepo.ModificarEstadoPagoPersona(historialPagoParaModificar);
// Si el pago fue aprobado
if (historialPagoParaModificar.EstadoDelPago == EstadoDeLosPagos.Aprobado)
{
PlanesRepository planRepo = new PlanesRepository(context);
// Busco el codigo de plan de la persona asignado cuando se registro
// Tabla PlanUsuarios, no es el plan en si, es el registro que lleva el control del plan para ese usuario
int?codigoPlanUsuario = await planRepo.BuscarCodigoPlanUsuarioPorCodigoPersona(historialPagoExistente.CodigoPersona);
PlanesBusiness planBusiness = new PlanesBusiness();
// Armo la entidad del nuevo plan
PlanesUsuarios planUsuario = new PlanesUsuarios
{
Consecutivo = codigoPlanUsuario.Value,
CodigoPlanDeseado = historialPagoExistente.CodigoPlan
};
// Cambio el plan para esa persona
await planBusiness.CambiarDePlanUsuario(planUsuario);
// Si el pago que me es mandando esta marcado como PayU
// Actualizo las observaciones y la referencia del pago ya que es todo en uno
if (historialPagoParaModificar.EsPagoPorPayU)
{
historialPagoExistente.ReferenciaPago = historialPagoParaModificar.ReferenciaPago;
historialPagoExistente.ObservacionesCliente = historialPagoParaModificar.ObservacionesCliente;
}
// Armamos una notificacion para el nuevo plan
NoticiasRepository noticiasRepo = new NoticiasRepository(context);
notificacion = new Notificaciones
{
CodigoTipoNotificacion = (int)TipoNotificacionEnum.PlanAprobado,
CodigoPlanNuevo = historialPagoExistente.CodigoPlan,
CodigoPersonaDestinoAccion = historialPagoExistente.CodigoPersona,
Creacion = DateTime.Now
};
noticiasRepo.CrearNotificacion(notificacion);
}
else if (historialPagoParaModificar.EstadoDelPago == EstadoDeLosPagos.Rechazado)
{
historialPagoExistente.ObservacionesAdministrador = historialPagoParaModificar.ObservacionesAdministrador;
NoticiasRepository noticiasRepo = new NoticiasRepository(context);
notificacion = new Notificaciones
{
CodigoTipoNotificacion = (int)TipoNotificacionEnum.PlanRechazado,
CodigoPlanNuevo = historialPagoParaModificar.CodigoPlan,
CodigoPersonaDestinoAccion = historialPagoParaModificar.CodigoPersona,
Creacion = DateTime.Now
};
noticiasRepo.CrearNotificacion(notificacion);
}
else if (historialPagoParaModificar.EstadoDelPago == EstadoDeLosPagos.PendientePorAprobar)
{
if (string.IsNullOrWhiteSpace(historialPagoParaModificar.ReferenciaPago) || historialPagoParaModificar.CodigoArchivo <= 0)
{
throw new InvalidOperationException("No puedes reportar el pago de un plan si no ofreces la referencia del pago y/o el archivo");
}
historialPagoExistente.ReferenciaPago = historialPagoParaModificar.ReferenciaPago;
historialPagoExistente.CodigoArchivo = historialPagoParaModificar.CodigoArchivo;
historialPagoExistente.ObservacionesCliente = historialPagoParaModificar.ObservacionesCliente;
}
WrapperSimpleTypesDTO wrapperModificarEstadoPagoPersona = new WrapperSimpleTypesDTO();
TimeLineNotificaciones timeLineNotificacion = null;
wrapperModificarEstadoPagoPersona.NumeroRegistrosAfectados = await context.SaveChangesAsync();
if (wrapperModificarEstadoPagoPersona.NumeroRegistrosAfectados > 0)
{
wrapperModificarEstadoPagoPersona.Exitoso = true;
if (notificacion != null && notificacion.Consecutivo > 0)
{
NoticiasRepository noticiasRepo = new NoticiasRepository(context);
if (notificacion.CodigoPersonaDestinoAccion.HasValue && notificacion.CodigoPersonaDestinoAccion > 0)
{
PersonasRepository personaRepo = new PersonasRepository(context);
int codigoIdioma = await personaRepo.BuscarCodigoIdiomaDeLaPersona(notificacion.CodigoPersonaDestinoAccion.Value);
notificacion.CodigoIdiomaUsuarioBase = codigoIdioma;
}
timeLineNotificacion = new TimeLineNotificaciones(await noticiasRepo.BuscarNotificacion(notificacion));
}
}
return(Tuple.Create(wrapperModificarEstadoPagoPersona, timeLineNotificacion));
}
}
public async Task <DateTime> BuscarFechaVencimientoPlan(PlanesUsuarios planParaBuscar)
{
DateTime fechaVencimiento = await _context.PlanesUsuarios.Where(x => x.Consecutivo == planParaBuscar.Consecutivo).Select(x => x.Vencimiento).FirstOrDefaultAsync();
return(fechaVencimiento);
}
public async Task <bool> VerificarSiPlanSoportaLaOperacion(PlanesUsuarios planParaValidar, TipoOperacion tipoOperacion)
{
PlanesUsuarios planUsuario = await _context.PlanesUsuarios.Where(x => x.Consecutivo == planParaValidar.Consecutivo)
.Select(x => x)
.Include(x => x.Planes)
.FirstOrDefaultAsync();
if (planUsuario.Vencimiento < DateTime.Now && planUsuario.Planes.PlanDefault != 1)
{
return(false);
}
bool esPosible = false;
switch (tipoOperacion)
{
case TipoOperacion.VideosPerfil:
if (planUsuario.Planes.VideosPerfil.ToEnum <SiNoEnum>() == SiNoEnum.Si)
{
esPosible = true;
}
break;
case TipoOperacion.ServiciosChat:
if (planUsuario.Planes.ServiciosChat.ToEnum <SiNoEnum>() == SiNoEnum.Si)
{
esPosible = true;
}
break;
case TipoOperacion.ConsultaCandidatos:
if (planUsuario.Planes.ConsultaCandidatos.ToEnum <SiNoEnum>() == SiNoEnum.Si)
{
esPosible = true;
}
break;
case TipoOperacion.DetalleCandidatos:
if (planUsuario.Planes.DetalleCandidatos.ToEnum <SiNoEnum>() == SiNoEnum.Si)
{
esPosible = true;
}
break;
case TipoOperacion.ConsultaGrupos:
if (planUsuario.Planes.ConsultaGrupos.ToEnum <SiNoEnum>() == SiNoEnum.Si)
{
esPosible = true;
}
break;
case TipoOperacion.DetalleGrupos:
if (planUsuario.Planes.DetalleGrupos.ToEnum <SiNoEnum>() == SiNoEnum.Si)
{
esPosible = true;
}
break;
case TipoOperacion.ConsultaEventos:
if (planUsuario.Planes.ConsultaEventos.ToEnum <SiNoEnum>() == SiNoEnum.Si)
{
esPosible = true;
}
break;
case TipoOperacion.CreacionAnuncios:
if (planUsuario.Planes.CreacionAnuncios.ToEnum <SiNoEnum>() == SiNoEnum.Si)
{
esPosible = true;
}
break;
case TipoOperacion.EstadisticasAnuncios:
if (planUsuario.Planes.EstadisticasAnuncios.ToEnum <SiNoEnum>() == SiNoEnum.Si)
{
esPosible = true;
}
break;
case TipoOperacion.MultiplesCategorias:
if (planUsuario.Planes.NumeroCategoriasPermisibles >= planUsuario.NumeroCategoriasUsadas + 1)
{
esPosible = true;
}
break;
default:
throw new InvalidOperationException("Tipo de Operacion Invalido!.");
}
return(esPosible);
}
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 <List <TimeLineNotificaciones> > ListaTimeLineNotificaciones(BuscadorDTO buscador)
{
using (SportsGoEntities context = new SportsGoEntities(false))
{
NoticiasRepository noticiaRepo = new NoticiasRepository(context);
DateTimeHelperNoPortable helper = new DateTimeHelperNoPortable();
if (buscador.FechaFiltroBase != DateTime.MinValue)
{
buscador.FechaFiltroBase = helper.ConvertDateTimeFromAnotherTimeZone(buscador.ZonaHorariaGMTBase, helper.DifferenceBetweenGMTAndLocalTimeZone, buscador.FechaFiltroBase);
}
List <NoticiasDTO> listaNoticias = await noticiaRepo.ListarNoticiasNotificaciones(buscador);
List <NotificacionesDTO> listarNotificaciones = await noticiaRepo.ListarNotificaciones(buscador);
List <TimeLineNotificaciones> listaTimeLineNotificacion = TimeLineNotificaciones.CrearListaTimeLineNotificaciones(listaNoticias, listarNotificaciones);
// Si no es minValue significa que estoy refrescando y no busco feed
if (buscador.FechaFiltroBase == DateTime.MinValue)
{
RssFeeds rssBuscado = await noticiaRepo.BuscarRssFeedPorCodigoIdioma(buscador.CodigoIdiomaUsuarioBase);
if (rssBuscado != null && !string.IsNullOrWhiteSpace(rssBuscado.UrlFeed))
{
FeedReader reader = new FeedReader();
IEnumerable <FeedItem> items = reader.RetrieveFeed(rssBuscado.UrlFeed);
if (items != null && items.Count() > 0)
{
IEnumerable <FeedItem> itemsFiltrados = items.Skip(buscador.SkipIndexBase).Take(buscador.TakeIndexBase);
if (itemsFiltrados != null && itemsFiltrados.Count() > 0)
{
foreach (FeedItem item in itemsFiltrados)
{
string url = item.Uri != null ? item.Uri.AbsoluteUri : string.Empty;
TimeLineNotificaciones timeLineRss = new TimeLineNotificaciones(item.Title, item.Summary, url, string.Empty, TipoNotificacionEnum.RssFeed);
listaTimeLineNotificacion.Insert(0, timeLineRss);
}
}
}
}
}
// Cuando Skip este en 0 significa que es la primera consulta, asi no repito su cosa de validar el plan
// si "FechaFiltroBase" tiene un valor significa que es pull to refresh y no debo agregar las validaciones del plan
if (buscador.SkipIndexBase == 0 && buscador.FechaFiltroBase == DateTime.MinValue)
{
PlanesRepository planRepo = new PlanesRepository(context);
AdministracionRepository adminRepo = new AdministracionRepository(context);
PlanesUsuarios planUsuario = new PlanesUsuarios
{
Consecutivo = buscador.CodigoPlanUsuario,
IdiomaBase = buscador.IdiomaBase
};
PlanesUsuariosDTO planDelUsuarioValidado = await planRepo.BuscarPlanUsuario(planUsuario);
ImagenesPerfilAdministradores imagenperfil = await adminRepo.BuscarPrimeraImagenPerfilAdministrador();
long mesesFaltantesParaQueSeVenza = DateTimeHelper.DiferenciaEntreDosFechas(planDelUsuarioValidado.Vencimiento, DateTime.Now);
if (mesesFaltantesParaQueSeVenza == 1 && planDelUsuarioValidado.Planes.PlanDefault != 1)
{
TimeLineNotificaciones timeLineCasiVence = new TimeLineNotificaciones
{
CodigoArchivo = imagenperfil.CodigoArchivo,
UrlArchivo = imagenperfil.UrlImagenPerfil,
DescripcionPlan = planDelUsuarioValidado.Planes.DescripcionIdiomaBuscado,
FechaVencimientoPlan = planDelUsuarioValidado.Vencimiento,
TipoDeLaNotificacion = TipoNotificacionEnum.EstaPorVencersePlan,
CreacionNotificacion = DateTime.Now
};
listaTimeLineNotificacion.Insert(0, timeLineCasiVence);
}
else if (mesesFaltantesParaQueSeVenza < 0 && planDelUsuarioValidado.Planes.PlanDefault != 1)
{
TimeLineNotificaciones timeLineVencio = new TimeLineNotificaciones
{
CodigoArchivo = imagenperfil.CodigoArchivo,
UrlArchivo = imagenperfil.UrlImagenPerfil,
DescripcionPlan = planDelUsuarioValidado.Planes.DescripcionIdiomaBuscado,
FechaVencimientoPlan = planDelUsuarioValidado.Vencimiento,
TipoDeLaNotificacion = TipoNotificacionEnum.SeVencioPlan,
CreacionNotificacion = DateTime.Now
};
listaTimeLineNotificacion.Insert(0, timeLineVencio);
}
}
if (listaTimeLineNotificacion != null && listaTimeLineNotificacion.Count > 0)
{
foreach (var notificacion in listaTimeLineNotificacion)
{
notificacion.CreacionNotificacion = helper.ConvertDateTimeFromAnotherTimeZone(buscador.ZonaHorariaGMTBase, helper.DifferenceBetweenGMTAndLocalTimeZone, notificacion.CreacionNotificacion);
notificacion.FechaInicioEvento = helper.ConvertDateTimeFromAnotherTimeZone(buscador.ZonaHorariaGMTBase, helper.DifferenceBetweenGMTAndLocalTimeZone, notificacion.FechaInicioEvento);
notificacion.FechaTerminacionEvento = helper.ConvertDateTimeFromAnotherTimeZone(buscador.ZonaHorariaGMTBase, helper.DifferenceBetweenGMTAndLocalTimeZone, notificacion.FechaTerminacionEvento);
notificacion.FechaVencimientoPlan = helper.ConvertDateTimeFromAnotherTimeZone(buscador.ZonaHorariaGMTBase, helper.DifferenceBetweenGMTAndLocalTimeZone, notificacion.FechaVencimientoPlan);
}
}
return(listaTimeLineNotificacion);
}
}
