public async Task <List <TimeLineNoticias> > ListarTimeLine(BuscadorDTO buscador)
{
using (SportsGoEntities context = new SportsGoEntities(false))
{
NoticiasRepository noticiaRepo = new NoticiasRepository(context);
GruposRepository grupoRepo = new GruposRepository(context);
AnunciantesRepository anuncianteRepo = new AnunciantesRepository(context);
DateTimeHelperNoPortable helper = new DateTimeHelperNoPortable();
if (buscador.FechaInicio != DateTime.MinValue)
{
buscador.FechaInicio = helper.ConvertDateTimeFromAnotherTimeZone(buscador.ZonaHorariaGMTBase, helper.DifferenceBetweenGMTAndLocalTimeZone, buscador.FechaInicio);
}
List <GruposEventosDTO> listaEventos = await grupoRepo.ListarEventos(buscador, true);
List <AnunciosDTO> listaAnuncios = await anuncianteRepo.ListarAnuncios(buscador, true);
List <NoticiasDTO> listaNoticias = await noticiaRepo.ListarNoticiasNoNotificaciones(buscador, true);
List <TimeLineNoticias> listaTimeLine = TimeLineNoticias.CrearListaTimeLine(listaEventos, listaAnuncios, listaNoticias);
List <int> listaCodigoAnunciosConsultados = listaAnuncios.Select(x => x.Consecutivo).ToList();
if (!buscador.EsConsultaEnLaApp && buscador.SkipIndexBase == 0)
{
List <AnunciosDTO> listaAnunciosLaterales = await anuncianteRepo.ListarAnunciosLaterales(buscador);
List <TimeLineNoticias> listaAnunciosLateralesParaAdicionar = TimeLineNoticias.CrearListaTimeLine(null, listaAnunciosLaterales, null);
listaCodigoAnunciosConsultados.AddRange(listaAnunciosLaterales.Select(x => x.Consecutivo));
if (listaAnunciosLateralesParaAdicionar != null && listaAnunciosLateralesParaAdicionar.Count > 0)
{
listaTimeLine.AddRange(listaAnunciosLateralesParaAdicionar);
}
}
if (listaCodigoAnunciosConsultados.Count > 0)
{
await anuncianteRepo.ModificarControlAnuncio(listaCodigoAnunciosConsultados);
}
if (listaTimeLine != null && listaTimeLine.Count > 0)
{
foreach (var timeLine in listaTimeLine)
{
timeLine.FechaPublicacion = helper.ConvertDateTimeFromAnotherTimeZone(buscador.ZonaHorariaGMTBase, helper.DifferenceBetweenGMTAndLocalTimeZone, timeLine.FechaPublicacion);
}
}
return(listaTimeLine);
}
}
public async Task <WrapperSimpleTypesDTO> EliminarNoticia(Noticias noticiaParaEliminar)
{
using (SportsGoEntities context = new SportsGoEntities(false))
{
NoticiasRepository noticiasRepo = new NoticiasRepository(context);
NoticiasContenidos noticiaContenidoParaBorrar = new NoticiasContenidos
{
CodigoNoticia = noticiaParaEliminar.Consecutivo
};
noticiasRepo.EliminarMultiplesNoticiasContenidos(noticiaContenidoParaBorrar);
NoticiasPaises noticiaPaisesParaBorrar = new NoticiasPaises
{
CodigoNoticia = noticiaParaEliminar.Consecutivo
};
noticiasRepo.EliminarMultiplesNoticiasPaises(noticiaPaisesParaBorrar);
CategoriasRepository categoriasRepo = new CategoriasRepository(context);
CategoriasNoticias categoriasNoticiaParaBorrar = new CategoriasNoticias
{
CodigoNoticia = noticiaParaEliminar.Consecutivo
};
categoriasRepo.EliminarMultiplesCategoriasNoticias(categoriasNoticiaParaBorrar);
int?codigoArchivoDeAnuncio = await noticiasRepo.BuscarArchivoDeUnaNoticia(noticiaParaEliminar);
noticiasRepo.EliminarNoticia(noticiaParaEliminar);
WrapperSimpleTypesDTO wrapperEliminarNoticia = new WrapperSimpleTypesDTO();
wrapperEliminarNoticia.NumeroRegistrosAfectados = await context.SaveChangesAsync();
if (codigoArchivoDeAnuncio.HasValue)
{
ArchivosRepository archivoRepo = new ArchivosRepository(context);
Archivos archivoParaEliminar = new Archivos
{
Consecutivo = codigoArchivoDeAnuncio.Value,
};
archivoRepo.EliminarArchivo(archivoParaEliminar);
}
wrapperEliminarNoticia.NumeroRegistrosAfectados += await context.SaveChangesAsync();
if (wrapperEliminarNoticia.NumeroRegistrosAfectados > 0)
{
wrapperEliminarNoticia.Exitoso = true;
}
return(wrapperEliminarNoticia);
}
}
public IActionResult EditarNoticia(int id)
{
NoticiasRepository repos = new NoticiasRepository();
var n = repos.NoticiaById(id);
if (n == null)
{
return(RedirectToAction("Index"));
}
else
{
return(View(n));
}
}
public IActionResult Noticia(string Id)
{
NoticiasRepository noticiasRepository = new NoticiasRepository();
var noticiaResult = noticiasRepository.GetNoticiasByNombre(Id.Replace("_", " "));
if (noticiaResult == null)
{
return(RedirectToAction("Noticias"));
}
else
{
return(View(noticiaResult));
}
}
public async Task <Tuple <WrapperSimpleTypesDTO, TimeLineNotificaciones> > CrearContacto(Contactos contactoParaCrear)
{
using (SportsGoEntities context = new SportsGoEntities(false))
{
ChatsRepository chatsRepo = new ChatsRepository(context);
int codigoPersonaContacto = contactoParaCrear.CodigoPersonaContacto;
int codigoPersonaOwner = contactoParaCrear.CodigoPersonaOwner;
chatsRepo.CrearContacto(contactoParaCrear);
Contactos contactoSegundoParaCrear = new Contactos
{
CodigoPersonaContacto = codigoPersonaOwner,
CodigoPersonaOwner = codigoPersonaContacto
};
chatsRepo.CrearContacto(contactoSegundoParaCrear);
NoticiasRepository noticiasRepo = new NoticiasRepository(context);
Notificaciones notificacion = new Notificaciones
{
CodigoTipoNotificacion = (int)TipoNotificacionEnum.PersonaAgregada,
CodigoPersonaOrigenAccion = codigoPersonaOwner,
CodigoPersonaDestinoAccion = codigoPersonaContacto,
Creacion = DateTime.Now
};
noticiasRepo.CrearNotificacion(notificacion);
WrapperSimpleTypesDTO wrapperCrearContacto = new WrapperSimpleTypesDTO();
TimeLineNotificaciones timeLineNotificacion = null;
wrapperCrearContacto.NumeroRegistrosAfectados = await context.SaveChangesAsync();
if (wrapperCrearContacto.NumeroRegistrosAfectados > 0)
{
wrapperCrearContacto.Exitoso = true;
wrapperCrearContacto.ConsecutivoCreado = contactoParaCrear.Consecutivo;
if (notificacion.Consecutivo > 0)
{
timeLineNotificacion = new TimeLineNotificaciones(await noticiasRepo.BuscarNotificacion(notificacion));
}
}
return(Tuple.Create(wrapperCrearContacto, timeLineNotificacion));
}
}
public IActionResult AgregarNoticia(NoticiasViewModel n)
{
if (ModelState.IsValid)
{
try
{
NoticiasRepository noticiasRepository = new NoticiasRepository();
var notic = noticiasRepository.GetNoticiasByNombre(n.Encabezado);
if (notic == null)
{
noticiasRepository.Insert(n);
if (n.Foto == null)
{
noticiasRepository.SetNoPhoto(n.idNoticias, $"{Environment.WebRootPath}");
}
else if (n.Foto.ContentType != "image/jpeg")
{
ModelState.AddModelError("", "Solo se pueden cargar imagenes JPEG.");
return(View(n));
}
else if (n.Foto.Length > 1024 * 1024)
{
ModelState.AddModelError("", "El tamaño maximo de una imagen es de [ 1 MB ].");
return(View(n));
}
else
{
noticiasRepository.GuardarArchivo(n.idNoticias, n.Foto, $"{Environment.WebRootPath}");
}
return(RedirectToAction("Noticias", "Administrador"));
}
else
{
ModelState.AddModelError("", "Ya existe una noticia con este nombre");
return(View(n));
}
}
catch (Exception ex)
{
ModelState.AddModelError("", ex.Message);
return(View(n));
}
}
else
{
return(View(n));
}
}
public async Task <Noticias> BuscarNoticia(Noticias noticiaParaBuscar)
{
using (SportsGoEntities context = new SportsGoEntities(false))
{
NoticiasRepository noticiaRepo = new NoticiasRepository(context);
Noticias noticiaBuscada = await noticiaRepo.BuscarNoticia(noticiaParaBuscar);
if (noticiaBuscada != null)
{
DateTimeHelperNoPortable helper = new DateTimeHelperNoPortable();
noticiaBuscada.Creacion = helper.ConvertDateTimeFromAnotherTimeZone(noticiaParaBuscar.ZonaHorariaGMTBase, helper.DifferenceBetweenGMTAndLocalTimeZone, noticiaBuscada.Creacion);
}
return(noticiaBuscada);
}
}
public IActionResult EliminarNoticia(int id)
{
NoticiasRepository noticiasRepository = new NoticiasRepository();
var n = noticiasRepository.GetById(id);
if (n != null)
{
noticiasRepository.Delete(n);
ViewBag.Mensaje = "La noticia ha sido eliminada exitosamente.";
}
else
{
ViewBag.Mensaje = "La noticia no existe o ya ha sido eliminada.";
}
return(RedirectToAction("Index"));
}
public async Task <Tuple <WrapperSimpleTypesDTO, TimeLineNotificaciones> > CrearGruposEventosAsistentes(GruposEventosAsistentes grupoEventoAsistentesParaCrear)
{
using (SportsGoEntities context = new SportsGoEntities(false))
{
GruposRepository grupoRepository = new GruposRepository(context);
grupoRepository.CrearGruposEventosAsistentes(grupoEventoAsistentesParaCrear);
int?codigoPersonaGrupo = await grupoRepository.BuscarCodigoPersonaDeUnGrupo(grupoEventoAsistentesParaCrear.CodigoEvento);
if (!codigoPersonaGrupo.HasValue)
{
throw new InvalidOperationException("No se pudo hallar el codigo persona del grupo dueño de este evento, BUUUUUUGGG!..");
}
NoticiasRepository noticiasRepo = new NoticiasRepository(context);
Notificaciones notificacion = new Notificaciones
{
CodigoEvento = grupoEventoAsistentesParaCrear.CodigoEvento,
CodigoPersonaDestinoAccion = codigoPersonaGrupo.Value,
CodigoPersonaOrigenAccion = grupoEventoAsistentesParaCrear.CodigoPersona,
CodigoTipoNotificacion = (int)TipoNotificacionEnum.InscripcionEventoUsuario,
Creacion = DateTime.Now
};
noticiasRepo.CrearNotificacion(notificacion);
WrapperSimpleTypesDTO wrapperCrearGrupoEventoAsistentes = new WrapperSimpleTypesDTO();
TimeLineNotificaciones timeLineNotificacion = null;
wrapperCrearGrupoEventoAsistentes.NumeroRegistrosAfectados = await context.SaveChangesAsync();
if (wrapperCrearGrupoEventoAsistentes.NumeroRegistrosAfectados > 0)
{
wrapperCrearGrupoEventoAsistentes.Exitoso = true;
wrapperCrearGrupoEventoAsistentes.ConsecutivoCreado = grupoEventoAsistentesParaCrear.Consecutivo;
if (notificacion.Consecutivo > 0)
{
timeLineNotificacion = new TimeLineNotificaciones(await noticiasRepo.BuscarNotificacion(notificacion));
}
}
return(Tuple.Create(wrapperCrearGrupoEventoAsistentes, timeLineNotificacion));
}
}
public async Task <WrapperSimpleTypesDTO> CrearPlan(Planes planParaCrear)
{
using (SportsGoEntities context = new SportsGoEntities(false))
{
PlanesRepository planRepository = new PlanesRepository(context);
planParaCrear.Archivos.CodigoTipoArchivo = (int)TipoArchivo.Imagen;
planRepository.CrearPlan(planParaCrear);
WrapperSimpleTypesDTO wrapperCrearPlan = new WrapperSimpleTypesDTO();
wrapperCrearPlan.NumeroRegistrosAfectados = await context.SaveChangesAsync();
if (wrapperCrearPlan.NumeroRegistrosAfectados > 0)
{
wrapperCrearPlan.Exitoso = true;
wrapperCrearPlan.ConsecutivoCreado = planParaCrear.Consecutivo;
if (planParaCrear.PlanDefault == (int)SiNoEnum.Si)
{
await planRepository.DesasignarPlanDefaultDeUnPerfilMenosActual(planParaCrear.Consecutivo, planParaCrear.CodigoTipoPerfil);
}
NoticiasRepository noticiasRepo = new NoticiasRepository(context);
Notificaciones notificacion = new Notificaciones
{
CodigoTipoNotificacion = (int)TipoNotificacionEnum.NuevoPlan,
CodigoPlanNuevo = planParaCrear.Consecutivo,
Creacion = DateTime.Now
};
noticiasRepo.CrearNotificacion(notificacion);
wrapperCrearPlan.NumeroRegistrosAfectados += await context.SaveChangesAsync();
//if (notificacion.Consecutivo > 0)
//{
// TimeLineNotificaciones timeLineNotificacion = new TimeLineNotificaciones(await noticiasRepo.BuscarNotificacion(notificacion));
//}
}
return(wrapperCrearPlan);
}
}
public async Task <WrapperSimpleTypesDTO> EliminarNoticiaPais(NoticiasPaises noticiaPaisParaEliminar)
{
using (SportsGoEntities context = new SportsGoEntities(false))
{
NoticiasRepository noticiasRepo = new NoticiasRepository(context);
noticiasRepo.EliminarNoticiaPais(noticiaPaisParaEliminar);
WrapperSimpleTypesDTO wrapperEliminarNoticiaPais = new WrapperSimpleTypesDTO();
wrapperEliminarNoticiaPais.NumeroRegistrosAfectados = await context.SaveChangesAsync();
if (wrapperEliminarNoticiaPais.NumeroRegistrosAfectados > 0)
{
wrapperEliminarNoticiaPais.Exitoso = true;
}
return(wrapperEliminarNoticiaPais);
}
}
public async Task <WrapperSimpleTypesDTO> CrearNoticiasContenidos(List <NoticiasContenidos> noticiaContenidoParaCrear)
{
using (SportsGoEntities context = new SportsGoEntities(false))
{
NoticiasRepository noticiaRepo = new NoticiasRepository(context);
noticiaRepo.CrearNoticiasContenidos(noticiaContenidoParaCrear);
WrapperSimpleTypesDTO wrapperCrearNoticiasContenidos = new WrapperSimpleTypesDTO();
wrapperCrearNoticiasContenidos.NumeroRegistrosAfectados = await context.SaveChangesAsync();
if (wrapperCrearNoticiasContenidos.NumeroRegistrosAfectados > 0)
{
wrapperCrearNoticiasContenidos.Exitoso = true;
}
return(wrapperCrearNoticiasContenidos);
}
}
public async Task <WrapperSimpleTypesDTO> ModificarNoticiaContenido(NoticiasContenidos noticiaContenidoParaModificar)
{
using (SportsGoEntities context = new SportsGoEntities(false))
{
NoticiasRepository noticiasRepo = new NoticiasRepository(context);
NoticiasContenidos noticiaContenidoExistente = await noticiasRepo.ModificarNoticiaContenido(noticiaContenidoParaModificar);
WrapperSimpleTypesDTO wrapperModificarNoticiaContenido = new WrapperSimpleTypesDTO();
wrapperModificarNoticiaContenido.NumeroRegistrosAfectados = await context.SaveChangesAsync();
if (wrapperModificarNoticiaContenido.NumeroRegistrosAfectados > 0)
{
wrapperModificarNoticiaContenido.Exitoso = true;
}
return(wrapperModificarNoticiaContenido);
}
}
public async Task <WrapperSimpleTypesDTO> CrearNoticia(Noticias crearNoticia)
{
using (SportsGoEntities context = new SportsGoEntities(false))
{
NoticiasRepository noticiaRepo = new NoticiasRepository(context);
crearNoticia.Creacion = DateTime.Now;
noticiaRepo.CrearNoticia(crearNoticia);
WrapperSimpleTypesDTO wrapperCrearNoticia = new WrapperSimpleTypesDTO();
wrapperCrearNoticia.NumeroRegistrosAfectados = await context.SaveChangesAsync();
if (wrapperCrearNoticia.NumeroRegistrosAfectados > 0)
{
wrapperCrearNoticia.Exitoso = true;
wrapperCrearNoticia.ConsecutivoCreado = crearNoticia.Consecutivo;
}
return(wrapperCrearNoticia);
}
}
private void addFav_Click(object sender, EventArgs e)
{
if (noticia != null)
{
Noticias noticias = new Noticias
{
Title = noticia.Title,
PubDate = noticia.PubDate,
Link = noticia.Link
};
NoticiasRepository.Create(noticia);
if (MessageBox.Show("Adicionado com sucesso!")
== MessageBoxResult.OK)
{
}
}
else
{
if (MessageBox.Show("Você deve selecionar uma noticia primeiro!")
== MessageBoxResult.OK)
{
}
}
}
private void delete_Click(object sender, EventArgs e)
{
if (noticia != null)
{
if (MessageBox.Show("Você deseja realmente excluir esta noticia?")
== MessageBoxResult.OK)
{
NoticiasRepository.Delete(noticia);
if (MessageBox.Show("Excluido com sucesso!")
== MessageBoxResult.OK)
{
}
Refresh();
}
}
else
{
if (MessageBox.Show("Você deve selecionar uma noticia primeiro!")
== MessageBoxResult.OK)
{
}
}
Refresh();
}
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 PublicacaoService(NoticiasRepository noticiasRepository)
{
_noticiasRepository = noticiasRepository;
}
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);
}
}
public IEnumerable <string> GetAllNoticiasNombre()
{
NoticiasRepository noticiasRepository = new NoticiasRepository();
return(noticiasRepository.GetAll().Select(x => x.Encabezado));
}
public NoticiasController()
{
_entityRepo = new NoticiasRepository();
}
public IEnumerable <Noticias> GetAllNoticias()
{
NoticiasRepository noticiasRepository = new NoticiasRepository();
return(noticiasRepository.GetAll());
}
public IActionResult EditarNoticia(NoticiasViewModel n)
{
if (ModelState.IsValid)
{
try
{
NoticiasRepository noticiasRepository = new NoticiasRepository();
var notic = noticiasRepository.GetNoticiasByNombre(n.Encabezado);
if (notic == null)
{
noticiasRepository.Update(n);
if (n.Foto == null)
{
}
else if (n.Foto.ContentType != "image/jpeg")
{
ModelState.AddModelError("", "Solo se pueden cargar imagenes JPG.");
return(View(n));
}
else if (n.Foto.Length > 1024 * 1024)
{
ModelState.AddModelError("", "El tamaño maximo de una imagen es de [ 1 MB ].");
return(View(n));
}
else
{
noticiasRepository.GuardarArchivo(n.idNoticias, n.Foto, $"{Environment.WebRootPath}");
}
return(RedirectToAction("Noticias", "Administrador"));
}
else if (notic.IdNoticias == n.idNoticias)
{
notic.Encabezado = n.Encabezado;
notic.Autor = n.Autor;
notic.Fecha = n.Fecha;
notic.DescripcionCorta = n.DescripcionCorta;
notic.Cuerpo = n.Cuerpo;
notic.VideoUrl = n.VideoURL;
noticiasRepository.Update(notic);
if (n.Foto == null)
{
//noticiasRepository.SetNOPhoto(n.idNoticias, Environment.WebRootPath);
}
else if (n.Foto.ContentType != "image/jpeg")
{
ModelState.AddModelError("", "Solo se pueden cargar imagenes JPG");
return(View(n));
}
else if (n.Foto.Length > 1024 * 1024)
{
ModelState.AddModelError("", "El tamaño maximo de una imagen es de [ 1 MB ].");
return(View(n));
}
else
{
noticiasRepository.GuardarArchivo(n.idNoticias, n.Foto, $"{Environment.WebRootPath}");
}
return(RedirectToAction("Noticias", "Administrador"));
}
else
{
ModelState.AddModelError("", "Ya existe una notic con este nombre");
return(View(n));
}
}
catch (Exception ex)
{
ModelState.AddModelError("", ex.Message);
return(View(n));
}
}
else
{
return(View(n));
}
}
private void Refresh()
{
List <Noticias> noticias = NoticiasRepository.Get();
LstFavoritos.ItemsSource = noticias;
}
public IActionResult Index()
{
NoticiasRepository repos = new NoticiasRepository();
return(View(repos.GetNoticias()));
}
public async Task <WrapperSimpleTypesDTO> ModificarNoticia(Noticias noticiaParaModificar)
{
using (SportsGoEntities context = new SportsGoEntities(false))
{
NoticiasRepository noticiasRepo = new NoticiasRepository(context);
Noticias noticiaExistente = await noticiasRepo.ModificarNoticia(noticiaParaModificar);
if (noticiaParaModificar.NoticiasContenidos != null && noticiaParaModificar.NoticiasContenidos.Count > 0)
{
foreach (NoticiasContenidos noticiaContenido in noticiaParaModificar.NoticiasContenidos)
{
NoticiasContenidos noticiaContenidoExistente = await noticiasRepo.ModificarNoticiaContenido(noticiaContenido);
}
}
if (noticiaParaModificar.NoticiasPaises != null && noticiaParaModificar.NoticiasPaises.Count > 0)
{
NoticiasPaises noticiaPaisParaBorrar = new NoticiasPaises
{
CodigoNoticia = noticiaParaModificar.Consecutivo
};
noticiasRepo.EliminarMultiplesNoticiasPaises(noticiaPaisParaBorrar);
foreach (var noticiaPais in noticiaParaModificar.NoticiasPaises)
{
noticiaPais.CodigoNoticia = noticiaParaModificar.Consecutivo;
}
noticiasRepo.CrearNoticiasPaises(noticiaParaModificar.NoticiasPaises);
}
if (noticiaParaModificar.CategoriasNoticias != null && noticiaParaModificar.CategoriasNoticias.Count > 0)
{
CategoriasRepository categoriasRepo = new CategoriasRepository(context);
CategoriasNoticias categoriaNoticiaParaBorrar = new CategoriasNoticias
{
CodigoNoticia = noticiaParaModificar.Consecutivo
};
categoriasRepo.EliminarMultiplesCategoriasNoticias(categoriaNoticiaParaBorrar);
foreach (CategoriasNoticias noticiaCategoria in noticiaParaModificar.CategoriasNoticias)
{
noticiaCategoria.CodigoNoticia = noticiaParaModificar.Consecutivo;
}
categoriasRepo.CrearListaCategoriaNoticias(noticiaParaModificar.CategoriasNoticias);
}
WrapperSimpleTypesDTO wrapperModificarNoticia = new WrapperSimpleTypesDTO();
wrapperModificarNoticia.NumeroRegistrosAfectados = await context.SaveChangesAsync();
if (wrapperModificarNoticia.NumeroRegistrosAfectados > 0)
{
wrapperModificarNoticia.Exitoso = true;
}
return(wrapperModificarNoticia);
}
}
