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 <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> 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> 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> 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> 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 <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> AsignarImagenPerfilAdministrador(int codigoUsuario, Stream streamSource)
{
using (SportsGoEntities context = new SportsGoEntities(false))
{
AdministracionRepository adminRepo = new AdministracionRepository(context);
ArchivosBusiness archivoBuss = new ArchivosBusiness();
ImagenesPerfilAdministradores imagenPerfilExistente = await adminRepo.BuscarImagenPerfilAdministrador(codigoUsuario);
int?codigoArchivoExistente = null;
WrapperSimpleTypesDTO wrapper = await archivoBuss.CrearArchivoStream((int)TipoArchivo.Imagen, streamSource);
if (imagenPerfilExistente == null)
{
ImagenesPerfilAdministradores imagenParaCrear = new ImagenesPerfilAdministradores
{
CodigoUsuario = codigoUsuario,
CodigoArchivo = Convert.ToInt32(wrapper.ConsecutivoArchivoCreado)
};
adminRepo.CrearImagenPerfilAdministrador(imagenParaCrear);
}
else
{
// Guardo el viejo codigo de archivo para borrarlo luego
codigoArchivoExistente = imagenPerfilExistente.CodigoArchivo;
imagenPerfilExistente = await adminRepo.AsignarImagenPerfil(codigoUsuario, Convert.ToInt32(wrapper.ConsecutivoArchivoCreado));
}
// Borro el archivo viejo
if (codigoArchivoExistente.HasValue)
{
ArchivosRepository archivoRepo = new ArchivosRepository(context);
Archivos archivoParaBorrar = new Archivos
{
Consecutivo = codigoArchivoExistente.Value
};
archivoRepo.EliminarArchivo(archivoParaBorrar);
}
WrapperSimpleTypesDTO wrapperAsignarImagenPerfilAdministrador = new WrapperSimpleTypesDTO();
wrapperAsignarImagenPerfilAdministrador.NumeroRegistrosAfectados = await context.SaveChangesAsync();
if (wrapperAsignarImagenPerfilAdministrador.NumeroRegistrosAfectados > 0)
{
wrapperAsignarImagenPerfilAdministrador.Exitoso = true;
wrapperAsignarImagenPerfilAdministrador.ConsecutivoCreado = imagenPerfilExistente.Consecutivo;
wrapperAsignarImagenPerfilAdministrador.ConsecutivoArchivoCreado = wrapper.ConsecutivoArchivoCreado;
}
return(wrapperAsignarImagenPerfilAdministrador);
}
}
public async Task <WrapperSimpleTypesDTO> AsignarArchivoReciboPago(int codigoHistorialPago, int codigoArchivo, Stream sourceStream)
{
using (SportsGoEntities context = new SportsGoEntities(false))
using (DbContextTransaction transaction = context.Database.BeginTransaction())
{
ArchivosRepository archivoRepo = new ArchivosRepository(context);
Archivos archivoParaCrear = new Archivos
{
CodigoTipoArchivo = (int)TipoArchivo.Imagen,
ArchivoContenido = new byte[] { 0, 1, 2 }
};
archivoRepo.CrearArchivo(archivoParaCrear);
WrapperSimpleTypesDTO wrapper = new WrapperSimpleTypesDTO();
wrapper.NumeroRegistrosAfectados = await context.SaveChangesAsync();
await archivoRepo.ModificarArchivoContenidoStream(archivoParaCrear.Consecutivo, sourceStream);
if (wrapper.NumeroRegistrosAfectados > 0 || archivoParaCrear.Consecutivo > 0)
{
wrapper.Exitoso = true;
wrapper.ConsecutivoCreado = archivoParaCrear.Consecutivo;
wrapper.ConsecutivoArchivoCreado = archivoParaCrear.Consecutivo;
PagosRepository pagosRepo = new PagosRepository(context);
// Meto el consecutivo del archivo generado por el EF por la creacion
HistorialPagosPersonas pagoParaAsignar = new HistorialPagosPersonas
{
Consecutivo = codigoHistorialPago,
CodigoArchivo = archivoParaCrear.Consecutivo
};
HistorialPagosPersonas pagoExistente = await pagosRepo.AsignarArchivoHistorialPago(pagoParaAsignar);
// Elimino el viejo archivo
if (codigoArchivo > 0)
{
Archivos archivoParaBorrar = new Archivos
{
Consecutivo = codigoArchivo
};
archivoRepo.EliminarArchivo(archivoParaBorrar);
}
wrapper.NumeroRegistrosAfectados += await context.SaveChangesAsync();
transaction.Commit();
}
return(wrapper);
}
}
public async Task <WrapperSimpleTypesDTO> ModificarArchivoCandidatoVideos(int codigoTipoArchivo, int codigoCandidatoVideo, int codigoArchivo, Stream sourceStream)
{
using (SportsGoEntities context = new SportsGoEntities(false))
using (DbContextTransaction transaction = context.Database.BeginTransaction())
{
ArchivosRepository archivoRepo = new ArchivosRepository(context);
Archivos archivoParaCrear = new Archivos
{
CodigoTipoArchivo = codigoTipoArchivo,
ArchivoContenido = new byte[] { 0, 1, 2 }
};
archivoRepo.CrearArchivo(archivoParaCrear);
WrapperSimpleTypesDTO wrapper = new WrapperSimpleTypesDTO();
wrapper.NumeroRegistrosAfectados = await context.SaveChangesAsync();
await archivoRepo.ModificarArchivoContenidoStream(archivoParaCrear.Consecutivo, sourceStream);
if (wrapper.NumeroRegistrosAfectados > 0 || archivoParaCrear.Consecutivo > 0)
{
wrapper.Exitoso = true;
wrapper.ConsecutivoCreado = archivoParaCrear.Consecutivo;
wrapper.ConsecutivoArchivoCreado = archivoParaCrear.Consecutivo;
CandidatosRepository candidatosRepo = new CandidatosRepository(context);
// Meto el consecutivo del archivo generado por el EF por la creacion
CandidatosVideos candidatoVideo = new CandidatosVideos
{
Consecutivo = codigoCandidatoVideo,
CodigoArchivo = archivoParaCrear.Consecutivo
};
CandidatosVideos candidatoVideoExistente = await candidatosRepo.ModificarCodigoArchivoCandidatoVideo(candidatoVideo);
// Elimino el viejo archivo
if (codigoArchivo > 0)
{
Archivos archivoParaBorrar = new Archivos
{
Consecutivo = codigoArchivo
};
archivoRepo.EliminarArchivo(archivoParaBorrar);
}
wrapper.NumeroRegistrosAfectados += await context.SaveChangesAsync();
transaction.Commit();
}
return(wrapper);
}
}
public async Task <WrapperSimpleTypesDTO> EliminarGrupoEvento(GruposEventos grupoEventoParaEliminar)
{
using (SportsGoEntities context = new SportsGoEntities(false))
{
CategoriasRepository categoriaRepo = new CategoriasRepository(context);
CategoriasEventos categoriaGrupoParaBorrar = new CategoriasEventos
{
CodigoEvento = grupoEventoParaEliminar.Consecutivo
};
categoriaRepo.EliminarMultiplesCategoriasEventos(categoriaGrupoParaBorrar);
GruposRepository grupoRepository = new GruposRepository(context);
GruposEventosAsistentes gruposAsistentesParaBorrar = new GruposEventosAsistentes
{
CodigoEvento = grupoEventoParaEliminar.Consecutivo
};
grupoRepository.EliminarMultiplesGrupoEventoAsistente(gruposAsistentesParaBorrar);
NoticiasRepository noticiasRepo = new NoticiasRepository(context);
Notificaciones notificacionEvento = new Notificaciones
{
CodigoEvento = grupoEventoParaEliminar.Consecutivo
};
noticiasRepo.EliminarNotificacionesDeUnEvento(notificacionEvento);
int?archivoGrupoEvento = await grupoRepository.BuscarArchivoGrupoEvento(grupoEventoParaEliminar);
grupoRepository.EliminarGrupoEvento(grupoEventoParaEliminar);
WrapperSimpleTypesDTO wrapperEliminarGrupoEvento = new WrapperSimpleTypesDTO();
wrapperEliminarGrupoEvento.NumeroRegistrosAfectados = await context.SaveChangesAsync();
if (archivoGrupoEvento.HasValue)
{
ArchivosRepository archivoRepo = new ArchivosRepository(context);
Archivos archivoParaEliminar = new Archivos
{
Consecutivo = archivoGrupoEvento.Value,
};
archivoRepo.EliminarArchivo(archivoParaEliminar);
}
wrapperEliminarGrupoEvento.NumeroRegistrosAfectados += await context.SaveChangesAsync();
if (wrapperEliminarGrupoEvento.NumeroRegistrosAfectados > 0)
{
wrapperEliminarGrupoEvento.Exitoso = true;
}
return(wrapperEliminarGrupoEvento);
}
}
public async Task <WrapperSimpleTypesDTO> EliminarCategoria(Categorias categoriaParaEliminar)
{
using (SportsGoEntities context = new SportsGoEntities(false))
{
if (categoriaParaEliminar.Consecutivo == 3 && categoriaParaEliminar.Consecutivo == 5 &&
categoriaParaEliminar.Consecutivo == 6 && categoriaParaEliminar.Consecutivo == 7)
{
throw new InvalidOperationException("Estas categorias deben existir y si o si ya que son las definidas para la posicion");
}
Archivos archivo = new Archivos
{
Consecutivo = categoriaParaEliminar.CodigoArchivo
};
HabilidadesRepository habilidadesRepo = new HabilidadesRepository(context);
Habilidades habilidadesParaBorrar = new Habilidades
{
CodigoCategoria = categoriaParaEliminar.Consecutivo
};
List <int> listaCodigoHabilidades = await habilidadesRepo.ListarCodigoHabilidadesPorCategoria(habilidadesParaBorrar);
foreach (var codigo in listaCodigoHabilidades)
{
habilidadesRepo.EliminarMultiplesHabilidadesContenidosPorCodigoHabilidad(codigo);
}
habilidadesRepo.EliminarMultiplesHabilidadesPorCodigoCategoria(habilidadesParaBorrar);
CategoriasRepository categoriasRepo = new CategoriasRepository(context);
CategoriasContenidos categoriaContenidoParaBorrar = new CategoriasContenidos
{
CodigoCategoria = categoriaParaEliminar.Consecutivo
};
categoriasRepo.EliminarMultiplesCategoriasContenidos(categoriaContenidoParaBorrar);
categoriasRepo.EliminarCategoria(categoriaParaEliminar);
ArchivosRepository archivoRepo = new ArchivosRepository(context);
archivoRepo.EliminarArchivo(archivo);
WrapperSimpleTypesDTO wrapperEliminarCategoria = new WrapperSimpleTypesDTO();
wrapperEliminarCategoria.NumeroRegistrosAfectados = await context.SaveChangesAsync();
if (wrapperEliminarCategoria.NumeroRegistrosAfectados > 0)
{
wrapperEliminarCategoria.Exitoso = true;
}
return(wrapperEliminarCategoria);
}
}
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 async Task <WrapperSimpleTypesDTO> EliminarAnuncio(Anuncios anuncioParaEliminar)
{
using (SportsGoEntities context = new SportsGoEntities(false))
{
AnunciantesRepository anuncianteRepo = new AnunciantesRepository(context);
AnunciosContenidos anuncioContenidoParaBorrar = new AnunciosContenidos
{
CodigoAnuncio = anuncioParaEliminar.Consecutivo
};
anuncianteRepo.EliminarMultiplesContenidosAnuncios(anuncioContenidoParaBorrar);
AnunciosPaises anuncioPaisesParaBorrar = new AnunciosPaises
{
CodigoAnuncio = anuncioParaEliminar.Consecutivo
};
anuncianteRepo.EliminarMultiplesAnuncioPais(anuncioPaisesParaBorrar);
CategoriasRepository categoriasRepo = new CategoriasRepository(context);
CategoriasAnuncios categoriasAnunciosParaBorrar = new CategoriasAnuncios
{
CodigoAnuncio = anuncioParaEliminar.Consecutivo
};
categoriasRepo.EliminarMultiplesCategoriasAnuncios(categoriasAnunciosParaBorrar);
int?codigoArchivoDeAnuncio = await anuncianteRepo.BuscarArchivoDeUnAnuncio(anuncioParaEliminar);
anuncianteRepo.EliminarAnuncio(anuncioParaEliminar);
WrapperSimpleTypesDTO wrapperEliminarAnuncio = new WrapperSimpleTypesDTO();
wrapperEliminarAnuncio.NumeroRegistrosAfectados = await context.SaveChangesAsync();
if (codigoArchivoDeAnuncio.HasValue)
{
ArchivosRepository archivoRepo = new ArchivosRepository(context);
Archivos archivoParaEliminar = new Archivos
{
Consecutivo = codigoArchivoDeAnuncio.Value,
};
archivoRepo.EliminarArchivo(archivoParaEliminar);
}
wrapperEliminarAnuncio.NumeroRegistrosAfectados += await context.SaveChangesAsync();
if (wrapperEliminarAnuncio.NumeroRegistrosAfectados > 0)
{
wrapperEliminarAnuncio.Exitoso = true;
}
return(wrapperEliminarAnuncio);
}
}
public async Task <WrapperSimpleTypesDTO> ModificarInformacionGrupoEvento(GruposEventos grupoEventoParaModificar)
{
using (SportsGoEntities context = new SportsGoEntities(false))
{
GruposRepository grupoRepository = new GruposRepository(context);
if (!grupoEventoParaModificar.CodigoArchivo.HasValue || grupoEventoParaModificar.CodigoArchivo <= 0)
{
int?codigoArchivo = await grupoRepository.BuscarArchivoGrupoEvento(grupoEventoParaModificar);
if (codigoArchivo.HasValue && codigoArchivo > 0)
{
ArchivosRepository archivoRepo = new ArchivosRepository(context);
Archivos archivo = new Archivos
{
Consecutivo = codigoArchivo.Value
};
archivoRepo.EliminarArchivo(archivo);
}
}
GruposEventos grupoEventoExistente = await grupoRepository.ModificarInformacionGrupoEvento(grupoEventoParaModificar);
if (grupoEventoParaModificar.CategoriasEventos != null && grupoEventoParaModificar.CategoriasEventos.Count > 0)
{
CategoriasRepository categoriaRepo = new CategoriasRepository(context);
CategoriasEventos categoriaEventos = new CategoriasEventos
{
CodigoEvento = grupoEventoParaModificar.Consecutivo
};
categoriaRepo.EliminarMultiplesCategoriasEventos(categoriaEventos);
categoriaRepo.CrearListaCategoriaEventos(grupoEventoParaModificar.CategoriasEventos);
}
WrapperSimpleTypesDTO wrapperModificarInformacionGrupoEvento = new WrapperSimpleTypesDTO();
wrapperModificarInformacionGrupoEvento.NumeroRegistrosAfectados = await context.SaveChangesAsync();
wrapperModificarInformacionGrupoEvento.Exitoso = true;
return(wrapperModificarInformacionGrupoEvento);
}
}
public async Task <WrapperSimpleTypesDTO> EliminarArchivo(Archivos archivoParaEliminar)
{
using (SportsGoEntities context = new SportsGoEntities(false))
{
ArchivosRepository archivoRepo = new ArchivosRepository(context);
archivoRepo.EliminarArchivo(archivoParaEliminar);
WrapperSimpleTypesDTO wrapperEliminarArchivo = new WrapperSimpleTypesDTO();
wrapperEliminarArchivo.NumeroRegistrosAfectados = await context.SaveChangesAsync();
if (wrapperEliminarArchivo.NumeroRegistrosAfectados > 0)
{
wrapperEliminarArchivo.Exitoso = true;
}
return(wrapperEliminarArchivo);
}
}
public async Task <WrapperSimpleTypesDTO> EliminarPagoPendientePorPagar(HistorialPagosPersonas historialPagoPersonaParaEliminar)
{
using (SportsGoEntities context = new SportsGoEntities(false))
{
PagosRepository pagosRepo = new PagosRepository(context);
bool estaEnPendiente = await pagosRepo.VerificarQuePagoEstaPendientePorPagar(historialPagoPersonaParaEliminar);
if (!estaEnPendiente)
{
throw new InvalidOperationException("Solo puedes eliminar un pago si esta en estado pendiente por pagar!.");
}
int?codigoArchivo = await pagosRepo.BuscarCodigoArchivoDelHistorico(historialPagoPersonaParaEliminar);
pagosRepo.EliminarHistorialPagoPersona(historialPagoPersonaParaEliminar);
if (codigoArchivo.HasValue && codigoArchivo > 0)
{
ArchivosRepository archivoRepo = new ArchivosRepository(context);
Archivos archivoParaBorrar = new Archivos
{
Consecutivo = codigoArchivo.Value
};
archivoRepo.EliminarArchivo(archivoParaBorrar);
}
WrapperSimpleTypesDTO wrapperEliminarPagoPendientePorPagar = new WrapperSimpleTypesDTO();
wrapperEliminarPagoPendientePorPagar.NumeroRegistrosAfectados = await context.SaveChangesAsync();
if (wrapperEliminarPagoPendientePorPagar.NumeroRegistrosAfectados > 0)
{
wrapperEliminarPagoPendientePorPagar.Exitoso = true;
}
return(wrapperEliminarPagoPendientePorPagar);
}
}