public async Task <WrapperSimpleTypesDTO> EliminarArchivoNoticia(Noticias noticiaArchivoParaEliminar)
{
using (SportsGoEntities context = new SportsGoEntities(false))
{
Archivos archivoParaEliminar = new Archivos
{
Consecutivo = noticiaArchivoParaEliminar.CodigoArchivo.Value,
};
NoticiasRepository noticiaRepo = new NoticiasRepository(context);
Noticias noticiaExistente = await noticiaRepo.DesasignarArchivoNoticia(noticiaArchivoParaEliminar);
ArchivosRepository archivoRepo = new ArchivosRepository(context);
archivoRepo.EliminarArchivo(archivoParaEliminar);
WrapperSimpleTypesDTO wrapperEliminarArchivoNoticia = new WrapperSimpleTypesDTO();
wrapperEliminarArchivoNoticia.NumeroRegistrosAfectados = await context.SaveChangesAsync();
if (wrapperEliminarArchivoNoticia.NumeroRegistrosAfectados > 0)
{
wrapperEliminarArchivoNoticia.Exitoso = true;
}
return(wrapperEliminarArchivoNoticia);
}
}
public async Task <WrapperSimpleTypesDTO> EliminarImagenBanner(Personas personaImagenBannerParaBorrar)
{
using (SportsGoEntities context = new SportsGoEntities(false))
{
Archivos archivoParaEliminar = new Archivos
{
Consecutivo = personaImagenBannerParaBorrar.CodigoArchivoImagenBanner.Value,
};
PersonasRepository personaRepo = new PersonasRepository(context);
Personas personaExistente = await personaRepo.DesasignarImagenBanner(personaImagenBannerParaBorrar);
ArchivosRepository archivoRepo = new ArchivosRepository(context);
archivoRepo.EliminarArchivo(archivoParaEliminar);
WrapperSimpleTypesDTO wrapperEliminarImagenPerfil = new WrapperSimpleTypesDTO();
wrapperEliminarImagenPerfil.NumeroRegistrosAfectados = await context.SaveChangesAsync();
if (wrapperEliminarImagenPerfil.NumeroRegistrosAfectados > 0)
{
wrapperEliminarImagenPerfil.Exitoso = true;
}
return(wrapperEliminarImagenPerfil);
}
}
public async Task <WrapperSimpleTypesDTO> EliminarArchivoGrupoEvento(GruposEventos grupoEventoArchivoParaBorrar)
{
using (SportsGoEntities context = new SportsGoEntities(false))
{
Archivos archivoParaEliminar = new Archivos
{
Consecutivo = grupoEventoArchivoParaBorrar.CodigoArchivo.Value,
};
GruposRepository grupoRepository = new GruposRepository(context);
GruposEventos grupoEventoExistente = await grupoRepository.DesasignarArchivoGrupoEvento(grupoEventoArchivoParaBorrar);
ArchivosRepository archivoRepo = new ArchivosRepository(context);
archivoRepo.EliminarArchivo(archivoParaEliminar);
WrapperSimpleTypesDTO wrapperEliminarArchivoGrupoEvento = new WrapperSimpleTypesDTO();
wrapperEliminarArchivoGrupoEvento.NumeroRegistrosAfectados = await context.SaveChangesAsync();
if (wrapperEliminarArchivoGrupoEvento.NumeroRegistrosAfectados > 0)
{
wrapperEliminarArchivoGrupoEvento.Exitoso = true;
}
return(wrapperEliminarArchivoGrupoEvento);
}
}
public async Task <WrapperSimpleTypesDTO> ModificarArchivoCategoria(Categorias categoriaParaModificar)
{
using (SportsGoEntities context = new SportsGoEntities(false))
{
ArchivosRepository archivoRepo = new ArchivosRepository(context);
Archivos archivo = new Archivos
{
Consecutivo = categoriaParaModificar.CodigoArchivo,
CodigoTipoArchivo = (int)TipoArchivo.Imagen,
ArchivoContenido = categoriaParaModificar.ArchivoContenido
};
archivoRepo.ModificarArchivo(archivo);
WrapperSimpleTypesDTO wrapperModificarArchivoCategoria = new WrapperSimpleTypesDTO();
wrapperModificarArchivoCategoria.NumeroRegistrosAfectados = await context.SaveChangesAsync();
if (wrapperModificarArchivoCategoria.NumeroRegistrosAfectados > 0)
{
wrapperModificarArchivoCategoria.Exitoso = true;
}
return(wrapperModificarArchivoCategoria);
}
}
public async Task <List <ChatsMensajes> > ListarChatsMensajes(ChatsMensajes chatMensajeParaListar)
{
using (SportsGoEntities context = new SportsGoEntities(false))
{
DateTimeHelperNoPortable helper = new DateTimeHelperNoPortable();
ChatsRepository chatsRepo = new ChatsRepository(context);
if (chatMensajeParaListar.FechaFiltroBase != DateTime.MinValue)
{
chatMensajeParaListar.FechaFiltroBase = helper.ConvertDateTimeFromAnotherTimeZone(chatMensajeParaListar.ZonaHorariaGMTBase, helper.DifferenceBetweenGMTAndLocalTimeZone, chatMensajeParaListar.FechaFiltroBase);
}
List <ChatsMensajes> listaMensajes = await chatsRepo.ListarChatsMensajes(chatMensajeParaListar);
if (listaMensajes != null && listaMensajes.Count > 0)
{
foreach (var mensaje in listaMensajes)
{
mensaje.FechaMensaje = helper.ConvertDateTimeFromAnotherTimeZone(chatMensajeParaListar.ZonaHorariaGMTBase, helper.DifferenceBetweenGMTAndLocalTimeZone, mensaje.FechaMensaje);
}
}
return(listaMensajes);
}
}
public async Task <WrapperSimpleTypesDTO> EliminarPais(Paises paisParaEliminar)
{
using (SportsGoEntities context = new SportsGoEntities(false))
{
Archivos archivo = new Archivos
{
Consecutivo = paisParaEliminar.CodigoArchivo
};
AdministracionRepository adminRepo = new AdministracionRepository(context);
PaisesContenidos paisContenidoParaBorrar = new PaisesContenidos
{
CodigoPais = paisParaEliminar.Consecutivo
};
adminRepo.EliminarMultiplesPaisesContenidos(paisContenidoParaBorrar);
adminRepo.EliminarPais(paisParaEliminar);
ArchivosRepository archivoRepo = new ArchivosRepository(context);
archivoRepo.EliminarArchivo(archivo);
WrapperSimpleTypesDTO wrapperEliminarPais = new WrapperSimpleTypesDTO();
wrapperEliminarPais.NumeroRegistrosAfectados = await context.SaveChangesAsync();
if (wrapperEliminarPais.NumeroRegistrosAfectados > 0)
{
wrapperEliminarPais.Exitoso = true;
}
return(wrapperEliminarPais);
}
}
public async Task <List <AnunciosDTO> > ListarAnuncios(BuscadorDTO buscador)
{
using (SportsGoEntities context = new SportsGoEntities(false))
{
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 <AnunciosDTO> listarInformacionAnuncios = await anuncianteRepo.ListarAnuncios(buscador);
if (listarInformacionAnuncios != null && listarInformacionAnuncios.Count > 0)
{
foreach (var anuncios in listarInformacionAnuncios)
{
anuncios.Creacion = helper.ConvertDateTimeFromAnotherTimeZone(buscador.ZonaHorariaGMTBase, helper.DifferenceBetweenGMTAndLocalTimeZone, anuncios.Creacion);
anuncios.FechaInicio = helper.ConvertDateTimeFromAnotherTimeZone(buscador.ZonaHorariaGMTBase, helper.DifferenceBetweenGMTAndLocalTimeZone, anuncios.FechaInicio);
if (anuncios.Vencimiento.HasValue)
{
anuncios.Vencimiento = helper.ConvertDateTimeFromAnotherTimeZone(buscador.ZonaHorariaGMTBase, helper.DifferenceBetweenGMTAndLocalTimeZone, anuncios.Vencimiento.Value);
}
}
}
return(listarInformacionAnuncios);
}
}
public async Task <WrapperSimpleTypesDTO> EliminarCandidatoVideo(CandidatosVideos candidatoVideosParaEliminar)
{
using (SportsGoEntities context = new SportsGoEntities(false))
{
Archivos archivoParaEliminar = new Archivos
{
Consecutivo = candidatoVideosParaEliminar.CodigoArchivo,
};
CandidatosRepository candidatosRepo = new CandidatosRepository(context);
candidatosRepo.EliminarCandidatoVideo(candidatoVideosParaEliminar);
ArchivosRepository archivoRepo = new ArchivosRepository(context);
archivoRepo.EliminarArchivo(archivoParaEliminar);
WrapperSimpleTypesDTO wrapperEliminarCandidatoVideo = new WrapperSimpleTypesDTO();
wrapperEliminarCandidatoVideo.NumeroRegistrosAfectados = await context.SaveChangesAsync();
if (wrapperEliminarCandidatoVideo.NumeroRegistrosAfectados > 0)
{
wrapperEliminarCandidatoVideo.Exitoso = true;
}
return(wrapperEliminarCandidatoVideo);
}
}
public async Task <WrapperSimpleTypesDTO> AsignarCandidatoResponsable(CandidatosResponsables candidatoResponsableParaAsignar)
{
using (SportsGoEntities context = new SportsGoEntities(false))
{
CandidatosRepository candidatosRepo = new CandidatosRepository(context);
Candidatos candidatoExistente = await candidatosRepo.BuscarCandidatoParaAsignar(candidatoResponsableParaAsignar);
candidatoResponsableParaAsignar.Consecutivo = candidatoExistente.CodigoResponsable.HasValue ? candidatoExistente.CodigoResponsable.Value : 0;
if (candidatoExistente.CodigoResponsable.HasValue)
{
CandidatosResponsables candidatoResponsableExistente = await candidatosRepo.ModificarCandidatoResponsable(candidatoResponsableParaAsignar);
}
else
{
candidatoExistente.CandidatosResponsables = candidatoResponsableParaAsignar;
}
WrapperSimpleTypesDTO wrapperCrearCandidatoResponsable = new WrapperSimpleTypesDTO();
wrapperCrearCandidatoResponsable.NumeroRegistrosAfectados = await context.SaveChangesAsync();
if (wrapperCrearCandidatoResponsable.NumeroRegistrosAfectados > 0)
{
wrapperCrearCandidatoResponsable.Exitoso = true;
wrapperCrearCandidatoResponsable.ConsecutivoCreado = candidatoExistente.CodigoResponsable.Value;
}
return(wrapperCrearCandidatoResponsable);
}
}
public async Task <WrapperSimpleTypesDTO> AsignarFacturaFormatoLista(List <FacturaFormato> facturaFormatoParaAsignar)
{
using (SportsGoEntities context = new SportsGoEntities(false))
{
PagosRepository pagosRepo = new PagosRepository(context);
foreach (FacturaFormato factura in facturaFormatoParaAsignar)
{
bool existe = await pagosRepo.BuscarSiExisteFacturaFormato(factura);
if (existe)
{
FacturaFormato facturaFormatoExistente = await pagosRepo.ModificarFacturaFormato(factura);
}
else
{
pagosRepo.CrearFacturaFormato(factura);
}
}
WrapperSimpleTypesDTO wrapperAsignarFacturaFormatoLista = new WrapperSimpleTypesDTO();
wrapperAsignarFacturaFormatoLista.NumeroRegistrosAfectados = await context.SaveChangesAsync();
if (wrapperAsignarFacturaFormatoLista.NumeroRegistrosAfectados > 0)
{
wrapperAsignarFacturaFormatoLista.Exitoso = true;
}
return(wrapperAsignarFacturaFormatoLista);
}
}
public async Task <List <CandidatosVideosDTO> > ListarCandidatosVideosDeUnCandidato(CandidatosVideos candidatoVideoParaListar)
{
using (SportsGoEntities context = new SportsGoEntities(false))
{
CandidatosRepository candidatosRepo = new CandidatosRepository(context);
DateTimeHelperNoPortable helper = new DateTimeHelperNoPortable();
if (candidatoVideoParaListar.FechaFiltroBase != DateTime.MinValue)
{
candidatoVideoParaListar.FechaFiltroBase = helper.ConvertDateTimeFromAnotherTimeZone(candidatoVideoParaListar.ZonaHorariaGMTBase, helper.DifferenceBetweenGMTAndLocalTimeZone, candidatoVideoParaListar.FechaFiltroBase);
}
List <CandidatosVideosDTO> listaVideosCandidato = await candidatosRepo.ListarCandidatosVideosDeUnCandidato(candidatoVideoParaListar);
if (listaVideosCandidato != null && listaVideosCandidato.Count > 0)
{
foreach (var videoCandidato in listaVideosCandidato)
{
videoCandidato.Creacion = helper.ConvertDateTimeFromAnotherTimeZone(candidatoVideoParaListar.ZonaHorariaGMTBase, helper.DifferenceBetweenGMTAndLocalTimeZone, videoCandidato.Creacion);
}
}
return(listaVideosCandidato);
}
}
public async Task <List <Monedas> > ListarMonedas()
{
using (SportsGoEntities context = new SportsGoEntities(false))
{
PagosRepository pagosRepo = new PagosRepository(context);
List <Monedas> listaMonedas = await pagosRepo.ListarMonedas();
QueryMoneyExchanger exchanger = new QueryMoneyExchanger();
Monedas monedaColombiana = listaMonedas.Where(x => x.MonedaEnum == MonedasEnum.PesosColombianos).FirstOrDefault();
foreach (Monedas moneda in listaMonedas.Where(x => x.MonedaEnum != MonedasEnum.PesosColombianos))
{
YahooExchangeEntity exchangeEntity = await exchanger.QueryMoneyExchange(monedaColombiana.AbreviaturaMoneda, moneda.AbreviaturaMoneda);
if (exchangeEntity != null)
{
moneda.CambioMoneda = exchangeEntity.Query.Results.Rate.Rate;
}
}
try
{
// No es obligatorio para el paso que actualize el cambio de moneda
await context.SaveChangesAsync();
}
catch (Exception)
{
}
return(listaMonedas);
}
}
public async Task <TimeLineNotificaciones> VerificarSiPagoEstaAprobadoYTraerNotificacion(HistorialPagosPersonas pagoParaVerificar)
{
using (SportsGoEntities context = new SportsGoEntities(false))
{
PagosRepository pagosRepo = new PagosRepository(context);
int?codigoEstado = await pagosRepo.BuscarEstadoDeUnPago(pagoParaVerificar);
if (!codigoEstado.HasValue)
{
throw new InvalidOperationException("No se pudo encontrar el estado del pago");
}
TimeLineNotificaciones timeLineNotificacion = null;
if (codigoEstado.Value == (int)EstadoDeLosPagos.Aprobado)
{
Notificaciones notificacionDelPago = await pagosRepo.BuscarNotificacionDeUnPago(pagoParaVerificar);
PersonasRepository personaRepo = new PersonasRepository(context);
int codigoIdioma = await personaRepo.BuscarCodigoIdiomaDeLaPersona(notificacionDelPago.CodigoPersonaDestinoAccion.Value);
notificacionDelPago.CodigoIdiomaUsuarioBase = codigoIdioma;
NoticiasRepository noticiasRepo = new NoticiasRepository(context);
timeLineNotificacion = new TimeLineNotificaciones(await noticiasRepo.BuscarNotificacion(notificacionDelPago));
DateTimeHelperNoPortable helper = new DateTimeHelperNoPortable();
timeLineNotificacion.CreacionNotificacion = helper.ConvertDateTimeFromAnotherTimeZone(pagoParaVerificar.ZonaHorariaGMTBase, helper.DifferenceBetweenGMTAndLocalTimeZone, timeLineNotificacion.CreacionNotificacion);
}
return(timeLineNotificacion);
}
}
public async Task <List <HistorialPagosPersonasDTO> > ListarHistorialPagosDeUnaPersona(BuscadorDTO buscador)
{
using (SportsGoEntities context = new SportsGoEntities(false))
{
PagosRepository pagosRepo = new PagosRepository(context);
List <HistorialPagosPersonasDTO> listaHistorialPagos = await pagosRepo.ListarHistorialPagosDeUnaPersona(buscador);
if (listaHistorialPagos != null && listaHistorialPagos.Count > 0)
{
Monedas monedaColombiana = await pagosRepo.BuscarMonedaColombiana();
Dictionary <MonedasEnum, string> diccionarioAbreviaturas = listaHistorialPagos.Where(x => x.Monedas.MonedaEnum != MonedasEnum.PesosColombianos).Select(x => x.Monedas).DistinctBy(x => x.MonedaEnum).ToDictionary(x => x.MonedaEnum, x => x.AbreviaturaMoneda);
Dictionary <MonedasEnum, decimal> diccionarioCambios = new Dictionary <MonedasEnum, decimal>();
QueryMoneyExchanger queryExchanger = new QueryMoneyExchanger();
foreach (MonedasEnum monedaParaConsultar in diccionarioAbreviaturas.Keys)
{
if (monedaParaConsultar != MonedasEnum.PesosColombianos)
{
YahooExchangeEntity exchangeEntity = await queryExchanger.QueryMoneyExchange(monedaColombiana.AbreviaturaMoneda, diccionarioAbreviaturas[monedaParaConsultar]);
Monedas monedaBuscada = await pagosRepo.BuscarMoneda(monedaParaConsultar);
if (exchangeEntity != null)
{
monedaBuscada.CambioMoneda = exchangeEntity.Query.Results.Rate.Rate;
}
diccionarioCambios.Add(monedaParaConsultar, monedaBuscada.CambioMoneda);
}
else
{
diccionarioCambios.Add(monedaParaConsultar, monedaColombiana.CambioMoneda);
}
}
DateTimeHelperNoPortable helper = new DateTimeHelperNoPortable();
foreach (HistorialPagosPersonasDTO historial in listaHistorialPagos)
{
if (historial.Monedas.MonedaEnum != MonedasEnum.PesosColombianos)
{
historial.Precio *= diccionarioCambios[historial.Monedas.MonedaEnum];
}
historial.FechaPago = helper.ConvertDateTimeFromAnotherTimeZone(buscador.ZonaHorariaGMTBase, helper.DifferenceBetweenGMTAndLocalTimeZone, historial.FechaPago);
}
}
try
{
// No es obligatorio para el paso que actualize el cambio de moneda
await context.SaveChangesAsync();
}
catch (Exception)
{
}
return(listaHistorialPagos);
}
}
public async Task <WrapperSimpleTypesDTO> EliminarHabilidad(Habilidades habilidadParaEliminar)
{
using (SportsGoEntities context = new SportsGoEntities(false))
{
HabilidadesRepository habilidadesRepo = new HabilidadesRepository(context);
HabilidadesContenidos habilidadContenidosParaBorrar = new HabilidadesContenidos
{
CodigoHabilidad = habilidadParaEliminar.Consecutivo
};
habilidadesRepo.EliminarMultiplesHabilidadesContenidosPorCodigoHabilidad(habilidadContenidosParaBorrar);
habilidadesRepo.EliminarHabilidad(habilidadParaEliminar);
WrapperSimpleTypesDTO wrapperEliminarHabilidad = new WrapperSimpleTypesDTO();
wrapperEliminarHabilidad.NumeroRegistrosAfectados = await context.SaveChangesAsync();
if (wrapperEliminarHabilidad.NumeroRegistrosAfectados > 0)
{
wrapperEliminarHabilidad.Exitoso = true;
}
return(wrapperEliminarHabilidad);
}
}
public async Task <WrapperSimpleTypesDTO> EliminarCandidatoResponsable(Candidatos candidatoResponsableParaBorrar)
{
using (SportsGoEntities context = new SportsGoEntities(false))
{
CandidatosRepository candidatosRepo = new CandidatosRepository(context);
Candidatos candidatoExistente = await candidatosRepo.DesasignarResponsableDeUnCandidato(candidatoResponsableParaBorrar);
CandidatosResponsables responsableABorrar = new CandidatosResponsables
{
Consecutivo = candidatoResponsableParaBorrar.CodigoResponsable.Value
};
candidatosRepo.EliminarCandidatoResponsable(responsableABorrar);
WrapperSimpleTypesDTO wrapperEliminarCandidatoResponsable = new WrapperSimpleTypesDTO();
wrapperEliminarCandidatoResponsable.NumeroRegistrosAfectados = await context.SaveChangesAsync();
if (wrapperEliminarCandidatoResponsable.NumeroRegistrosAfectados > 0)
{
wrapperEliminarCandidatoResponsable.Exitoso = true;
}
return(wrapperEliminarCandidatoResponsable);
}
}
public async Task <WrapperSimpleTypesDTO> AsignarTerminosCondicionesLista(List <TerminosCondiciones> terminosCondicionesParaAsignar)
{
using (SportsGoEntities context = new SportsGoEntities(false))
{
AdministracionRepository adminRepo = new AdministracionRepository(context);
foreach (TerminosCondiciones terminos in terminosCondicionesParaAsignar)
{
bool existe = await adminRepo.BuscarSiExisteTerminosYCondiciones(terminos);
if (existe)
{
TerminosCondiciones terminosCondicionesExistentes = await adminRepo.ModificarTerminosCondiciones(terminos);
}
else
{
adminRepo.CrearTerminosCondiciones(terminos);
}
}
WrapperSimpleTypesDTO wrapperAsignarTerminosCondicionesLista = new WrapperSimpleTypesDTO();
wrapperAsignarTerminosCondicionesLista.NumeroRegistrosAfectados = await context.SaveChangesAsync();
if (wrapperAsignarTerminosCondicionesLista.NumeroRegistrosAfectados > 0)
{
wrapperAsignarTerminosCondicionesLista.Exitoso = true;
}
return(wrapperAsignarTerminosCondicionesLista);
}
}
public async Task CandidatoRepository_ModificarCandidato_ShouldModify()
{
using (SportsGoEntities context = new SportsGoEntities(false))
using (DbContextTransaction dbContextTransaction = context.Database.BeginTransaction())
{
CandidatosRepository candidatoRepository = new CandidatosRepository(context);
Candidatos candidatoParaCrear = new Candidatos
{
Consecutivo = 4,
CodigoPersona = 8,
CodigoGenero = 1,
Estatura = 180,
Peso = 70,
Biografia = "Yo ser Niño MVC Angular y no leer comentarios trollo yo ser",
FechaNacimiento = new DateTime(1995, 11, 9),
};
var hola = context.Personas.Find(8);
candidatoParaCrear.Personas = hola;
candidatoParaCrear.Personas.Nombres = "Sergioo";
Candidatos candidatoExistente = await candidatoRepository.ModificarInformacionCandidato(candidatoParaCrear);
Assert.IsNotNull(candidatoExistente);
}
}
public async Task <WrapperSimpleTypesDTO> CrearAnuncio(Anuncios anuncioParaCrear)
{
using (SportsGoEntities context = new SportsGoEntities(false))
{
AnunciantesRepository anuncianteRepo = new AnunciantesRepository(context);
PlanesDTO configuracionPlan = await anuncianteRepo.BuscarConfiguracionAnuncioPorPlanAnunciante(anuncioParaCrear.CodigoAnunciante);
anuncioParaCrear.Vencimiento = DateTimeHelper.SumarDiasSegunTipoCalendario(anuncioParaCrear.FechaInicio, configuracionPlan.NumeroDiasVigenciaAnuncio);
anuncioParaCrear.NumeroApariciones = configuracionPlan.NumeroAparicionesAnuncio;
anuncianteRepo.CrearAnuncio(anuncioParaCrear);
WrapperSimpleTypesDTO wrapperCrearAnuncio = new WrapperSimpleTypesDTO();
wrapperCrearAnuncio.NumeroRegistrosAfectados = await context.SaveChangesAsync();
if (wrapperCrearAnuncio.NumeroRegistrosAfectados > 0)
{
wrapperCrearAnuncio.Exitoso = true;
wrapperCrearAnuncio.ConsecutivoCreado = anuncioParaCrear.Consecutivo;
}
return(wrapperCrearAnuncio);
}
}
public async Task <WrapperSimpleTypesDTO> ModificarArchivoStream(int consecutivoArchivo, int codigoTipoArchivo, Stream sourceStream)
{
using (SportsGoEntities context = new SportsGoEntities(false))
using (DbContextTransaction transaction = context.Database.BeginTransaction())
{
ArchivosRepository archivoRepo = new ArchivosRepository(context);
Archivos archivoTipoParaModificar = new Archivos
{
Consecutivo = consecutivoArchivo,
CodigoTipoArchivo = codigoTipoArchivo,
ArchivoContenido = new byte[] { 0, 1, 2 }
};
archivoRepo.ModificarCodigoTipoArchivoDeUnArchivo(archivoTipoParaModificar);
await archivoRepo.ModificarArchivoContenidoStream(consecutivoArchivo, sourceStream);
WrapperSimpleTypesDTO wrapper = new WrapperSimpleTypesDTO();
wrapper.NumeroRegistrosAfectados = await context.SaveChangesAsync();
transaction.Commit();
if (wrapper.NumeroRegistrosAfectados > 0)
{
wrapper.Exitoso = true;
}
return(wrapper);
}
}
public async Task <WrapperSimpleTypesDTO> EliminarArchivoAnuncio(Anuncios anuncioArchivoParaEliminar)
{
using (SportsGoEntities context = new SportsGoEntities(false))
{
Archivos archivoParaEliminar = new Archivos
{
Consecutivo = anuncioArchivoParaEliminar.CodigoArchivo.Value,
};
AnunciantesRepository anuncianteRepo = new AnunciantesRepository(context);
Anuncios anuncioExistente = await anuncianteRepo.DesasignarArchivoAnuncio(anuncioArchivoParaEliminar);
ArchivosRepository archivoRepo = new ArchivosRepository(context);
archivoRepo.EliminarArchivo(archivoParaEliminar);
WrapperSimpleTypesDTO wrapperDesasignarArchivoAnuncio = new WrapperSimpleTypesDTO();
wrapperDesasignarArchivoAnuncio.NumeroRegistrosAfectados = await context.SaveChangesAsync();
if (wrapperDesasignarArchivoAnuncio.NumeroRegistrosAfectados > 0)
{
wrapperDesasignarArchivoAnuncio.Exitoso = true;
}
return(wrapperDesasignarArchivoAnuncio);
}
}
public async Task <WrapperSimpleTypesDTO> DesasignarPlanDefault(Planes planParaDesasignar)
{
using (SportsGoEntities context = new SportsGoEntities(false))
{
PlanesRepository planRepository = new PlanesRepository(context);
int?codigoTipoPerfilPlan = await planRepository.BuscarCodigoTipoPerfilDeUnPlan(planParaDesasignar);
if (!codigoTipoPerfilPlan.HasValue)
{
throw new InvalidOperationException("El plan no tiene un tipo de perfil especificado!. BUUUUUGGGGGG!.");
}
TipoPerfil tipoPerfil = codigoTipoPerfilPlan.Value.ToEnum <TipoPerfil>();
int numeroDePlanesDefault = await planRepository.NumeroPlanesDefault(tipoPerfil);
if (numeroDePlanesDefault <= 1)
{
throw new InvalidOperationException("No puedes quedarte sin planes default para el perfil de " + tipoPerfil.ToString() + "!.");
}
Planes planExistente = await planRepository.DesasignarPlanDefault(planParaDesasignar);
WrapperSimpleTypesDTO wrapperDesasignarPlanDefault = new WrapperSimpleTypesDTO();
wrapperDesasignarPlanDefault.NumeroRegistrosAfectados = await context.SaveChangesAsync();
if (wrapperDesasignarPlanDefault.NumeroRegistrosAfectados > 0)
{
wrapperDesasignarPlanDefault.Exitoso = true;
}
return(wrapperDesasignarPlanDefault);
}
}
public async Task <WrapperSimpleTypesDTO> CrearChat(Chats chatParaCrearOwner)
{
using (SportsGoEntities context = new SportsGoEntities(false))
{
ChatsRepository chatsRepo = new ChatsRepository(context);
// Verifico si ya existe mi chat principal, si existe lo reactivo, si no lo creo
bool existeChatOwner = await chatsRepo.VerificarSiYaExisteChat(chatParaCrearOwner);
if (existeChatOwner)
{
chatParaCrearOwner = await chatsRepo.ReactivarChat(chatParaCrearOwner);
}
else
{
chatParaCrearOwner.EstadoChat = EstadosChat.Activo;
chatParaCrearOwner.Creacion = DateTime.Now;
chatsRepo.CrearChat(chatParaCrearOwner);
}
Chats chatNoOwner = new Chats
{
CodigoPersonaOwner = chatParaCrearOwner.CodigoPersonaNoOwner,
CodigoPersonaNoOwner = chatParaCrearOwner.CodigoPersonaOwner
};
// Verifico si ya existe mi chat secundario de la persona a que le voy a enviar, si existe no hago nada, si no lo creo
// Lo dejo en estado inactivo para que crear el chat principal no le cree un chat a la persona secundaria
// Solo cuando un mensaje es mandado es que ambos son reactivados
bool existeChatNoOwner = await chatsRepo.VerificarSiYaExisteChat(chatNoOwner);
if (!existeChatNoOwner)
{
chatNoOwner.EstadoChat = EstadosChat.PendienteParaBorrarMensajes;
chatNoOwner.Creacion = DateTime.Now;
chatsRepo.CrearChat(chatNoOwner);
}
WrapperSimpleTypesDTO wrapperCrearChat = new WrapperSimpleTypesDTO();
wrapperCrearChat.NumeroRegistrosAfectados = await context.SaveChangesAsync();
if (wrapperCrearChat.NumeroRegistrosAfectados > 0 || chatParaCrearOwner.Consecutivo > 0)
{
wrapperCrearChat.Exitoso = true;
wrapperCrearChat.ConsecutivoCreado = chatParaCrearOwner.Consecutivo;
if (chatNoOwner.Consecutivo > 0)
{
wrapperCrearChat.ConsecutivoChatRecibe = chatNoOwner.Consecutivo;
}
else
{
wrapperCrearChat.ConsecutivoChatRecibe = await chatsRepo.BuscarConsecutivoChat(chatNoOwner);
}
}
return(wrapperCrearChat);
}
}
public async Task <WrapperSimpleTypesDTO> EliminarPlan(Planes planParaEliminar)
{
using (SportsGoEntities context = new SportsGoEntities(false))
{
PlanesRepository planRepository = new PlanesRepository(context);
int?codigoTipoPerfilPlan = await planRepository.BuscarCodigoTipoPerfilDeUnPlan(planParaEliminar);
if (!codigoTipoPerfilPlan.HasValue)
{
throw new InvalidOperationException("El plan no tiene un tipo de perfil especificado!. BUUUUUGGGGGG!.");
}
TipoPerfil tipoPerfil = codigoTipoPerfilPlan.Value.ToEnum <TipoPerfil>();
int numeroDePlanesDefault = await planRepository.NumeroPlanesDefault(tipoPerfil);
if (numeroDePlanesDefault <= 1)
{
bool esPlanDefault = await planRepository.BuscarSiPlanEsDefault(planParaEliminar);
if (esPlanDefault)
{
throw new InvalidOperationException("No puedes quedarte sin planes default para el perfil de " + tipoPerfil.ToString() + "!.");
}
}
NoticiasRepository noticiasRepo = new NoticiasRepository(context);
Notificaciones notificacion = new Notificaciones
{
CodigoPlanNuevo = planParaEliminar.Consecutivo
};
noticiasRepo.EliminarNotificacionesDeUnPlan(notificacion);
PlanesContenidos planContenido = new PlanesContenidos
{
CodigoPlan = planParaEliminar.Consecutivo
};
planRepository.EliminarMultiplesPlanesContenidos(planContenido);
planRepository.EliminarPlan(planParaEliminar);
ArchivosRepository archivoRepo = new ArchivosRepository(context);
Archivos archivo = new Archivos
{
Consecutivo = planParaEliminar.CodigoArchivo
};
archivoRepo.EliminarArchivo(archivo);
WrapperSimpleTypesDTO wrapperEliminarPlan = new WrapperSimpleTypesDTO();
wrapperEliminarPlan.NumeroRegistrosAfectados = await context.SaveChangesAsync();
if (wrapperEliminarPlan.NumeroRegistrosAfectados > 0)
{
wrapperEliminarPlan.Exitoso = true;
}
return(wrapperEliminarPlan);
}
}
public async Task <PersonasDTO> BuscarPersona(Personas personaParaBuscar)
{
using (SportsGoEntities context = new SportsGoEntities(false))
{
PersonasRepository personaRepo = new PersonasRepository(context);
PersonasDTO personaBuscada = await personaRepo.BuscarPersona(personaParaBuscar);
if (personaBuscada.CandidatoDeLaPersona != null)
{
if (personaBuscada.CandidatoDeLaPersona.CodigoResponsable.HasValue)
{
CandidatosRepository candidatoRepo = new CandidatosRepository(context);
CandidatosResponsables candidatoReponsable = new CandidatosResponsables
{
Consecutivo = personaBuscada.CandidatoDeLaPersona.CodigoResponsable.Value
};
personaBuscada.CandidatoDeLaPersona.CandidatosResponsables = await candidatoRepo.BuscarSoloCandidatoResponsableDTO(candidatoReponsable);
}
}
return(personaBuscada);
}
}
public async Task <WrapperSimpleTypesDTO> CrearHabilidadesCandidato(List <HabilidadesCandidatos> habilidadCandidatoParaCrear)
{
using (SportsGoEntities context = new SportsGoEntities(false))
{
HabilidadesRepository habilidadesRepo = new HabilidadesRepository(context);
// Elimina todas las habilidades para recrearlas luega
habilidadesRepo.EliminarMultiplesHabilidadesCandidatosPorCodigoCandidato(habilidadCandidatoParaCrear[0]);
// Evitar que si se le manda una instancia la vuelva a crear
habilidadCandidatoParaCrear.ForEach(x => x.Habilidades = null);
habilidadesRepo.CrearHabilidadesCandidato(habilidadCandidatoParaCrear);
WrapperSimpleTypesDTO wrapperCrearHabilidadesCandidato = new WrapperSimpleTypesDTO();
wrapperCrearHabilidadesCandidato.NumeroRegistrosAfectados = await context.SaveChangesAsync();
if (wrapperCrearHabilidadesCandidato.NumeroRegistrosAfectados > 0)
{
wrapperCrearHabilidadesCandidato.Exitoso = true;
}
return(wrapperCrearHabilidadesCandidato);
}
}
public async Task <WrapperSimpleTypesDTO> AsignarImagenBanner(Personas personaParaAsignarImagenBanner)
{
using (SportsGoEntities context = new SportsGoEntities(false))
{
PersonasRepository personaRepo = new PersonasRepository(context);
int?codigoImagenBanner = await personaRepo.BuscarCodigoImagenBanner(personaParaAsignarImagenBanner);
personaParaAsignarImagenBanner.ArchivosBanner.CodigoTipoArchivo = (int)TipoArchivo.Imagen;
if (codigoImagenBanner.HasValue)
{
ArchivosRepository archivoRepo = new ArchivosRepository(context);
personaParaAsignarImagenBanner.ArchivosBanner.Consecutivo = codigoImagenBanner.Value;
archivoRepo.ModificarArchivo(personaParaAsignarImagenBanner.ArchivosBanner);
}
else
{
Personas personaExistente = await personaRepo.AsignarImagenBanner(personaParaAsignarImagenBanner);
}
WrapperSimpleTypesDTO wrapperCrearImagenBanner = new WrapperSimpleTypesDTO();
wrapperCrearImagenBanner.NumeroRegistrosAfectados = await context.SaveChangesAsync();
if (wrapperCrearImagenBanner.NumeroRegistrosAfectados > 0)
{
wrapperCrearImagenBanner.Exitoso = true;
wrapperCrearImagenBanner.ConsecutivoArchivoCreado = Convert.ToInt64(personaParaAsignarImagenBanner.CodigoArchivoImagenBanner);
}
return(wrapperCrearImagenBanner);
}
}
public async Task <WrapperSimpleTypesDTO> ModificarHabilidad(Habilidades habilidadParaModificar)
{
using (SportsGoEntities context = new SportsGoEntities(false))
{
HabilidadesRepository habilidadesRepo = new HabilidadesRepository(context);
habilidadParaModificar.CodigoTipoHabilidad = (int)habilidadParaModificar.TipoHabilidad;
Habilidades habilidadExistente = await habilidadesRepo.ModificarHabilidad(habilidadParaModificar);
if (habilidadParaModificar.HabilidadesContenidos != null && habilidadParaModificar.HabilidadesContenidos.Count > 0)
{
foreach (var item in habilidadParaModificar.HabilidadesContenidos)
{
await habilidadesRepo.ModificarHabilidadContenido(item);
}
}
WrapperSimpleTypesDTO wrapperModificarHabilidad = new WrapperSimpleTypesDTO();
wrapperModificarHabilidad.NumeroRegistrosAfectados = await context.SaveChangesAsync();
if (wrapperModificarHabilidad.NumeroRegistrosAfectados > 0)
{
wrapperModificarHabilidad.Exitoso = true;
}
return(wrapperModificarHabilidad);
}
}
public async Task <List <GruposEventosAsistentesDTO> > ListarEventosAsistentesDeUnaPersona(BuscadorDTO buscador)
{
using (SportsGoEntities context = new SportsGoEntities(false))
{
GruposRepository grupoRepository = new GruposRepository(context);
DateTimeHelperNoPortable helper = new DateTimeHelperNoPortable();
if (buscador.FechaFiltroBase != DateTime.MinValue)
{
buscador.FechaFiltroBase = helper.ConvertDateTimeFromAnotherTimeZone(buscador.ZonaHorariaGMTBase, helper.DifferenceBetweenGMTAndLocalTimeZone, buscador.FechaFiltroBase);
}
List <GruposEventosAsistentesDTO> listaEventosAsistentesDeUnaPersona = await grupoRepository.ListarEventosAsistentesDeUnaPersona(buscador);
if (listaEventosAsistentesDeUnaPersona != null && listaEventosAsistentesDeUnaPersona.Count > 0)
{
foreach (var eventoAsistente in listaEventosAsistentesDeUnaPersona)
{
eventoAsistente.GruposEventos.Creacion = helper.ConvertDateTimeFromAnotherTimeZone(buscador.ZonaHorariaGMTBase, helper.DifferenceBetweenGMTAndLocalTimeZone, eventoAsistente.GruposEventos.Creacion);
eventoAsistente.GruposEventos.FechaInicio = helper.ConvertDateTimeFromAnotherTimeZone(buscador.ZonaHorariaGMTBase, helper.DifferenceBetweenGMTAndLocalTimeZone, eventoAsistente.GruposEventos.FechaInicio);
eventoAsistente.GruposEventos.FechaTerminacion = helper.ConvertDateTimeFromAnotherTimeZone(buscador.ZonaHorariaGMTBase, helper.DifferenceBetweenGMTAndLocalTimeZone, eventoAsistente.GruposEventos.FechaTerminacion);
}
}
return(listaEventosAsistentesDeUnaPersona);
}
}
public async Task <List <NoticiasDTO> > ListarNoticias(BuscadorDTO buscador)
{
using (SportsGoEntities context = new SportsGoEntities(false))
{
NoticiasRepository noticiaRepo = new NoticiasRepository(context);
DateTimeHelperNoPortable helper = new DateTimeHelperNoPortable();
if (buscador.FechaInicio != DateTime.MinValue)
{
buscador.FechaInicio = helper.ConvertDateTimeFromAnotherTimeZone(buscador.ZonaHorariaGMTBase, helper.DifferenceBetweenGMTAndLocalTimeZone, buscador.FechaInicio);
}
List <NoticiasDTO> listaNoticias = await noticiaRepo.ListarNoticiasNoNotificaciones(buscador);
if (listaNoticias != null && listaNoticias.Count > 0)
{
foreach (var noticia in listaNoticias)
{
noticia.Creacion = helper.ConvertDateTimeFromAnotherTimeZone(buscador.ZonaHorariaGMTBase, helper.DifferenceBetweenGMTAndLocalTimeZone, noticia.Creacion);
}
}
return(listaNoticias);
}
}
