コード例 #1
0
        public async Task <WrapperSimpleTypesDTO> AsignarCandidatoResponsable(CandidatosResponsables candidatoResponsableParaAsignar)
        {
            using (SportsGoEntities context = new SportsGoEntities(false))
            {
                CandidatosRepository candidatosRepo = new CandidatosRepository(context);

                Candidatos candidatoExistente = await candidatosRepo.BuscarCandidatoParaAsignar(candidatoResponsableParaAsignar);

                candidatoResponsableParaAsignar.Consecutivo = candidatoExistente.CodigoResponsable.HasValue ? candidatoExistente.CodigoResponsable.Value : 0;

                if (candidatoExistente.CodigoResponsable.HasValue)
                {
                    CandidatosResponsables candidatoResponsableExistente = await candidatosRepo.ModificarCandidatoResponsable(candidatoResponsableParaAsignar);
                }
                else
                {
                    candidatoExistente.CandidatosResponsables = candidatoResponsableParaAsignar;
                }

                WrapperSimpleTypesDTO wrapperCrearCandidatoResponsable = new WrapperSimpleTypesDTO();

                wrapperCrearCandidatoResponsable.NumeroRegistrosAfectados = await context.SaveChangesAsync();

                if (wrapperCrearCandidatoResponsable.NumeroRegistrosAfectados > 0)
                {
                    wrapperCrearCandidatoResponsable.Exitoso           = true;
                    wrapperCrearCandidatoResponsable.ConsecutivoCreado = candidatoExistente.CodigoResponsable.Value;
                }

                return(wrapperCrearCandidatoResponsable);
            }
        }
コード例 #2
0
        public async Task <PersonasDTO> BuscarPersona(Personas personaParaBuscar)
        {
            using (SportsGoEntities context = new SportsGoEntities(false))
            {
                PersonasRepository personaRepo    = new PersonasRepository(context);
                PersonasDTO        personaBuscada = await personaRepo.BuscarPersona(personaParaBuscar);

                if (personaBuscada.CandidatoDeLaPersona != null)
                {
                    if (personaBuscada.CandidatoDeLaPersona.CodigoResponsable.HasValue)
                    {
                        CandidatosRepository candidatoRepo = new CandidatosRepository(context);

                        CandidatosResponsables candidatoReponsable = new CandidatosResponsables
                        {
                            Consecutivo = personaBuscada.CandidatoDeLaPersona.CodigoResponsable.Value
                        };

                        personaBuscada.CandidatoDeLaPersona.CandidatosResponsables = await candidatoRepo.BuscarSoloCandidatoResponsableDTO(candidatoReponsable);
                    }
                }

                return(personaBuscada);
            }
        }
コード例 #3
0
        public async Task <WrapperSimpleTypesDTO> EliminarCandidatoResponsable(Candidatos candidatoResponsableParaBorrar)
        {
            using (SportsGoEntities context = new SportsGoEntities(false))
            {
                CandidatosRepository candidatosRepo     = new CandidatosRepository(context);
                Candidatos           candidatoExistente = await candidatosRepo.DesasignarResponsableDeUnCandidato(candidatoResponsableParaBorrar);

                CandidatosResponsables responsableABorrar = new CandidatosResponsables
                {
                    Consecutivo = candidatoResponsableParaBorrar.CodigoResponsable.Value
                };

                candidatosRepo.EliminarCandidatoResponsable(responsableABorrar);

                WrapperSimpleTypesDTO wrapperEliminarCandidatoResponsable = new WrapperSimpleTypesDTO();

                wrapperEliminarCandidatoResponsable.NumeroRegistrosAfectados = await context.SaveChangesAsync();

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

                return(wrapperEliminarCandidatoResponsable);
            }
        }
コード例 #4
0
        public async Task <CandidatosResponsables> BuscarCandidatoResponsable(CandidatosResponsables candidatoResponsableParaBuscar)
        {
            CandidatosResponsables candidatoResponsableBuscado = await(from candidatoResponsable in _context.CandidatosResponsables
                                                                       where candidatoResponsable.Consecutivo == candidatoResponsableParaBuscar.Consecutivo
                                                                       select candidatoResponsable).Include(x => x.Candidatos)
                                                                 .AsNoTracking()
                                                                 .FirstOrDefaultAsync();

            return(candidatoResponsableBuscado);
        }
コード例 #5
0
        public async Task <CandidatosResponsables> BuscarCandidatoResponsable(CandidatosResponsables candidatoResponsableParaBuscar)
        {
            using (SportsGoEntities context = new SportsGoEntities(false))
            {
                CandidatosRepository   candidatosRepo = new CandidatosRepository(context);
                CandidatosResponsables candidatoResponsableBuscado = await candidatosRepo.BuscarCandidatoResponsable(candidatoResponsableParaBuscar);

                return(candidatoResponsableBuscado);
            }
        }
コード例 #6
0
        public void CrearCandidatoResponsable(CandidatosResponsables candidatoResponsableParaCrear)
        {
            candidatoResponsableParaCrear.TelefonoMovil = candidatoResponsableParaCrear.TelefonoMovil.Trim();
            candidatoResponsableParaCrear.TelefonoFijo  = !string.IsNullOrWhiteSpace(candidatoResponsableParaCrear.TelefonoFijo) ? candidatoResponsableParaCrear.TelefonoFijo.Trim() : string.Empty;
            candidatoResponsableParaCrear.Skype         = !string.IsNullOrWhiteSpace(candidatoResponsableParaCrear.Skype) ? candidatoResponsableParaCrear.Skype.Trim() : string.Empty;
            candidatoResponsableParaCrear.Email         = candidatoResponsableParaCrear.Email.Trim();
            candidatoResponsableParaCrear.Nombres       = candidatoResponsableParaCrear.Nombres.Trim();
            candidatoResponsableParaCrear.Apellidos     = !string.IsNullOrWhiteSpace(candidatoResponsableParaCrear.Apellidos) ? candidatoResponsableParaCrear.Apellidos.Trim() : string.Empty;

            _context.CandidatosResponsables.Add(candidatoResponsableParaCrear);
        }
コード例 #7
0
        public async Task <CandidatosResponsables> ModificarCandidatoResponsable(CandidatosResponsables candidatoResponsableParaModificar)
        {
            CandidatosResponsables candidatoResponsableExistente = await _context.CandidatosResponsables.Where(x => x.Consecutivo == candidatoResponsableParaModificar.Consecutivo).FirstOrDefaultAsync();

            candidatoResponsableExistente.TelefonoMovil = candidatoResponsableParaModificar.TelefonoMovil.Trim();
            candidatoResponsableExistente.TelefonoFijo  = !string.IsNullOrWhiteSpace(candidatoResponsableParaModificar.TelefonoFijo) ? candidatoResponsableParaModificar.TelefonoFijo.Trim() : string.Empty;
            candidatoResponsableExistente.Skype         = !string.IsNullOrWhiteSpace(candidatoResponsableParaModificar.Skype) ? candidatoResponsableParaModificar.Skype.Trim() : string.Empty;
            candidatoResponsableExistente.Email         = candidatoResponsableParaModificar.Email.Trim();
            candidatoResponsableExistente.Nombres       = candidatoResponsableParaModificar.Nombres.Trim();
            candidatoResponsableExistente.Apellidos     = !string.IsNullOrWhiteSpace(candidatoResponsableParaModificar.Apellidos) ? candidatoResponsableParaModificar.Apellidos.Trim() : string.Empty;

            return(candidatoResponsableExistente);
        }
コード例 #8
0
        public async Task <IHttpActionResult> BuscarCandidatoResponsable(CandidatosResponsables candidatoResponsableParaBuscar)
        {
            if (candidatoResponsableParaBuscar == null || candidatoResponsableParaBuscar.Consecutivo <= 0)
            {
                return(BadRequest("candidatoResponsableParaBuscar vacio y/o invalido!."));
            }

            try
            {
                CandidatosResponsables candidatoResponsableBuscado = await _candidatosBusiness.BuscarCandidatoResponsable(candidatoResponsableParaBuscar);

                return(Ok(candidatoResponsableBuscado));
            }
            catch (Exception ex)
            {
                return(InternalServerError(ex));
            }
        }
コード例 #9
0
        public async Task <WrapperSimpleTypesDTO> ModificarCandidatoResponsable(CandidatosResponsables candidatoResponsableParaModificar)
        {
            using (SportsGoEntities context = new SportsGoEntities(false))
            {
                CandidatosRepository   candidatosRepo = new CandidatosRepository(context);
                CandidatosResponsables candidatoResponsableExistente = await candidatosRepo.ModificarCandidatoResponsable(candidatoResponsableParaModificar);

                WrapperSimpleTypesDTO wrapperModificarCandidatoResponsable = new WrapperSimpleTypesDTO();

                wrapperModificarCandidatoResponsable.NumeroRegistrosAfectados = await context.SaveChangesAsync();

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

                return(wrapperModificarCandidatoResponsable);
            }
        }
コード例 #10
0
        public async Task <IHttpActionResult> ModificarCandidatoResponsable(CandidatosResponsables candidatoResponsableParaModificar)
        {
            if (candidatoResponsableParaModificar == null || candidatoResponsableParaModificar.Consecutivo <= 0 || string.IsNullOrWhiteSpace(candidatoResponsableParaModificar.TelefonoMovil) ||
                string.IsNullOrWhiteSpace(candidatoResponsableParaModificar.Email) || string.IsNullOrWhiteSpace(candidatoResponsableParaModificar.Nombres))
            {
                return(BadRequest("candidatoResponsableParaModificar vacio y/o invalido!."));
            }

            try
            {
                WrapperSimpleTypesDTO wrapperModificarCandidatoResponsable = await _candidatosBusiness.ModificarCandidatoResponsable(candidatoResponsableParaModificar);

                return(Ok(wrapperModificarCandidatoResponsable));
            }
            catch (Exception ex)
            {
                return(InternalServerError(ex));
            }
        }
コード例 #11
0
        public async Task <WrapperSimpleTypesDTO> CrearCandidatoResponsable(CandidatosResponsables candidatoResponsableParaCrear)
        {
            using (SportsGoEntities context = new SportsGoEntities(false))
            {
                CandidatosRepository candidatosRepo = new CandidatosRepository(context);
                candidatosRepo.CrearCandidatoResponsable(candidatoResponsableParaCrear);

                WrapperSimpleTypesDTO wrapperCrearCandidatoResponsable = new WrapperSimpleTypesDTO();

                wrapperCrearCandidatoResponsable.NumeroRegistrosAfectados = await context.SaveChangesAsync();

                if (wrapperCrearCandidatoResponsable.NumeroRegistrosAfectados > 0)
                {
                    wrapperCrearCandidatoResponsable.Exitoso           = true;
                    wrapperCrearCandidatoResponsable.ConsecutivoCreado = candidatoResponsableParaCrear.Consecutivo;
                }

                return(wrapperCrearCandidatoResponsable);
            }
        }
コード例 #12
0
        public async Task CandidatosBusiness_AsignarCandidatoResponsable_ShouldAssign()
        {
            CandidatosBusiness candidatoBusiness = new CandidatosBusiness();

            CandidatosResponsables candidatoResponsable = new CandidatosResponsables
            {
                Consecutivo     = 0,
                CodigoCandidato = 5,
                Nombres         = "responsable",
                Apellidos       = "Apellido",
                Email           = "*****@*****.**",
                TelefonoFijo    = "131",
                TelefonoMovil   = "4141",
                Skype           = "miskype"
            };

            WrapperSimpleTypesDTO wrapperAsignarCandidatoResponsable = await candidatoBusiness.AsignarCandidatoResponsable(candidatoResponsable);

            Assert.IsTrue(wrapperAsignarCandidatoResponsable.Exitoso);
            Assert.AreNotEqual(wrapperAsignarCandidatoResponsable.NumeroRegistrosAfectados, 0);
        }
コード例 #13
0
 public void EliminarCandidatoResponsable(CandidatosResponsables candidatoResponsableParaBorrar)
 {
     _context.CandidatosResponsables.Attach(candidatoResponsableParaBorrar);
     _context.CandidatosResponsables.Remove(candidatoResponsableParaBorrar);
 }
コード例 #14
0
        public async Task <CandidatosResponsablesDTO> BuscarSoloCandidatoResponsableDTO(CandidatosResponsables candidatoResponsableParaBuscar)
        {
            CandidatosResponsablesDTO candidatoResponsableBuscado = await(from candidatoResponsable in _context.CandidatosResponsables
                                                                          where candidatoResponsable.Consecutivo == candidatoResponsableParaBuscar.Consecutivo
                                                                          select new CandidatosResponsablesDTO
            {
                Consecutivo   = candidatoResponsable.Consecutivo,
                Nombres       = candidatoResponsable.Nombres,
                Apellidos     = candidatoResponsable.Apellidos,
                TelefonoFijo  = candidatoResponsable.TelefonoFijo,
                TelefonoMovil = candidatoResponsable.TelefonoMovil,
                Email         = candidatoResponsable.Email,
                Skype         = candidatoResponsable.Skype
            })
                                                                    .AsNoTracking()
                                                                    .FirstOrDefaultAsync();

            return(candidatoResponsableBuscado);
        }
コード例 #15
0
        public async Task <Candidatos> BuscarCandidatoParaAsignar(CandidatosResponsables candidatoResponsableParaBuscar)
        {
            Candidatos candidatoExistente = await _context.Candidatos.Where(x => x.Consecutivo == candidatoResponsableParaBuscar.CodigoCandidato).Include(x => x.CandidatosResponsables).FirstOrDefaultAsync();

            return(candidatoExistente);
        }