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(PlanesUsuariosDTO planUsuarioParaValidar)
{
if (planUsuarioParaValidar == null)
{
throw new ArgumentNullException("No puedes validar un planUsuario si planUsuarioParaValidar es nulo!.");
}
if (planUsuarioParaValidar.Consecutivo <= 0 || planUsuarioParaValidar.TipoOperacionBase == TipoOperacion.SinOperacion)
{
throw new ArgumentException("planUsuarioParaValidar vacio y/o invalido!.");
}
IHttpClient client = ConfigurarHttpClient();
WrapperSimpleTypesDTO wrapperVerificarPlanOperacion = await client.PostAsync <PlanesUsuariosDTO, WrapperSimpleTypesDTO>("Planes/VerificarSiPlanSoportaLaOperacion", planUsuarioParaValidar);
return(wrapperVerificarPlanOperacion);
}
public async Task <WrapperSimpleTypesDTO> CambiarDePlanUsuario(PlanesUsuariosDTO planParaCambiar)
{
if (planParaCambiar == null)
{
throw new ArgumentNullException("No puedes cambiar un planUsuario si planParaCambiar es nulo!.");
}
if (planParaCambiar.Consecutivo <= 0 || planParaCambiar.CodigoPlanDeseado <= 0)
{
throw new ArgumentException("planParaCambiar vacio y/o invalido!.");
}
IHttpClient client = ConfigurarHttpClient();
WrapperSimpleTypesDTO wrapperCambiarDePlanUsuario = await client.PostAsync <PlanesUsuariosDTO, WrapperSimpleTypesDTO>("Planes/CambiarDePlanUsuario", planParaCambiar);
return(wrapperCambiarDePlanUsuario);
}
public async Task <PlanesUsuariosDTO> BuscarPlanUsuario(PlanesUsuariosDTO planUsuarioParaBuscar)
{
if (planUsuarioParaBuscar == null)
{
throw new ArgumentNullException("No puedes buscar un planUsuario si planUsuarioParaBuscar es nulo!.");
}
if (planUsuarioParaBuscar.Consecutivo <= 0 || planUsuarioParaBuscar.IdiomaBase == Idioma.SinIdioma)
{
throw new ArgumentException("planUsuarioParaBuscar vacio y/o invalido!.");
}
IHttpClient client = ConfigurarHttpClient();
PlanesUsuariosDTO planUsuarioBuscado = await client.PostAsync("Planes/BuscarPlanUsuario", planUsuarioParaBuscar);
return(planUsuarioBuscado);
}
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 <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 <JsonResult> GetMyPlan()
{
try
{
PlanesServices planService = new PlanesServices();
if (UserLoggedIn().CodigoPlanUsuario > 0)
{
Result <PlanesUsuariosDTO> result = new Result <PlanesUsuariosDTO>();
PlanesUsuariosDTO myPlan = new PlanesUsuariosDTO();
myPlan.Consecutivo = UserLoggedIn().CodigoPlanUsuario;
myPlan.CodigoIdiomaUsuarioBase = UserLoggedIn().PersonaDelUsuario.CodigoIdioma;
result.obj = await planService.BuscarPlanUsuario(myPlan);
if (result.obj != null)
{
return(Json(result, JsonRequestBehavior.AllowGet));
}
return(Json(Helper.returnErrorObj(UserLoggedIn().PersonaDelUsuario.CodigoIdioma), JsonRequestBehavior.AllowGet));
}
else
{
Result <PlanesDTO> result = new Result <PlanesDTO>();
result.obj = await planService.BuscarPlanDefaultDeUnPerfil(new PlanesDTO()
{
TipoPerfil = UserLoggedIn().TipoPerfil
});
if (result.obj != null)
{
return(Json(result, JsonRequestBehavior.AllowGet));
}
return(Json(Helper.returnErrorObj(UserLoggedIn().PersonaDelUsuario.CodigoIdioma), JsonRequestBehavior.AllowGet));
}
}
catch (Exception)
{
return(Json(Helper.returnErrorObj(UserLoggedIn().PersonaDelUsuario.CodigoIdioma), JsonRequestBehavior.AllowGet));
}
}
public override async void Init(object initData)
{
base.Init(initData);
try
{
await CargarItemsNotificaciones(0, 3);
LastRefresh = DateTime.Now;
}
catch (Exception)
{
}
ChatsServices.NotificacionRecibida += async(obj, evt) =>
{
if (evt.NotificacionRecibida != null)
{
using (await _lockeable.LockAsync())
{
LastRefresh = DateTime.Now;
bool notificacionYaExiste = false;
// Verificamos que la notificacion ya existe, tomando en cuenta que el consecutivo debe ser valido para descartar las notificaciones de otros sources que no sea la tabla de Notificaciones (Como las noticias del admin)
if (TimeLine != null && TimeLine.Count > 0)
{
notificacionYaExiste = TimeLine.Where(x => x.ConsecutivoNotificacion == evt.NotificacionRecibida.ConsecutivoNotificacion && x.ConsecutivoNotificacion > 0).Any();
}
// Si la notificacion no existe, procedo a agregarla
if (!notificacionYaExiste)
{
evt.NotificacionRecibida = BuildearNotificacionesTraducidas(evt.NotificacionRecibida);
evt.NotificacionRecibida.EsNuevoMensaje = true;
Device.BeginInvokeOnMainThread(() =>
{
if (TimeLine != null)
{
TimeLine = new ObservableRangeCollection <TimeLineNotificaciones>(new List <TimeLineNotificaciones> {
evt.NotificacionRecibida
});
}
else
{
TimeLine.Insert(0, evt.NotificacionRecibida);
}
});
// Aumentamos el contador del Badge
App.InteractuarValorBadgeNotificacion(1);
//Set or Get the state of the Effect sounds.
_audioManager.EffectsOn = true;
//Set the volume level of the Effects from 0 to 1.
_audioManager.EffectsVolume = 0.4f;
try
{
//await _audioManager.PlaySound("notificationSound.mp3");
await _audioManager.PlayNotificationDefaultSound();
}
catch (Exception)
{
}
if (evt.NotificacionRecibida.TipoDeLaNotificacion == TipoNotificacionEnum.PlanAprobado)
{
PlanesUsuariosDTO planUsuario = new PlanesUsuariosDTO
{
Consecutivo = App.Usuario.CodigoPlanUsuario,
IdiomaBase = App.IdiomaPersona
};
PlanesUsuariosDTO planDelUsuario = await _planService.BuscarPlanUsuario(planUsuario);
if (planDelUsuario != null)
{
App.Usuario.PlanesUsuarios = planDelUsuario;
}
}
if (evt.NotificacionRecibida.TipoDeLaNotificacion == TipoNotificacionEnum.PersonaEliminada)
{
if (evt.NotificacionRecibida.CodigoPersonaOrigen > 0)
{
PerfilPageModel.DispararEventoPersonaBorrada(this, evt.NotificacionRecibida.CodigoPersonaOrigen);
}
}
}
}
}
};
ConnectionChanged += async(sender, args) =>
{
if (args.IsConnect && NecesitaRefrescar)
{
try
{
await CargarItemsNotificaciones(0, 100, true, true);
NecesitaRefrescar = false;
}
catch (Exception)
{
}
}
if (!args.IsConnect)
{
NecesitaRefrescar = true;
}
};
}
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 <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);
}
}
