public async Task <AnunciosContenidos> ModificarAnuncioContenido(AnunciosContenidos anuncioContenidoParaModificar)
{
AnunciosContenidos anuncioContenidoExistente = await _context.AnunciosContenidos.Where(x => x.Consecutivo == anuncioContenidoParaModificar.Consecutivo).FirstOrDefaultAsync();
anuncioContenidoExistente.Titulo = anuncioContenidoParaModificar.Titulo.Trim();
anuncioContenidoExistente.Descripcion = !string.IsNullOrWhiteSpace(anuncioContenidoParaModificar.Descripcion) ? anuncioContenidoParaModificar.Descripcion.Trim() : string.Empty;
return(anuncioContenidoExistente);
}
public async Task <AnunciosContenidos> BuscarAnuncioContenidoPorConsecutivo(AnunciosContenidos anuncioContenidoParaBuscar)
{
using (SportsGoEntities context = new SportsGoEntities(false))
{
AnunciantesRepository anuncianteRepo = new AnunciantesRepository(context);
AnunciosContenidos anuncioContenidoBuscado = await anuncianteRepo.BuscarAnuncioContenidoPorConsecutivo(anuncioContenidoParaBuscar);
return(anuncioContenidoBuscado);
}
}
public async Task <AnunciosContenidos> BuscarAnuncioContenidoPorConsecutivo(AnunciosContenidos anuncioContenidoParaBuscar)
{
AnunciosContenidos anuncioContenidoBuscado = await(from anuncioContenido in _context.AnunciosContenidos
where anuncioContenido.Consecutivo == anuncioContenidoParaBuscar.Consecutivo
select anuncioContenido).Include(x => x.Anuncios)
.AsNoTracking()
.FirstOrDefaultAsync();
return(anuncioContenidoBuscado);
}
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> ModificarAnuncio(Anuncios anuncioParaModificar)
{
using (SportsGoEntities context = new SportsGoEntities(false))
{
AnunciantesRepository anuncianteRepo = new AnunciantesRepository(context);
Anuncios anuncioExistente = await anuncianteRepo.ModificarAnuncio(anuncioParaModificar);
if (anuncioParaModificar.AnunciosContenidos != null && anuncioParaModificar.AnunciosContenidos.Count > 0)
{
foreach (AnunciosContenidos anuncioContenido in anuncioParaModificar.AnunciosContenidos)
{
AnunciosContenidos anuncioContenidoExistente = await anuncianteRepo.ModificarAnuncioContenido(anuncioContenido);
}
}
if (anuncioParaModificar.AnunciosPaises != null && anuncioParaModificar.AnunciosPaises.Count > 0)
{
AnunciosPaises anuncioPaisParaBorrar = new AnunciosPaises
{
CodigoAnuncio = anuncioParaModificar.Consecutivo
};
anuncianteRepo.EliminarMultiplesAnuncioPais(anuncioPaisParaBorrar);
anuncianteRepo.CrearAnunciosPaises(anuncioParaModificar.AnunciosPaises);
}
if (anuncioParaModificar.CategoriasAnuncios != null && anuncioParaModificar.CategoriasAnuncios.Count > 0)
{
CategoriasRepository categoriasRepo = new CategoriasRepository(context);
CategoriasAnuncios categoriaAnuncioParaBorrar = new CategoriasAnuncios
{
CodigoAnuncio = anuncioParaModificar.Consecutivo
};
categoriasRepo.EliminarMultiplesCategoriasAnuncios(categoriaAnuncioParaBorrar);
categoriasRepo.CrearListaCategoriaAnuncios(anuncioParaModificar.CategoriasAnuncios);
}
WrapperSimpleTypesDTO wrapperModificarAnuncio = new WrapperSimpleTypesDTO();
wrapperModificarAnuncio.NumeroRegistrosAfectados = await context.SaveChangesAsync();
if (wrapperModificarAnuncio.NumeroRegistrosAfectados > 0)
{
wrapperModificarAnuncio.Exitoso = true;
}
return(wrapperModificarAnuncio);
}
}
public async Task <IHttpActionResult> EliminarAnuncioContenido(AnunciosContenidos anuncioContenidoParaEliminar)
{
if (anuncioContenidoParaEliminar == null || anuncioContenidoParaEliminar.Consecutivo <= 0)
{
return(BadRequest("anuncioContenidoParaEliminar vacio y/o invalido!."));
}
try
{
WrapperSimpleTypesDTO wrapperEliminarAnuncioContenido = await _anuncianteBusiness.EliminarAnuncioContenido(anuncioContenidoParaEliminar);
return(Ok(wrapperEliminarAnuncioContenido));
}
catch (Exception ex)
{
return(InternalServerError(ex));
}
}
public async Task <IHttpActionResult> ModificarAnuncioContenido(AnunciosContenidos anuncioContenidoParaModificar)
{
if (anuncioContenidoParaModificar == null || anuncioContenidoParaModificar.Consecutivo <= 0 || string.IsNullOrWhiteSpace(anuncioContenidoParaModificar.Titulo))
{
return(BadRequest("anuncioContenidoParaModificar vacio y/o invalido!."));
}
try
{
WrapperSimpleTypesDTO wrapperModificarAnuncioContenido = await _anuncianteBusiness.ModificarAnuncioContenido(anuncioContenidoParaModificar);
return(Ok(wrapperModificarAnuncioContenido));
}
catch (Exception ex)
{
return(InternalServerError(ex));
}
}
public async Task <IHttpActionResult> ListarAnunciosContenidosDeUnAnuncio(AnunciosContenidos anuncioContenidoParaListar)
{
if (anuncioContenidoParaListar == null || anuncioContenidoParaListar.CodigoAnuncio <= 0)
{
return(BadRequest("anuncioContenidoParaListar vacio y/o invalido!."));
}
try
{
List <AnunciosContenidos> listaContenidoDeUnAnuncio = await _anuncianteBusiness.ListarAnunciosContenidosDeUnAnuncio(anuncioContenidoParaListar);
return(Ok(listaContenidoDeUnAnuncio));
}
catch (Exception ex)
{
return(InternalServerError(ex));
}
}
public async Task <IHttpActionResult> BuscarAnuncioContenidoPorConsecutivo(AnunciosContenidos anuncioContenidoParaBuscar)
{
if (anuncioContenidoParaBuscar == null || anuncioContenidoParaBuscar.Consecutivo <= 0)
{
return(BadRequest("anuncioContenidoParaBuscar vacio y/o invalido!."));
}
try
{
AnunciosContenidos anuncioContenidoBuscado = await _anuncianteBusiness.BuscarAnuncioContenidoPorConsecutivo(anuncioContenidoParaBuscar);
return(Ok(anuncioContenidoBuscado));
}
catch (Exception ex)
{
return(InternalServerError(ex));
}
}
public async Task <WrapperSimpleTypesDTO> EliminarAnuncioContenido(AnunciosContenidos anuncioContenidoParaEliminar)
{
using (SportsGoEntities context = new SportsGoEntities(false))
{
AnunciantesRepository anuncianteRepo = new AnunciantesRepository(context);
anuncianteRepo.EliminarAnuncioContenido(anuncioContenidoParaEliminar);
WrapperSimpleTypesDTO wrapperEliminarAnuncioContenido = new WrapperSimpleTypesDTO();
wrapperEliminarAnuncioContenido.NumeroRegistrosAfectados = await context.SaveChangesAsync();
if (wrapperEliminarAnuncioContenido.NumeroRegistrosAfectados > 0)
{
wrapperEliminarAnuncioContenido.Exitoso = true;
}
return(wrapperEliminarAnuncioContenido);
}
}
public async Task <WrapperSimpleTypesDTO> ModificarMultiplesAnuncioContenido(List <AnunciosContenidos> anuncioContenidoParaModificar)
{
using (SportsGoEntities context = new SportsGoEntities(false))
{
AnunciantesRepository anuncianteRepo = new AnunciantesRepository(context);
foreach (var anuncioContenido in anuncioContenidoParaModificar)
{
AnunciosContenidos anuncioContenidoExistente = await anuncianteRepo.ModificarAnuncioContenido(anuncioContenido);
}
WrapperSimpleTypesDTO wrapperModificarMultiplesAnuncioContenido = new WrapperSimpleTypesDTO();
wrapperModificarMultiplesAnuncioContenido.NumeroRegistrosAfectados = await context.SaveChangesAsync();
if (wrapperModificarMultiplesAnuncioContenido.NumeroRegistrosAfectados > 0)
{
wrapperModificarMultiplesAnuncioContenido.Exitoso = true;
}
return(wrapperModificarMultiplesAnuncioContenido);
}
}
public void EliminarMultiplesContenidosAnuncios(AnunciosContenidos anuncioContenidoParaEliminar)
{
_context.AnunciosContenidos.RemoveRange(_context.AnunciosContenidos.Where(x => x.CodigoAnuncio == anuncioContenidoParaEliminar.CodigoAnuncio));
}
public void EliminarAnuncioContenido(AnunciosContenidos anuncioContenidoParaEliminar)
{
_context.AnunciosContenidos.Attach(anuncioContenidoParaEliminar);
_context.AnunciosContenidos.Remove(anuncioContenidoParaEliminar);
}
public async Task <List <AnunciosContenidos> > ListarAnunciosContenidosDeUnAnuncio(AnunciosContenidos anuncioContenidoParaListar)
{
List <AnunciosContenidos> listaContenidoDeUnAnuncio = await(from anuncioContenido in _context.AnunciosContenidos
where anuncioContenido.CodigoAnuncio == anuncioContenidoParaListar.CodigoAnuncio
select anuncioContenido).AsNoTracking()
.ToListAsync();
return(listaContenidoDeUnAnuncio);
}
public async Task <List <AnunciosContenidos> > ListarAnunciosContenidosDeUnAnuncio(AnunciosContenidos anuncioContenidoParaListar)
{
using (SportsGoEntities context = new SportsGoEntities(false))
{
AnunciantesRepository anuncianteRepo = new AnunciantesRepository(context);
List <AnunciosContenidos> listaContenidoDeUnAnuncio = await anuncianteRepo.ListarAnunciosContenidosDeUnAnuncio(anuncioContenidoParaListar);
return(listaContenidoDeUnAnuncio);
}
}
