public IActionResult Insertar([FromBody] PersonalDTO personal)
        {
            if (personal == null)
            {
                return(BadRequest("Debe enviar datos"));
            }

            if (string.IsNullOrEmpty(personal.Dni))
            {
                return(BadRequest("Debe enviar DNI"));
            }

            if (string.IsNullOrEmpty(personal.Nombre))
            {
                return(BadRequest("Debe enviar nombre"));
            }

            if (string.IsNullOrEmpty(personal.ApellidoPaterno))
            {
                return(BadRequest("Debe enviar apellido paterno"));
            }

            if (string.IsNullOrEmpty(personal.ApellidoMaterno))
            {
                return(BadRequest("Debe enviar apellido materno"));
            }

            var personalInsertar = _personalService.Insertar(personal);

            return(Ok(personalInsertar));
        }
        public void cargardatospaciente()
        {
            IngresoDTO  ingresoDTO  = (IngresoDTO)Session["ingreso_ADM_DTO"];
            PacienteDTO pacienteDTO = (PacienteDTO)Session["paciente_ADM_DTO"];

            lblRut.Text          = pacienteDTO.rut + "-" + pacienteDTO.digito_verificador;
            lblNombre.Text       = pacienteDTO.nombre + " " + pacienteDTO.apellido_paterno + " " + pacienteDTO.apellido_materno;
            lblEdad.Text         = pacienteDTO.edad;
            lblEstado.Text       = ingresoDTO.estado;
            lblEnfermedad.Text   = ingresoDTO.enfermedad;
            lblFechaIngreso.Text = pacienteDTO.fecha_registro.ToString("dd/MM/yyyy");
            lblHoraIngreso.Text  = ingresoDTO.hora_ingreso;
            lblUnidad.Text       = ingresoDTO.unidad.nombre;
            lblSala.Text         = ingresoDTO.sala.numero;
            lblCama.Text         = ingresoDTO.cama.descripcion;

            PersonalNEG personalNEG    = new PersonalNEG();
            PersonalDTO personalDTOIN  = new PersonalDTO();
            PersonalDTO personalDTOOUT = new PersonalDTO();

            personalDTOIN.unidadID = ingresoDTO.unidadID;
            personalDTOOUT         = personalNEG.readxUnidad(personalDTOIN);

            PersonaDTO personaDTOIN  = new PersonaDTO();
            PersonaDTO personaDTOOUT = new PersonaDTO();

            PersonaNEG personaNEG = new PersonaNEG();

            personaDTOIN.personaID = personalDTOOUT.personaID;
            personaDTOOUT          = personaNEG.read(personaDTOIN);
            lblDoctor.Text         = personaDTOOUT.nombre + " " + personaDTOOUT.apellido_paterno + " " + personaDTOOUT.apellido_materno;
        }
Example #3
0
        public PersonalDTO readxUnidad(PersonalDTO personalDTO)
        {
            DataTable   dt          = new DataTable();
            PersonalDTO retornoDTO  = new PersonalDTO();
            PersonalDAO personalDAO = new PersonalDAO();

            dt = personalDAO.readxUnidad(personalDTO);

            foreach (DataRow row in dt.Rows)
            {
                retornoDTO.personalID = Convert.ToInt64(row["personalID"].ToString());
                retornoDTO.personaID  = Convert.ToInt64(row["personaID"].ToString());

                if (retornoDTO.personaID != 0)
                {
                    PersonaNEG personaNEG = new PersonaNEG();
                    PersonaDTO personaDTO = new PersonaDTO();

                    personaDTO.personaID = retornoDTO.personaID;
                    retornoDTO.persona   = new PersonaDTO();
                    retornoDTO.persona   = personaNEG.read(personaDTO);
                }

                retornoDTO.cargoID  = Convert.ToInt64(row["cargoID"].ToString());
                retornoDTO.unidadID = Convert.ToInt64(row["unidadID"].ToString());
            }


            return(retornoDTO);
        }
Example #4
0
        public int delete(PersonalDTO personalDTO)
        {
            int retorno = 0;

            string        sql = "DELETE FROM Personal WHERE personalID=@personalID";
            SqlConnection con = new SqlConnection(connectionString);
            SqlCommand    cmd = new SqlCommand(sql, con);

            cmd.Parameters.AddWithValue("@personalID", personalDTO.personalID);
            cmd.CommandType = CommandType.Text;
            con.Open();

            try
            {
                retorno = cmd.ExecuteNonQuery();
            }
            catch (Exception ex)
            {
                retorno = 0;
            }
            finally
            {
                con.Close();
            }
            return(retorno);
        }
Example #5
0
        public DataTable readxUnidad(PersonalDTO personalDTO)
        {
            //List<ExamenDTO> retornoDTO = new List<ExamenDTO>();

            DataTable dataTable = new DataTable();

            SqlConnection conn = new SqlConnection(connectionString);

            string sql = "select * from Personal where unidadID = @unidadID and cargoID = 1";

            SqlCommand sqlcmd = new SqlCommand(sql, conn);

            sqlcmd.Parameters.Add(new SqlParameter("@unidadID", SqlDbType.Int));

            sqlcmd.Parameters["@unidadID"].Value = personalDTO.unidadID;

            try
            {
                conn.Open();
                SqlDataReader rdr = sqlcmd.ExecuteReader();
                dataTable.Load(rdr);
                rdr.Close();
            }
            catch
            {
                dataTable = null;
            }
            finally
            {
                conn.Close();
            }
            return(dataTable);
        }
Example #6
0
        public int create(PersonalDTO personalDTO)
        {
            int           retorno = 0;
            SqlConnection conn    = new SqlConnection(connectionString);

            string sql = "INSERT INTO Personal (personaID, cargoID, unidadID) values(@personaID, @cargoID, @unidadID)";

            SqlCommand sqlcmd = new SqlCommand(sql, conn);

            sqlcmd.Parameters.AddWithValue("@personaID", personalDTO.personaID);
            sqlcmd.Parameters.AddWithValue("@cargoID", personalDTO.cargoID);
            sqlcmd.Parameters.AddWithValue("@unidadID", personalDTO.unidadID);

            sqlcmd.CommandType = CommandType.Text;
            conn.Open();

            try
            {
                retorno = sqlcmd.ExecuteNonQuery();
            }
            catch
            {
                retorno = 0;
            }
            finally
            {
                conn.Close();
            }

            return(retorno);
        }
Example #7
0
        public DataTable buscarxrut(PersonalDTO personalDTO)
        {
            DataTable dataTable = new DataTable();

            SqlConnection conn = new SqlConnection(connectionString);

            string sql = "select pl.personalID, p.personaID, p.rut, p.dv, p.nombres, p.ap_paterno, p.ap_materno, pl.clave from Personal pl inner join Persona p on pl.personaID = p.personaID and p.rut = @rut and pl.clave = @clave";

            SqlCommand sqlcmd = new SqlCommand(sql, conn);

            sqlcmd.Parameters.Add(new SqlParameter("@rut", SqlDbType.VarChar));
            sqlcmd.Parameters["@rut"].Value = personalDTO.rut;

            sqlcmd.Parameters.Add(new SqlParameter("@clave", SqlDbType.VarChar));
            sqlcmd.Parameters["@clave"].Value = personalDTO.clave;

            try
            {
                conn.Open();
                SqlDataReader rdr = sqlcmd.ExecuteReader();
                dataTable.Load(rdr);
                rdr.Close();
            }
            catch
            {
                dataTable = null;
            }
            finally
            {
                conn.Close();
            }
            return(dataTable);
        }
Example #8
0
        public ActionResult Create(string editAction, string personalId)
        {
            PersonalDTO personalDTO = new PersonalDTO();

            try
            {
                switch (editAction)
                {
                case EditActionConstant.NEW:
                    ViewBag.Title = "Nuevo Usuario";
                    personalDTO.FechaNacimiento = DateTime.Now;
                    personalDTO.EditAction      = editAction;
                    break;

                case EditActionConstant.EDIT:
                    ViewBag.Title          = "Editar Usuario";
                    personalDTO            = personalService.GetPersonalId(Convert.ToInt32(personalId));
                    personalDTO.EditAction = editAction;
                    ListarPersonal(personalDTO.PersonalId);
                    break;
                }

                ListDropList();
            }
            catch (Exception ex)
            {
                throw ex;
            }
            return(PartialView(personalDTO));
        }
Example #9
0
        public ActionResult Create(JsonHeader collection)
        {
            Dictionary <string, string> headerDictionary  = WebHelper.JsonToDictionary(collection.Header);
            JsonResultMessage           jsonResultMessage = new JsonResultMessage();
            PersonalDTO personaDTO = new PersonalDTO();

            try
            {
                personaDTO.PersonalId      = Convert.ToInt32(headerDictionary["PersonalId"]);
                personaDTO.NumeroDocumento = Convert.ToString(headerDictionary["NumeroDocumento"]);
                personaDTO.Apellidos       = Convert.ToString(headerDictionary["Apellidos"]);
                personaDTO.FechaNacimiento = Convert.ToDateTime(headerDictionary["FechaNacimiento"]);
                personaDTO.Telefono        = Convert.ToString(headerDictionary["Telefono"]);
                personaDTO.Correo          = Convert.ToString(headerDictionary["Correo"]);
                personaDTO.Usuario         = Convert.ToString(headerDictionary["Usuario"]);
                personaDTO.Password        = Convert.ToString(headerDictionary["Password"]);
                personaDTO.Estado          = EstadoConstante.ACTIVO;
                personaDTO.UsuarioDTO      = new UsuarioDTO
                {
                    PersonalId = personaDTO.PersonalId,
                    Nombre     = string.Concat(personaDTO.Nombres, " ", personaDTO.Apellidos),
                    UserName   = personaDTO.Usuario,
                    Password   = personaDTO.Password,
                    Estado     = EstadoConstante.ACTIVO
                };
                personalService.InsertarUsuario(personaDTO);
                jsonResultMessage.message = "Usuario grabado satisfactoriamente.";

                return(Json(jsonResultMessage));
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
Example #10
0
        public int create(PersonalDTO personalDTO)
        {
            int         retorno     = 0;
            PersonalDAO personalDAO = new PersonalDAO();

            retorno = personalDAO.create(personalDTO);

            return(retorno);
        }
        public IActionResult Actualizar([FromBody] PersonalDTO personal)
        {
            if (personal == null)
            {
                return(BadRequest("Debe enviar datos"));
            }

            if (personal.IdPer == 0)
            {
                return(BadRequest("Debe enviar id"));
            }

            if (personal.IdEmp == 0)
            {
                return(BadRequest("Debe enviar id de empresa"));
            }

            if (personal.IdAre == 0)
            {
                return(BadRequest("Debe enviar id de área"));
            }

            if (personal.IdCar == 0)
            {
                return(BadRequest("Debe enviar id de cargo"));
            }

            if (string.IsNullOrEmpty(personal.Dni))
            {
                return(BadRequest("Debe enviar DNI"));
            }

            if (string.IsNullOrEmpty(personal.Nombre))
            {
                return(BadRequest("Debe enviar nombre"));
            }

            if (string.IsNullOrEmpty(personal.ApellidoPaterno))
            {
                return(BadRequest("Debe enviar apellido paterno"));
            }

            if (string.IsNullOrEmpty(personal.ApellidoMaterno))
            {
                return(BadRequest("Debe enviar apellido materno"));
            }

            var personalActualizar = _personalService.Actualizar(personal);

            if (personalActualizar == null)
            {
                return(BadRequest("Personal no actualizado"));
            }

            return(Ok(personalActualizar));
        }
        public List <PersonalDTO> getListarPersonal_Codigo_login(string COD_PERSONAL)
        {
            List <PersonalDTO> ListaPersonalDTO = new List <PersonalDTO>();
            //ListaUsuarioEmpresaDTO = null;
            string        cnxString = _appDBContext.Database.GetConnectionString();
            SqlConnection cnx       = new SqlConnection(cnxString);

            try
            {
                cnx.Open();
                using (SqlCommand Sqlcmd = new SqlCommand())
                {
                    Sqlcmd.Connection  = cnx;
                    Sqlcmd.CommandType = CommandType.StoredProcedure;
                    Sqlcmd.CommandText = "SP_S_Listar_Personal_X_Codigo_Login_21";
                    Sqlcmd.Parameters.Clear();
                    Sqlcmd.Parameters.Add("@Cod_Personal", SqlDbType.Int).Value = COD_PERSONAL;
                    // Sqlcmd.Parameters.Add("@ID_USER", SqlDbType.Int).Value = ID_USER;
                    SqlDataReader oDataReader = Sqlcmd.ExecuteReader();
                    while (oDataReader.Read())
                    {
                        PersonalDTO PersonalDTO = new PersonalDTO();

                        PersonalDTO.cod_personal = oDataReader["COD_PERSONAL"].ToString();
                        PersonalDTO.nom_personal = oDataReader["NOM_PERSONAL"].ToString();
                        PersonalDTO.ape_paterno  = oDataReader["APE_PATERNO"].ToString();
                        PersonalDTO.ape_materno  = oDataReader["APE_MATERNO"].ToString();
                        PersonalDTO.activo       = bool.Parse(oDataReader["ACTIVO"].ToString());
                        PersonalDTO.email        = oDataReader["EMAIL"].ToString();

                        ListaPersonalDTO.Add(PersonalDTO);
                    }
                }
            }
            catch (SqlException sex)
            {
                eErrorLog mensajeLogError = new eErrorLog(
                    sex.Message, "PersonalRepository/getListarPersonal_Codigo_login(). SQL." + sex, "Error Sql");
                mensajeLogError.RegisterLog();
            }
            catch (Exception ex)
            {
                eErrorLog mensajeLogError = new eErrorLog(ex.Message, "PersonalRepository/getListarPersonal_Codigo_login() EX." + ex, "Error");
                mensajeLogError.RegisterLog();
            }
            finally
            {
                if (cnx.State == System.Data.ConnectionState.Open)
                {
                    cnx.Close();
                }
            }


            return(ListaPersonalDTO);
        }
Example #13
0
        /// <summary>
        /// Obtener una sola persona del Personal
        /// </summary>
        /// <param name="id_personal">Id del usuario a buscar</param>
        /// <returns></returns>
        public PersonalDTO GetPersonal(int id_personal)
        {
            PersonalDTO personal = new PersonalDTO();

            using (var hospitalDB = new HospitalDB())
            {
                personal = hospitalDB.personal.Find(id_personal);
            }
            return(personal);
        }
        public async Task <IActionResult> UpdateAsync(PersonalDTO personal)
        {
            if (!ModelState.IsValid)
            {
                return(CustomResponse(ModelState));
            }

            var model = await _personalAppService.UpdateAsync(personal);

            return(CustomResponse(model));
        }
        public async Task <IActionResult> DeleteSoAsync(PersonalDTO personal)
        {
            try
            {
                await _personalAppService.DeleteSoftAsync(personal);

                return(CustomResponse());
            }catch (Exception)
            {
                return(CustomResponse());
            }
        }
Example #16
0
        public async Task <bool> UpdateAsync(PersonalDTO model, string id)
        {
            try
            {
                var user = _databaseContext.Usuario
                           .Include(u => u.Rol)
                           .Single(u => u.Id == id);
                if (model.Email != null)
                {
                    user.Email    = model.Email;
                    user.UserName = model.Email;
                }
                if (model.NombrePersonal != null)
                {
                    user.NombrePersonal = model.NombrePersonal;
                }
                if (model.ApellidoPersonal != null)
                {
                    user.ApellidoPersonal = model.ApellidoPersonal;
                }
                if (model.Cargo != null)
                {
                    user.Cargo = model.Cargo;
                }
                if (model.PhoneNumber != null)
                {
                    user.PhoneNumber = model.PhoneNumber;
                }
                if (model.Pais != null)
                {
                    user.Pais = model.Pais;
                }
                if (model.newPassword != null)
                {
                    var token = await _userManager.GeneratePasswordResetTokenAsync(user);

                    await _userManager.ResetPasswordAsync(user, token, model.newPassword);
                }

                await _userManager.UpdateAsync(user);

                await _databaseContext.SaveChangesAsync();

                return(true);
            }

            catch (Exception e)
            {
                Console.WriteLine(e);
                return(false);
            }
        }
        public IActionResult Grabar(PersonalDTO personal)
        {
            if (personal.IdAre == 0)
            {
                _personalService.Insertar(personal);
            }
            else
            {
                _personalService.Actualizar(personal);
            }

            return(RedirectToAction("Index"));
        }
        public async Task DeleteAsync(PersonalDTO personalDTO)
        {
            try
            {
                await _unitOfWork.IPersonRepository.DeleteAsync(_mapper.Map <Personal>(personalDTO));

                await _unitOfWork.CommitAsync();
            }
            catch (Exception e)
            {
                _notifier.Handle(new NotificationMessage("Erro", e.Message));
            }
        }
        public PersonalDTO Actualizar(PersonalDTO personal)
        {
            try
            {
                _contexto.Update(personal);
                _contexto.SaveChanges();

                return(personal);
            }
            catch (Exception)
            {
                return(null);
            }
        }
        public async Task DeleteSoftAsync(PersonalDTO personalDTO)
        {
            try
            {
                var result = await _unitOfWork.IPersonRepository.GetByIdAsync(x => x.Id.Equals(personalDTO.Id));

                result.RecordSituation = RecordSituation.INACTIVE;
                await _unitOfWork.CommitAsync();
            }
            catch (Exception e)
            {
                _notifier.Handle(new NotificationMessage("Erro", e.Message));
            }
        }
        public PersonalDTO Insertar(PersonalDTO personal)
        {
            try
            {
                _contexto.Add(personal);
                _contexto.SaveChanges();

                return(personal);
            }
            catch (Exception)
            {
                return(null);
            }
        }
Example #22
0
        public async Task <IActionResult> Post([FromBody] PersonalDTO model)
        {
            var user = new Usuario(model.Id, model.Email, model.NombrePersonal, model.ApellidoPersonal, model.Cargo,
                                   model.FechaAfilacion, model.Email, model.PhoneNumber, model.Password, model.Pais);

            user.EmailConfirmed = true;

            var result = await _userManager.CreateAsync(user, model.Password);

            if (result.Succeeded)
            {
                return(Ok(_usuarioService.Add(model)));
            }
            return(Ok());
        }
Example #23
0
        public async Task <PersonaDTO> GetById(int?id)
        {
            PersonaDTO Persona = new PersonaDTO();

            Persona = await(from p in _context.PERSONA
                            join e in _context.EMPLEADO on p.idPersona equals e.idPersona
                            where p.idPersona == id
                            select new PersonaDTO
            {
                idPersona       = p.idPersona,
                nombres         = p.nombres,
                apellidoPaterno = p.apellidoPaterno,
                apellidoMaterno = p.apellidoMaterno,
                fechaNacimiento = p.fechaNacimiento,
                telefono        = p.telefono,
                numeroDocumento = (int)p.dniPersona,
                numeroRuc       = p.numeroRuc
            }).FirstOrDefaultAsync();
            Persona.personal = await(from e in _context.EMPLEADO
                                     where e.idPersona == Persona.idPersona
                                     select new PersonalDTO
            {
                idEmpleado      = e.idEmpleado,
                idTipoEmpleado  = e.idTipoEmpleado,
                fechaIngreso    = e.fechaIngreso.Value.ToString("yyyy-MM-dd"),
                cargo           = e.cargo,
                descripcionArea = e.descripcionArea
            }).FirstOrDefaultAsync();
            //Tipo de Empleado verificar
            if (Persona.personal.idTipoEmpleado == (int)await _detalleRepository.GetIdDetalleByDescripcion("MEDICA/O"))
            {
                PersonalDTO personaTemporal = new PersonalDTO();
                personaTemporal = await(from m in _context.MEDICO
                                        where m.idEmpleado == Persona.personal.idEmpleado
                                        select new PersonalDTO
                {
                    idEspecialidad = (from tb in _context.TABLA_DETALLE
                                      where m.idEspecialidad == tb.idTablaDetalle
                                      select m.idEspecialidad).FirstOrDefault(),
                    idMedico      = m.idMedico,
                    numeroColegio = m.numeroColegio
                }).FirstOrDefaultAsync();
                Persona.personal.idEspecialidad = personaTemporal.idEspecialidad;
                Persona.personal.idMedico       = personaTemporal.idMedico;
                Persona.personal.numeroColegio  = personaTemporal.numeroColegio;
            }
            return(Persona);
        }
Example #24
0
        public void UpdatePersonal(PersonalDTO personal)                //Metod för att ändra personaluppgifter.
        {
            using (var db = new DataContext())
            {
                var query = db.Personal.Where(x => x.PersonalID == personal.PersonalID).FirstOrDefault();

                query.PersonNr            = personal.PersonNr;
                query.Namn                = personal.Namn;
                query.Månadslön           = (int)personal.Månadslön;
                query.Sysselsättningsgrad = personal.Sysselsättningsgrad;
                query.Vakansavdrag        = personal.Vakansavdrag;
                query.Årsarbete           = personal.Årsarbete;

                db.SaveChanges();
            }
        }
Example #25
0
        public void RemovePersonal(PersonalDTO personal)        //Metod för att radera personal ur databasen/registret.
        {
            using (var db = new DataContext())
            {
                var avdelningpers = from x in db.AvdelningPersonalxRef
                                    where x.Personal_PersonalID == personal.PersonalID
                                    select x;
                foreach (var item in avdelningpers)
                {
                    db.AvdelningPersonalxRef.Remove(item);
                }

                var personalen = db.Personal.Where(x => x.PersonalID == personal.PersonalID).FirstOrDefault();
                db.Personal.Remove(personalen);
                db.SaveChanges();
            }
        }
        public async Task <PersonalDTO> UpdateAsync(PersonalDTO personalDTO)
        {
            try
            {
                _unitOfWork.IPersonRepository.Update(_mapper.Map <Personal>(personalDTO));
                await _unitOfWork.CommitAsync();

                var result = await GetByIdAsync(personalDTO.Id);

                return(result);
            }
            catch (Exception e)
            {
                _notifier.Handle(new NotificationMessage("Erro", e.Message));
                throw new Exception();
            }
        }
        public async Task <IActionResult> CreateAsync(PersonalDTO personal)
        {
            if (!ModelState.IsValid)
            {
                return(CustomResponse(ModelState));
            }

            try
            {
                await _personalAppService.AddAsync(personal);

                return(CustomResponse());
            }
            catch (Exception)
            {
                return(CustomResponse());
            }
        }
        public ActionResult Create(JsonHeader collection)
        {
            Dictionary <string, string> editDictionary    = WebHelper.JsonToDictionary(collection.Header);
            JsonResultMessage           jsonResultMessage = new JsonResultMessage();
            PersonalDTO personalDTO = new PersonalDTO();

            try
            {
                if (collection.EditAction == EditActionConstant.EDIT)
                {
                    personalDTO.PersonalId = Convert.ToInt32(editDictionary["PersonalId"]);
                }

                personalDTO.Nombres         = editDictionary["Nombres"].ToUpper().ToString();
                personalDTO.Apellidos       = editDictionary["Apellidos"].ToUpper().ToString();
                personalDTO.NumeroDocumento = editDictionary["NumeroDocumento"].ToString();
                personalDTO.FechaNacimiento = Convert.ToDateTime(editDictionary["FechaNacimiento"]);
                personalDTO.Telefono        = editDictionary["Telefono"].ToString();
                personalDTO.Celular         = editDictionary["Celular"].ToString();
                personalDTO.Correo          = editDictionary["Correo"].ToUpper().ToString();

                personalDTO.Estado            = EstadoConstante.ACTIVO;
                personalDTO.UsuarioCreacionId = 1;
                personalDTO.FechaCreacion     = DateTime.Now;

                if (collection.EditAction == EditActionConstant.NEW)
                {
                    _personalService.Create(personalDTO);
                }
                else
                {
                    _personalService.Update(personalDTO);
                }

                jsonResultMessage.message = "Personal grabado satisfactoriamente.";
            }
            catch (Exception ex)
            {
                jsonResultMessage.success = false;
                jsonResultMessage.message = ex.Message;
                throw ex;
            }
            return(Json(jsonResultMessage));
        }
Example #29
0
        public bool Add(PersonalDTO model)
        {
            try
            {
                var user = _databaseContext.Usuario.Single(x => x.Email == model.Email);

                _databaseContext.Rol
                .Include(u => u.usuarios)
                .Single(r => r.Name == model.Name)
                .usuarios.Add(user);
                _databaseContext.SaveChanges();
                return(true);
            }
            catch (Exception e)
            {
                Console.WriteLine(e);
                return(false);
            }
        }
        public IActionResult Editar(int id = 0)
        {
            PersonalDTO personal;

            if (id == 0) //nuevo
            {
                personal = new PersonalDTO();
            }
            else //editar
            {
                personal = _personalService.ObtenerPorId(id);
            }

            var listItemsEmpresas = from e in _empresaService.Listar()
                                    select new SelectListItem
            {
                Text  = e.RazonSocial,
                Value = e.IdEmp.ToString()
            };

            var listItemsAreas = from a in _areaService.Listar()
                                 select new SelectListItem
            {
                Text  = a.Descripcion,
                Value = a.IdAre.ToString()
            };

            var listItemsCargos = from c in _cargoService.Listar()
                                  select new SelectListItem
            {
                Text  = c.Descripcion,
                Value = c.IdCar.ToString()
            };

            ViewBag.areas            = listItemsAreas;
            ViewBag.cargos           = listItemsCargos;
            ViewBag.empresas         = listItemsEmpresas;
            ViewBag.listItemsGeneros = genero.listItemsGeneros;
            ViewBag.listItemsEstados = estado.listItemsEstados;

            return(View(personal));
        }