Exemple #1
0
        public async Task <WrapperSimpleTypesDTO> ModificarHabilidad(Habilidades habilidadParaModificar)
        {
            using (SportsGoEntities context = new SportsGoEntities(false))
            {
                HabilidadesRepository habilidadesRepo = new HabilidadesRepository(context);

                habilidadParaModificar.CodigoTipoHabilidad = (int)habilidadParaModificar.TipoHabilidad;
                Habilidades habilidadExistente = await habilidadesRepo.ModificarHabilidad(habilidadParaModificar);

                if (habilidadParaModificar.HabilidadesContenidos != null && habilidadParaModificar.HabilidadesContenidos.Count > 0)
                {
                    foreach (var item in habilidadParaModificar.HabilidadesContenidos)
                    {
                        await habilidadesRepo.ModificarHabilidadContenido(item);
                    }
                }

                WrapperSimpleTypesDTO wrapperModificarHabilidad = new WrapperSimpleTypesDTO();

                wrapperModificarHabilidad.NumeroRegistrosAfectados = await context.SaveChangesAsync();

                if (wrapperModificarHabilidad.NumeroRegistrosAfectados > 0)
                {
                    wrapperModificarHabilidad.Exitoso = true;
                }

                return(wrapperModificarHabilidad);
            }
        }
Exemple #2
0
        public async Task <WrapperSimpleTypesDTO> EliminarHabilidad(Habilidades habilidadParaEliminar)
        {
            using (SportsGoEntities context = new SportsGoEntities(false))
            {
                HabilidadesRepository habilidadesRepo = new HabilidadesRepository(context);
                HabilidadesContenidos habilidadContenidosParaBorrar = new HabilidadesContenidos
                {
                    CodigoHabilidad = habilidadParaEliminar.Consecutivo
                };

                habilidadesRepo.EliminarMultiplesHabilidadesContenidosPorCodigoHabilidad(habilidadContenidosParaBorrar);
                habilidadesRepo.EliminarHabilidad(habilidadParaEliminar);

                WrapperSimpleTypesDTO wrapperEliminarHabilidad = new WrapperSimpleTypesDTO();

                wrapperEliminarHabilidad.NumeroRegistrosAfectados = await context.SaveChangesAsync();

                if (wrapperEliminarHabilidad.NumeroRegistrosAfectados > 0)
                {
                    wrapperEliminarHabilidad.Exitoso = true;
                }

                return(wrapperEliminarHabilidad);
            }
        }
Exemple #3
0
        public async Task <WrapperSimpleTypesDTO> CrearHabilidadesCandidato(List <HabilidadesCandidatos> habilidadCandidatoParaCrear)
        {
            using (SportsGoEntities context = new SportsGoEntities(false))
            {
                HabilidadesRepository habilidadesRepo = new HabilidadesRepository(context);

                // Elimina todas las habilidades para recrearlas luega
                habilidadesRepo.EliminarMultiplesHabilidadesCandidatosPorCodigoCandidato(habilidadCandidatoParaCrear[0]);

                // Evitar que si se le manda una instancia la vuelva a crear
                habilidadCandidatoParaCrear.ForEach(x => x.Habilidades = null);

                habilidadesRepo.CrearHabilidadesCandidato(habilidadCandidatoParaCrear);

                WrapperSimpleTypesDTO wrapperCrearHabilidadesCandidato = new WrapperSimpleTypesDTO();

                wrapperCrearHabilidadesCandidato.NumeroRegistrosAfectados = await context.SaveChangesAsync();

                if (wrapperCrearHabilidadesCandidato.NumeroRegistrosAfectados > 0)
                {
                    wrapperCrearHabilidadesCandidato.Exitoso = true;
                }

                return(wrapperCrearHabilidadesCandidato);
            }
        }
Exemple #4
0
        public async Task <List <HabilidadesDTO> > ListarHabilidadesPorCodigoCategoriaAndIdioma(Habilidades habilidadParaListar)
        {
            using (SportsGoEntities context = new SportsGoEntities(false))
            {
                HabilidadesRepository habilidadesRepo = new HabilidadesRepository(context);
                List <HabilidadesDTO> listaHabilidadesPorCategoria = await habilidadesRepo.ListarHabilidadesPorCodigoCategoriaAndIdioma(habilidadParaListar);

                return(listaHabilidadesPorCategoria);
            }
        }
Exemple #5
0
        public async Task <Habilidades> BuscarHabilidad(Habilidades habilidadParaBuscar)
        {
            using (SportsGoEntities context = new SportsGoEntities(false))
            {
                HabilidadesRepository habilidadesRepo  = new HabilidadesRepository(context);
                Habilidades           habilidadBuscada = await habilidadesRepo.BuscarHabilidad(habilidadParaBuscar);

                return(habilidadBuscada);
            }
        }
Exemple #6
0
        public async Task <List <HabilidadesContenidos> > ListarContenidoDeUnaHabilidad(HabilidadesContenidos habilidadContenidoParaListar)
        {
            using (SportsGoEntities context = new SportsGoEntities(false))
            {
                HabilidadesRepository        habilidadesRepo            = new HabilidadesRepository(context);
                List <HabilidadesContenidos> listaHabilidadesContenidos = await habilidadesRepo.ListarContenidoDeUnaHabilidad(habilidadContenidoParaListar);

                return(listaHabilidadesContenidos);
            }
        }
Exemple #7
0
        public async Task <List <HabilidadesCandidatosDTO> > ListarHabilidadesCandidatoPorCategoriaCandidatoAndIdioma(HabilidadesCandidatos habilidadCandidatoParaListar)
        {
            using (SportsGoEntities context = new SportsGoEntities(false))
            {
                HabilidadesRepository           habilidadesRepo           = new HabilidadesRepository(context);
                List <HabilidadesCandidatosDTO> listaHabilidadesCandidato = await habilidadesRepo.ListarHabilidadesCandidatoPorCategoriaCandidatoAndIdioma(habilidadCandidatoParaListar);

                return(listaHabilidadesCandidato);
            }
        }
Exemple #8
0
        public async Task <HabilidadesCandidatosDTO> BuscarHabilidadCandidatoPorIdioma(HabilidadesCandidatos habilidadCandidatoParaBuscar)
        {
            using (SportsGoEntities context = new SportsGoEntities(false))
            {
                HabilidadesRepository    habilidadesRepo           = new HabilidadesRepository(context);
                HabilidadesCandidatosDTO habilidadCandidatoBuscada = await habilidadesRepo.BuscarHabilidadCandidatoPorIdioma(habilidadCandidatoParaBuscar);

                return(habilidadCandidatoBuscada);
            }
        }
        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);
            }
        }
Exemple #10
0
        public async Task CandidatoRepository_ListarHabilidadesPorIdioma_ShouldList()
        {
            using (SportsGoEntities context = new SportsGoEntities(false))
            {
                HabilidadesRepository habilidadesRepo = new HabilidadesRepository(context);
                Habilidades           habilidad       = new Habilidades
                {
                    IdiomaBase = Idioma.Español
                };

                List <HabilidadesDTO> informacionCandidato = await habilidadesRepo.ListarHabilidadesPorIdioma(habilidad);

                Assert.IsNotNull(informacionCandidato);
            }
        }
        public async Task <WrapperSimpleTypesDTO> EliminarCategoriaCandidato(CategoriasCandidatos categoriaCandidatoParaBorrar)
        {
            using (SportsGoEntities context = new SportsGoEntities(false))
            {
                HabilidadesRepository habilidadesRepo     = new HabilidadesRepository(context);
                HabilidadesCandidatos habilidadParaBorrar = new HabilidadesCandidatos
                {
                    CodigoCategoriaCandidato = categoriaCandidatoParaBorrar.Consecutivo
                };
                habilidadesRepo.EliminarMultiplesHabilidadesCandidatosPorCodigoCandidato(habilidadParaBorrar);

                CategoriasRepository categoriasRepo = new CategoriasRepository(context);
                int?codigoCandidato = await categoriasRepo.BuscarCodigoCandidatoDeUnaCategoriaCandidato(categoriaCandidatoParaBorrar.Consecutivo);

                if (!codigoCandidato.HasValue)
                {
                    throw new InvalidOperationException("No se pudo hallar el codigo del candidato para borrar la categoria y modificar el plan!.");
                }

                categoriasRepo.EliminarCategoriaCandidato(categoriaCandidatoParaBorrar);

                PlanesRepository planRepo = new PlanesRepository(context);
                int?codigoPlanExistente   = await planRepo.BuscarCodigoPlanUsuarioPorCodigoCandidato(codigoCandidato.Value);

                if (!codigoPlanExistente.HasValue)
                {
                    throw new InvalidOperationException("No se pudo hallar el plan del candidato para crear la categoria para el!.");
                }

                // Se "BAJA" el contador de categorias 1
                PlanesUsuarios planUsuarioExistente = await planRepo.ModificarNumeroCategoriasUsadas(codigoPlanExistente.Value, -1);

                WrapperSimpleTypesDTO wrapperEliminarCategoriaCandidato = new WrapperSimpleTypesDTO();

                wrapperEliminarCategoriaCandidato.NumeroRegistrosAfectados = await context.SaveChangesAsync();

                if (wrapperEliminarCategoriaCandidato.NumeroRegistrosAfectados > 0)
                {
                    wrapperEliminarCategoriaCandidato.Exitoso = true;
                }

                return(wrapperEliminarCategoriaCandidato);
            }
        }
Exemple #12
0
        public async Task <WrapperSimpleTypesDTO> EliminarHabilidadContenido(HabilidadesContenidos habilidadContenidoParaEliminar)
        {
            using (SportsGoEntities context = new SportsGoEntities(false))
            {
                HabilidadesRepository habilidadesRepo = new HabilidadesRepository(context);
                habilidadesRepo.EliminarHabilidadContenido(habilidadContenidoParaEliminar);

                WrapperSimpleTypesDTO wrapperEliminarHabilidadContenido = new WrapperSimpleTypesDTO();

                wrapperEliminarHabilidadContenido.NumeroRegistrosAfectados = await context.SaveChangesAsync();

                if (wrapperEliminarHabilidadContenido.NumeroRegistrosAfectados > 0)
                {
                    wrapperEliminarHabilidadContenido.Exitoso = true;
                }

                return(wrapperEliminarHabilidadContenido);
            }
        }
Exemple #13
0
        public async Task <WrapperSimpleTypesDTO> CrearHabilidadesContenidosIndividual(HabilidadesContenidos habilidadesContenidosParaCrear)
        {
            using (SportsGoEntities context = new SportsGoEntities(false))
            {
                HabilidadesRepository habilidadesRepo = new HabilidadesRepository(context);
                habilidadesRepo.CrearHabilidadesContenidosIndividual(habilidadesContenidosParaCrear);

                WrapperSimpleTypesDTO wrapperCrearHabilidadesContenidosIndividual = new WrapperSimpleTypesDTO();

                wrapperCrearHabilidadesContenidosIndividual.NumeroRegistrosAfectados = await context.SaveChangesAsync();

                if (wrapperCrearHabilidadesContenidosIndividual.NumeroRegistrosAfectados > 0)
                {
                    wrapperCrearHabilidadesContenidosIndividual.Exitoso = true;
                }

                return(wrapperCrearHabilidadesContenidosIndividual);
            }
        }
Exemple #14
0
        public async Task <WrapperSimpleTypesDTO> CrearHabilidad(Habilidades habilidadParaCrear)
        {
            using (SportsGoEntities context = new SportsGoEntities(false))
            {
                HabilidadesRepository habilidadesRepo = new HabilidadesRepository(context);

                habilidadesRepo.CrearHabilidad(habilidadParaCrear);

                WrapperSimpleTypesDTO wrapperCrearHabilidad = new WrapperSimpleTypesDTO();

                wrapperCrearHabilidad.NumeroRegistrosAfectados = await context.SaveChangesAsync();

                if (wrapperCrearHabilidad.NumeroRegistrosAfectados > 0)
                {
                    wrapperCrearHabilidad.Exitoso           = true;
                    wrapperCrearHabilidad.ConsecutivoCreado = habilidadParaCrear.Consecutivo;
                }

                return(wrapperCrearHabilidad);
            }
        }
        public async Task <WrapperSimpleTypesDTO> ModificarCategoriaCandidato(CategoriasCandidatos categoriaCandidatoParaModificar)
        {
            using (SportsGoEntities context = new SportsGoEntities(false))
            {
                CategoriasRepository categoriasRepo = new CategoriasRepository(context);
                CategoriasCandidatos categoriaCandidatoExistente = await categoriasRepo.ModificarCategoriaCandidato(categoriaCandidatoParaModificar);

                HabilidadesRepository habilidadesRepo     = new HabilidadesRepository(context);
                HabilidadesCandidatos habilidadParaBorrar = new HabilidadesCandidatos
                {
                    CodigoCategoriaCandidato = categoriaCandidatoParaModificar.Consecutivo
                };
                habilidadesRepo.EliminarMultiplesHabilidadesCandidatosPorCodigoCandidato(habilidadParaBorrar);

                if (categoriaCandidatoParaModificar.HabilidadesCandidatos != null && categoriaCandidatoParaModificar.HabilidadesCandidatos.Count > 0)
                {
                    categoriaCandidatoParaModificar.HabilidadesCandidatos = categoriaCandidatoParaModificar.HabilidadesCandidatos.Where(x => x.NumeroEstrellas > 0).ToList();
                }

                categoriaCandidatoParaModificar.HabilidadesCandidatos.ForEach(x =>
                {
                    x.CodigoCategoriaCandidato = categoriaCandidatoParaModificar.Consecutivo;
                    x.Habilidades = null;
                });
                habilidadesRepo.CrearHabilidadesCandidato(categoriaCandidatoParaModificar.HabilidadesCandidatos);

                WrapperSimpleTypesDTO wrapperModificarCategoriaCandidato = new WrapperSimpleTypesDTO();

                wrapperModificarCategoriaCandidato.NumeroRegistrosAfectados = await context.SaveChangesAsync();

                if (wrapperModificarCategoriaCandidato.NumeroRegistrosAfectados > 0)
                {
                    wrapperModificarCategoriaCandidato.Exitoso = true;
                }

                return(wrapperModificarCategoriaCandidato);
            }
        }