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); }