コード例 #1
0
        public async Task <WrapperSimpleTypesDTO> AsignarImagenPerfilPersona(int codigoPersona, 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;

                        PersonasRepository personaRepo = new PersonasRepository(context);
                        // Meto el consecutivo del archivo generado por el EF por la creacion
                        Personas persona = new Personas
                        {
                            Consecutivo = codigoPersona,
                            CodigoArchivoImagenPerfil = archivoParaCrear.Consecutivo
                        };

                        Personas personaExistente = await personaRepo.AsignarCodigoImagenPerfil(persona);

                        // 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);
                }
        }
コード例 #2
0
        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);
            }
        }
コード例 #3
0
        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);
            }
        }
コード例 #4
0
 public async Task StreamArchivoFull(Archivos archivoParaBuscar, Stream outputStream)
 {
     using (SportsGoEntities context = new SportsGoEntities(false))
         using (DbContextTransaction transaction = context.Database.BeginTransaction())
         {
             ArchivosRepository archivoRepo = new ArchivosRepository(context);
             using (Stream source = await archivoRepo.StreamArchivo(archivoParaBuscar))
             {
                 await source.CopyToAsync(outputStream);
             }
         }
 }
コード例 #5
0
        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);
            }
        }
コード例 #6
0
        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);
            }
        }
コード例 #7
0
        public async Task StreamArchivoRange(Archivos archivoParaBuscar, Stream outputStream, long start, long end)
        {
            using (SportsGoEntities context = new SportsGoEntities(false))
                using (DbContextTransaction transaction = context.Database.BeginTransaction())
                {
                    ArchivosRepository archivoRepo = new ArchivosRepository(context);

                    using (Stream source = await archivoRepo.StreamArchivo(archivoParaBuscar))
                    {
                        MediaStreamHelper.CreatePartialContent(source, outputStream, start, end);
                    }
                }
        }
コード例 #8
0
        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);
            }
        }
コード例 #9
0
        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);
            }
        }
コード例 #10
0
        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);
            }
        }