public async Task <List <AnunciosDTO> > ListarAnunciosDeUnAnunciante(Anuncios anuncioParaListar)
{
using (SportsGoEntities context = new SportsGoEntities(false))
{
AnunciantesRepository anuncianteRepo = new AnunciantesRepository(context);
List <AnunciosDTO> listarInformacionAnuncios = await anuncianteRepo.ListarAnunciosDeUnAnunciante(anuncioParaListar);
if (listarInformacionAnuncios != null && listarInformacionAnuncios.Count > 0)
{
DateTimeHelperNoPortable helper = new DateTimeHelperNoPortable();
foreach (var anuncios in listarInformacionAnuncios)
{
anuncios.Creacion = helper.ConvertDateTimeFromAnotherTimeZone(anuncioParaListar.ZonaHorariaGMTBase, helper.DifferenceBetweenGMTAndLocalTimeZone, anuncios.Creacion);
anuncios.FechaInicio = helper.ConvertDateTimeFromAnotherTimeZone(anuncioParaListar.ZonaHorariaGMTBase, helper.DifferenceBetweenGMTAndLocalTimeZone, anuncios.FechaInicio);
if (anuncios.Vencimiento.HasValue)
{
anuncios.Vencimiento = helper.ConvertDateTimeFromAnotherTimeZone(anuncioParaListar.ZonaHorariaGMTBase, helper.DifferenceBetweenGMTAndLocalTimeZone, anuncios.Vencimiento.Value);
}
}
}
return(listarInformacionAnuncios);
}
}
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 <List <AnunciosDTO> > ListarAnunciosDeUnAnunciante(Anuncios anuncioParaListar)
{
IQueryable <Anuncios> queryAnuncios = _context.Anuncios.Where(x => x.CodigoAnunciante == anuncioParaListar.CodigoAnunciante).AsQueryable();
int queryContador = await queryAnuncios.CountAsync();
List <AnunciosDTO> listaAnuncios = await queryAnuncios
.Select(x => new AnunciosDTO
{
Consecutivo = x.Consecutivo,
Creacion = x.Creacion,
Vencimiento = x.Vencimiento,
NumeroApariciones = x.NumeroApariciones,
NumeroVecesClickeados = x.NumeroVecesClickeados,
NumeroVecesVistos = x.NumeroVecesVistos,
UltimaVezVisto = x.UltimaVezVisto,
CodigoArchivo = x.CodigoArchivo,
UrlPublicidad = x.UrlPublicidad,
CodigoTipoArchivo = x.Archivos.CodigoTipoArchivo,
NumeroRegistrosExistentes = queryContador,
CodigoTipoAnuncio = x.CodigoTipoAnuncio,
FechaInicio = x.FechaInicio,
TituloIdiomaBuscado = x.AnunciosContenidos.Where(y => y.CodigoIdioma == anuncioParaListar.CodigoIdiomaUsuarioBase).Select(y => y.Titulo).FirstOrDefault(),
DescripcionIdiomaBuscado = x.AnunciosContenidos.Where(y => y.CodigoIdioma == anuncioParaListar.CodigoIdiomaUsuarioBase).Select(y => y.Descripcion).FirstOrDefault(),
AnunciosContenidos = x.AnunciosContenidos
.Select(z => new AnunciosContenidosDTO
{
Consecutivo = z.Consecutivo,
CodigoAnuncio = z.CodigoAnuncio,
Titulo = z.Titulo,
Descripcion = z.Descripcion,
CodigoIdioma = z.CodigoIdioma,
}).ToList(),
AnunciosPaises = x.AnunciosPaises.Select(y =>
new AnunciosPaisesDTO
{
Consecutivo = y.Consecutivo,
CodigoPais = y.CodigoPais,
CodigoAnuncio = y.CodigoAnuncio,
DescripcionIdiomaBuscado = y.Paises.PaisesContenidos.Where(z => z.CodigoIdioma == anuncioParaListar.CodigoIdiomaUsuarioBase).Select(z => z.Descripcion).FirstOrDefault()
})
.ToList(),
CategoriasAnuncios = x.CategoriasAnuncios.Select(y =>
new CategoriasAnunciosDTO
{
Consecutivo = y.Consecutivo,
CodigoAnuncio = y.CodigoAnuncio,
CodigoCategoria = y.CodigoCategoria,
DescripcionIdiomaBuscado = y.Categorias.CategoriasContenidos.Where(z => z.CodigoIdioma == anuncioParaListar.CodigoIdiomaUsuarioBase).Select(z => z.Descripcion).FirstOrDefault()
})
.ToList()
})
.OrderByDescending(x => x.Creacion)
.Skip(() => anuncioParaListar.SkipIndexBase)
.Take(() => anuncioParaListar.TakeIndexBase)
.AsNoTracking()
.ToListAsync();
return(listaAnuncios);
}
public void CrearAnuncio(Anuncios anuncioParaCrear)
{
anuncioParaCrear.UrlPublicidad = !string.IsNullOrWhiteSpace(anuncioParaCrear.UrlPublicidad) ? anuncioParaCrear.UrlPublicidad.Trim() : string.Empty;
anuncioParaCrear.Creacion = DateTime.Now;
_context.Anuncios.Add(anuncioParaCrear);
}
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);
}
}
async Task ExecuteLoadItemsCommand()
{
if (IsBusy)
{
return;
}
IsBusy = true;
try
{
Anuncios.Clear();
var items = await DataStore.GetItemsAsync(true);
foreach (var item in items)
{
Anuncios.Add(item);
}
}
catch (Exception ex)
{
Debug.WriteLine(ex);
}
finally
{
IsBusy = false;
}
}
public async Task <int?> BuscarArchivoDeUnAnuncio(Anuncios anuncioParaBuscar)
{
int?anuncioBuscado = await(from anuncio in _context.Anuncios
where anuncio.Consecutivo == anuncioParaBuscar.Consecutivo
select anuncio.CodigoArchivo).FirstOrDefaultAsync();
return(anuncioBuscado);
}
public async Task <Anuncios> DesasignarArchivoAnuncio(Anuncios anuncioArchivoParaEliminar)
{
Anuncios anuncioExistente = await _context.Anuncios.Where(x => x.Consecutivo == anuncioArchivoParaEliminar.Consecutivo).FirstOrDefaultAsync();
anuncioExistente.CodigoArchivo = null;
return(anuncioExistente);
}
public ActionResult DeleteConfirmed(int id)
{
Anuncios anuncios = db.Anuncios.Find(id);
db.Anuncios.Remove(anuncios);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public async Task <Anuncios> AumentarContadorClickDeUnAnuncio(Anuncios anuncioParaAumentar)
{
Anuncios anuncioExistente = await _context.Anuncios.Where(x => x.Consecutivo == anuncioParaAumentar.Consecutivo).FirstOrDefaultAsync();
anuncioExistente.NumeroVecesClickeados = anuncioExistente.NumeroVecesClickeados.HasValue ? anuncioExistente.NumeroVecesClickeados + 1 : 1;
return(anuncioExistente);
}
public async Task <WrapperSimpleTypesDTO> ModificarArchivoAnuncio(int codigoTipoArchivo, int codigoAnuncio, 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;
AnunciantesRepository anuncioRepo = new AnunciantesRepository(context);
// Meto el consecutivo del archivo generado por el EF por la creacion
Anuncios anuncio = new Anuncios
{
Consecutivo = codigoAnuncio,
CodigoArchivo = archivoParaCrear.Consecutivo
};
Anuncios anuncioExistente = await anuncioRepo.ModificarCodigoArchivoAnuncio(anuncio);
// Elimino el viejo archivo
if (codigoArchivo.HasValue && codigoArchivo > 0)
{
Archivos archivoParaBorrar = new Archivos
{
Consecutivo = codigoArchivo.Value
};
archivoRepo.EliminarArchivo(archivoParaBorrar);
}
wrapper.NumeroRegistrosAfectados += await context.SaveChangesAsync();
transaction.Commit();
}
return(wrapper);
}
}
public ActionResult Edit([Bind(Include = "anuncioId,nomeAnuncio,nomeCliente,dataInicial,dataFinal,investimento")] Anuncios anuncios)
{
if (ModelState.IsValid)
{
db.Entry(anuncios).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(anuncios));
}
public async Task <Anuncios> ModificarCodigoArchivoAnuncio(Anuncios anuncioParaModificar)
{
Anuncios anuncioExistente = await(from anuncio in _context.Anuncios
where anuncio.Consecutivo == anuncioParaModificar.Consecutivo
select anuncio).FirstOrDefaultAsync();
anuncioExistente.CodigoArchivo = anuncioParaModificar.CodigoArchivo;
return(anuncioExistente);
}
public async Task <Anuncios> ModificarAnuncio(Anuncios anuncioParaModificar)
{
Anuncios anuncioExistente = await _context.Anuncios.Where(x => x.Consecutivo == anuncioParaModificar.Consecutivo).FirstOrDefaultAsync();
anuncioExistente.FechaInicio = anuncioParaModificar.FechaInicio;
anuncioExistente.UrlPublicidad = !string.IsNullOrWhiteSpace(anuncioParaModificar.UrlPublicidad) ? anuncioParaModificar.UrlPublicidad.Trim() : string.Empty;
anuncioExistente.CodigoTipoAnuncio = anuncioParaModificar.CodigoTipoAnuncio;
return(anuncioExistente);
}
public ActionResult Create([Bind(Include = "anuncioId,nomeAnuncio,nomeCliente,dataInicial,dataFinal,investimento")] Anuncios anuncios)
{
if (ModelState.IsValid)
{
db.Anuncios.Add(anuncios);
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(anuncios));
}
// GET: RedirectAnuncio
public void Index(int id, string link)
{
Anuncios anuncios = new Anuncios();
anuncios.TouchAnuncio(id);
if (!link.Contains("http://") || !link.Contains("https://"))
{
link = "http://" + link;
}
Response.Redirect(link, true);
}
public async Task AnunciantesBusiness_EliminarAnuncio_ShouldEliminate()
{
AnunciantesBusiness anuncianteBusiness = new AnunciantesBusiness();
Anuncios anuncios = new Anuncios
{
Consecutivo = 4,
};
await anuncianteBusiness.EliminarAnuncio(anuncios);
}
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 AnuncianteBusiness_EliminarAnuncio_ShouldDelete()
{
AnunciantesBusiness anuncianteBusiness = new AnunciantesBusiness();
Anuncios anuncioParaBorrar = new Anuncios
{
Consecutivo = 3
};
WrapperSimpleTypesDTO wrapper = await anuncianteBusiness.EliminarAnuncio(anuncioParaBorrar);
Assert.IsNotNull(wrapper);
Assert.IsTrue(wrapper.Exitoso);
}
// GET: Anuncios/Delete/5
public ActionResult Delete(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Anuncios anuncios = db.Anuncios.Find(id);
if (anuncios == null)
{
return(HttpNotFound());
}
return(View(anuncios));
}
public async Task <IHttpActionResult> AumentarContadorClickDeUnAnuncio(Anuncios anuncioParaAumentar)
{
if (anuncioParaAumentar == null || anuncioParaAumentar.Consecutivo <= 0)
{
return(BadRequest("anuncioParaAumentar vacio y/o invalido!."));
}
try
{
WrapperSimpleTypesDTO wrapperAumentarContadorClickDeUnAnuncio = await _anuncianteBusiness.AumentarContadorClickDeUnAnuncio(anuncioParaAumentar);
return(Ok(wrapperAumentarContadorClickDeUnAnuncio));
}
catch (Exception ex)
{
return(InternalServerError(ex));
}
}
public async Task <IHttpActionResult> EliminarArchivoAnuncio(Anuncios anuncioArchivoParaEliminar)
{
if (anuncioArchivoParaEliminar == null || anuncioArchivoParaEliminar.Consecutivo <= 0 || anuncioArchivoParaEliminar.CodigoArchivo <= 0)
{
return(BadRequest("anuncioArchivoParaEliminar vacio y/o invalido!."));
}
try
{
WrapperSimpleTypesDTO wrapperEliminarArchivoAnuncio = await _anuncianteBusiness.EliminarArchivoAnuncio(anuncioArchivoParaEliminar);
return(Ok(wrapperEliminarArchivoAnuncio));
}
catch (Exception ex)
{
return(InternalServerError(ex));
}
}
public async Task <IHttpActionResult> ModificarAnuncio(Anuncios anuncioParaModificar)
{
if (anuncioParaModificar == null || anuncioParaModificar.Consecutivo <= 0 || anuncioParaModificar.FechaInicio == DateTime.MinValue)
{
return(BadRequest("anuncioParaModificar vacio y/o invalido!."));
}
try
{
WrapperSimpleTypesDTO wrapperModificarAnuncio = await _anuncianteBusiness.ModificarAnuncio(anuncioParaModificar);
return(Ok(wrapperModificarAnuncio));
}
catch (Exception ex)
{
return(InternalServerError(ex));
}
}
public async Task <IHttpActionResult> BuscarAnuncioPorConsecutivo(Anuncios anuncioParaBuscar)
{
if (anuncioParaBuscar == null || anuncioParaBuscar.Consecutivo <= 0)
{
return(BadRequest("anuncioParaBuscar vacio y/o invalido!."));
}
try
{
Anuncios anuncioBuscado = await _anuncianteBusiness.BuscarAnuncioPorConsecutivo(anuncioParaBuscar);
return(Ok(anuncioBuscado));
}
catch (Exception ex)
{
return(InternalServerError(ex));
}
}
public void PublicarComunicado(string _descripcion, string _estado)
{
try
{
ORMicbfDataDataContext db = new ORMicbfDataDataContext();
Anuncios objanuncio = new Anuncios();
objanuncio.Descripcion = _descripcion;
objanuncio.fechaAnuncio = DateTime.Now;
objanuncio.estado = _estado;
db.Anuncios.InsertOnSubmit(objanuncio);
db.SubmitChanges();
MessageBox.Show("El comunicado se Publico con exito");
}
catch (Exception e)
{
MessageBox.Show("Error" + e.Message);
}
}
public async Task <IHttpActionResult> ListarAnunciosDeUnAnunciante(Anuncios anuncioParaListar)
{
if (anuncioParaListar == null || anuncioParaListar.SkipIndexBase < 0 || anuncioParaListar.TakeIndexBase <= 0 || anuncioParaListar.CodigoAnunciante <= 0 || anuncioParaListar.IdiomaBase == Idioma.SinIdioma)
{
return(BadRequest("anuncioParaListar vacio y/o invalido!."));
}
try
{
List <AnunciosDTO> listarInformacionAnuncios = await _anuncianteBusiness.ListarAnunciosDeUnAnunciante(anuncioParaListar);
return(Ok(listarInformacionAnuncios));
}
catch (Exception ex)
{
return(InternalServerError(ex));
}
}
public async Task <WrapperSimpleTypesDTO> AumentarContadorClickDeUnAnuncio(Anuncios anuncioParaAumentar)
{
using (SportsGoEntities context = new SportsGoEntities(false))
{
AnunciantesRepository anuncianteRepo = new AnunciantesRepository(context);
Anuncios anuncioExistente = await anuncianteRepo.AumentarContadorClickDeUnAnuncio(anuncioParaAumentar);
WrapperSimpleTypesDTO wrapperAumentarContadorClickDeUnAnuncio = new WrapperSimpleTypesDTO();
wrapperAumentarContadorClickDeUnAnuncio.NumeroRegistrosAfectados += await context.SaveChangesAsync();
if (wrapperAumentarContadorClickDeUnAnuncio.NumeroRegistrosAfectados > 0)
{
wrapperAumentarContadorClickDeUnAnuncio.Exitoso = true;
}
return(wrapperAumentarContadorClickDeUnAnuncio);
}
}
public async Task AnunciantesBusiness_CrearAnuncios_ShouldCreate()
{
AnunciantesBusiness anuncianteBusiness = new AnunciantesBusiness();
Anuncios anuncio = new Anuncios
{
CodigoAnunciante = 1,
FechaInicio = DateTime.Now,
Vencimiento = new DateTime(2017, 09, 15),
CodigoTipoAnuncio = 1,
UrlPublicidad = "https://www.twitch.tv/directory/game/League%20of%20Legends",
AnunciosContenidos = new List <AnunciosContenidos>
{
new AnunciosContenidos {
Titulo = "Prueba de un anuncio para League of Legends :D", Descripcion = "La descripcion de una prueba de un anuncio que quizas funcione o quizas no", CodigoIdioma = 1
},
new AnunciosContenidos {
Titulo = "Test for a advertising for League of Legends :D", Descripcion = "The description of an advertising test that could work or dont", CodigoIdioma = 2
}
},
AnunciosPaises = new List <AnunciosPaises>
{
new AnunciosPaises {
CodigoPais = 1
},
new AnunciosPaises {
CodigoPais = 2
},
new AnunciosPaises {
CodigoPais = 3
},
new AnunciosPaises {
CodigoPais = 9
}
}
};
WrapperSimpleTypesDTO wrapper = await anuncianteBusiness.CrearAnuncio(anuncio);
Assert.IsNotNull(wrapper);
}
public async Task <Anuncios> BuscarAnuncioPorConsecutivo(Anuncios anuncioParaBuscar)
{
Anuncios anuncioBuscado = await(from anuncio in _context.Anuncios
where anuncio.Consecutivo == anuncioParaBuscar.Consecutivo
select anuncio).Include(x => x.Anunciantes)
.Include(x => x.AnunciosContenidos)
.Include(x => x.AnunciosPaises)
.Include(x => x.CategoriasAnuncios)
.Include(x => x.TipoPublicacion)
.AsNoTracking()
.FirstOrDefaultAsync();
if (anuncioBuscado.CodigoArchivo.HasValue)
{
anuncioBuscado.CodigoTipoArchivo = await _context.Archivos.Where(x => x.Consecutivo == anuncioBuscado.CodigoArchivo)
.Select(x => x.CodigoTipoArchivo)
.FirstOrDefaultAsync();
}
return(anuncioBuscado);
}
