public async Task <WrapperSimpleTypesDTO> CrearCandidato(CandidatosDTO candidatoParaCrear)
        {
            if (candidatoParaCrear == null || candidatoParaCrear.Personas == null || candidatoParaCrear.Personas.Usuarios == null || candidatoParaCrear.CategoriasCandidatos == null)
            {
                throw new ArgumentNullException("No puedes crear un candidato si candidatoParaCrear o la persona del candidato es nulo!.");
            }
            if (candidatoParaCrear.CodigoGenero <= 0 ||
                candidatoParaCrear.Estatura <= 0 || candidatoParaCrear.Peso <= 0 || candidatoParaCrear.FechaNacimiento == DateTime.MinValue)
            {
                throw new ArgumentException("candidatoParaCrear vacia y/o invalida!.");
            }
            else if (string.IsNullOrWhiteSpace(candidatoParaCrear.Personas.Nombres) || string.IsNullOrWhiteSpace(candidatoParaCrear.Personas.Apellidos) || candidatoParaCrear.Personas.CodigoPais <= 0 ||
                     candidatoParaCrear.Personas.TipoPerfil == TipoPerfil.SinTipoPerfil || candidatoParaCrear.Personas.CodigoIdioma <= 0 || string.IsNullOrWhiteSpace(candidatoParaCrear.Personas.Telefono) || string.IsNullOrWhiteSpace(candidatoParaCrear.Personas.CiudadResidencia))
            {
                throw new ArgumentException("Persona de candidatoParaCrear vacio y/o invalido!.");
            }
            else if (string.IsNullOrWhiteSpace(candidatoParaCrear.Personas.Usuarios.Usuario) || string.IsNullOrWhiteSpace(candidatoParaCrear.Personas.Usuarios.Clave) ||
                     string.IsNullOrWhiteSpace(candidatoParaCrear.Personas.Usuarios.Email))
            {
                throw new ArgumentException("Usuario de candidatoParaCrear vacio y/o invalido!.");
            }
            else if (candidatoParaCrear.CategoriasCandidatos.Count <= 0 ||
                     !candidatoParaCrear.CategoriasCandidatos.All(x => x.CodigoCategoria > 0 && (x.HabilidadesCandidatos.Count > 0 && x.HabilidadesCandidatos.All(y => y.CodigoHabilidad > 0 && y.NumeroEstrellas >= 0 && y.NumeroEstrellas <= 5))))
            {
                throw new ArgumentException("Categorias o Habilidades de candidatoParaCrear vacio y/o invalido!.");
            }

            IHttpClient client = ConfigurarHttpClient();

            WrapperSimpleTypesDTO wrapperCrearCandidato = await client.PostAsync <CandidatosDTO, WrapperSimpleTypesDTO>("Candidatos/CrearCandidato", candidatoParaCrear);

            return(wrapperCrearCandidato);
        }
        public async Task CandidatosServices_BuscarCandidatoPorCodigoCandidato_ShouldSearch()
        {
            CandidatosServices candidatoService = new CandidatosServices();

            CandidatosDTO candidato = new CandidatosDTO
            {
                Consecutivo = 1
            };

            CandidatosDTO candidatoBuscado = await candidatoService.BuscarCandidatoPorCodigoCandidato(candidato);

            Assert.IsNotNull(candidatoBuscado);
        }
Beispiel #3
0
        public async Task <List <int> > ListarCodigoCategoriasDeUnCandidato(int codigoPersona)
        {
            CandidatosDTO candidato = await _context.Candidatos.Where(x => x.CodigoPersona == codigoPersona)
                                      .Select(x => new CandidatosDTO
            {
                CategoriasCandidatos = x.CategoriasCandidatos.Where(z => z.CodigoCandidato == x.Consecutivo)
                                       .Select(z => new CategoriasCandidatosDTO
                {
                    CodigoCategoria = z.CodigoCategoria,
                }).ToList(),
            })
                                      .FirstOrDefaultAsync();

            return(candidato.CategoriasCandidatos.Select(x => x.CodigoCategoria).ToList());
        }
Beispiel #4
0
        async Task <WrapperSimpleTypesDTO> CrearCandidato()
        {
            CandidatosDTO candidatoParaCrear = Persona.CandidatoDeLaPersona;

            candidatoParaCrear.Personas = Persona;

            CandidatosServices candidatoServices = new CandidatosServices();

            if (IsNotConnected)
            {
                return(null);
            }
            WrapperSimpleTypesDTO wrapper = await candidatoServices.CrearCandidato(candidatoParaCrear);

            return(wrapper);
        }
        public async Task <CandidatosDTO> BuscarCandidatoPorCodigoCandidato(CandidatosDTO candidatoParaBuscar)
        {
            if (candidatoParaBuscar == null)
            {
                throw new ArgumentNullException("No puedes buscar un candidato si candidatoParaBuscar es nulo!.");
            }
            if (candidatoParaBuscar.Consecutivo <= 0)
            {
                throw new ArgumentException("candidatoParaBuscar vacio y/o invalido!.");
            }

            IHttpClient client = ConfigurarHttpClient();

            CandidatosDTO informacionCandidato = await client.PostAsync("Candidatos/BuscarCandidatoPorCodigoCandidato", candidatoParaBuscar);

            return(informacionCandidato);
        }
        public async Task <WrapperSimpleTypesDTO> EliminarCandidatoResponsable(CandidatosDTO candidatoResponsableParaBorrar)
        {
            if (candidatoResponsableParaBorrar == null)
            {
                throw new ArgumentNullException("No puedes modificar un candidatoResponsable si candidatoResponsableParaBorrar es nula!.");
            }
            if (candidatoResponsableParaBorrar.Consecutivo <= 0 || candidatoResponsableParaBorrar.CodigoResponsable <= 0)
            {
                throw new ArgumentException("candidatoResponsableParaBorrar vacio y/o invalido!.");
            }

            IHttpClient client = ConfigurarHttpClient();

            WrapperSimpleTypesDTO wrapperEliminarCandidatoResponsable = await client.PostAsync <CandidatosDTO, WrapperSimpleTypesDTO>("Candidatos/EliminarCandidatoVideo", candidatoResponsableParaBorrar);

            return(wrapperEliminarCandidatoResponsable);
        }
        public async Task <WrapperSimpleTypesDTO> ModificarInformacionCandidato(CandidatosDTO candidatoParaModificar)
        {
            if (candidatoParaModificar == null)
            {
                throw new ArgumentNullException("No puedes modificar un candidato si categoriaParaModificar es nulo!.");
            }
            if (candidatoParaModificar.Consecutivo <= 0 ||
                candidatoParaModificar.CodigoGenero <= 0 || candidatoParaModificar.Estatura <= 0 || candidatoParaModificar.Peso <= 0 ||
                candidatoParaModificar.FechaNacimiento == DateTime.MinValue)
            {
                throw new ArgumentException("candidatoParaModificar vacio y/o invalido!.");
            }

            IHttpClient client = ConfigurarHttpClient();

            WrapperSimpleTypesDTO wrapperModificarCandidato = await client.PostAsync <CandidatosDTO, WrapperSimpleTypesDTO>("Candidatos/ModificarInformacionCandidato", candidatoParaModificar);

            return(wrapperModificarCandidato);
        }
        public async Task <JsonResult> UpdatePerson(PersonasDTO person)
        {
            Result <WrapperSimpleTypesDTO> result = new Result <WrapperSimpleTypesDTO>();

            try
            {
                switch (person.TipoPerfil)
                {
                case TipoPerfil.Candidato:
                    CandidatosDTO candidateToUpdate = new CandidatosDTO();
                    candidateToUpdate           = person.CandidatoDeLaPersona;
                    person.CandidatoDeLaPersona = null;
                    candidateToUpdate.Personas  = person;
                    return(await CreateCandidate(candidateToUpdate));

                case TipoPerfil.Grupo:
                    GruposDTO groupToUpdate = new GruposDTO();
                    groupToUpdate           = person.GrupoDeLaPersona;
                    person.GrupoDeLaPersona = null;
                    groupToUpdate.Personas  = person;
                    return(await CreateGroup(groupToUpdate));

                case TipoPerfil.Representante:
                    RepresentantesDTO agentToUpdate = new RepresentantesDTO();
                    agentToUpdate = person.RepresentanteDeLaPersona;
                    person.RepresentanteDeLaPersona = null;
                    agentToUpdate.Personas          = person;
                    return(await CreateAgent(agentToUpdate));

                default:
                    result.Success = false;
                    result.Message = "No es un perfíl válido";
                    return(Json(result, JsonRequestBehavior.AllowGet));
                }
            }
            catch (Exception)
            {
                return(Json(Helper.returnErrorSaveObj(UserLoggedIn().PersonaDelUsuario.CodigoIdioma), JsonRequestBehavior.AllowGet));
            }
        }
 public BuscadorModel(CandidatosDTO candidato) : this(candidato.Personas, TipoBusqueda.Candidato)
 {
     Estatura = candidato.Estatura;
     Peso     = candidato.Peso;
     Edad     = Convert.ToInt32(DateTimeHelper.DiferenciaEntreDosFechasAños(DateTime.Now, candidato.FechaNacimiento));
 }
        public async Task <JsonResult> CreateCandidate(CandidatosDTO candidato)
        {
            Result <WrapperSimpleTypesDTO> result = new Result <WrapperSimpleTypesDTO>();

            try
            {
                string newEmail = candidato.Personas.Usuarios.Email;
                candidato.Personas.CodigoUsuario  = UserLoggedIn().Consecutivo;
                candidato.Personas.Usuarios       = UserLoggedIn();
                candidato.Personas.Usuarios.Email = newEmail;

                CandidatosServices   canditateService = new CandidatosServices();
                PersonasServices     personService    = new PersonasServices();
                AuthenticateServices usuarioService   = new AuthenticateServices();
                if (candidato.Consecutivo != 0)
                {
                    candidato.CategoriasCandidatos = null;
                    result.obj = await personService.ModificarPersona(candidato.Personas); // Update person

                    if (result.obj != null)
                    {
                        result.obj = await canditateService.ModificarInformacionCandidato(candidato); // Update candidate
                    }
                    if (result.obj != null)
                    {
                        result.obj = await usuarioService.ModificarEmailUsuario(candidato.Personas.Usuarios); // Update email user
                    }
                    if (result.obj != null)
                    {
                        UserLoggedIn().PersonaDelUsuario.IdiomaDeLaPersona = candidato.Personas.IdiomaDeLaPersona;
                    }
                }
                else
                {
                    candidato.CategoriasCandidatos.ToList().ForEach(c => c.Categorias = null);
                    result.obj = await canditateService.CrearCandidato(candidato); // Create a new candidate

                    if (result.obj != null)
                    {
                        AuthenticateServices service        = new AuthenticateServices();
                        UsuariosDTO          userToValidate = UserLoggedIn();
                        userToValidate.Personas       = null;
                        userToValidate.TiposPerfiles  = null;
                        userToValidate.PlanesUsuarios = null;
                        var user = await service.VerificarUsuario(userToValidate);

                        if (user != null)
                        {
                            setUserLogin(user);
                        }
                    }
                }


                if (result.obj == null)
                {
                    return(Json(Helper.returnErrorSaveObj(UserLoggedIn().PersonaDelUsuario.CodigoIdioma), JsonRequestBehavior.AllowGet));
                }
                result.Message = "La información se ha guardado con éxito";
                return(Json(result, JsonRequestBehavior.AllowGet));
            }
            catch (Exception)
            {
                return(Json(Helper.returnErrorSaveObj(UserLoggedIn().PersonaDelUsuario.CodigoIdioma), JsonRequestBehavior.AllowGet));
            }
        }