Ejemplo n.º 1
0
        public async Task CargarPerfilPuestoPorDependencia(int IdDependencia, int IdManualPuesto)
        {
            try
            {
                var indiceOcupacional = new IndiceOcupacional
                {
                    IdDependencia = IdDependencia,
                };
                var listarmanualespuestos = await apiServicio.Listar <IndiceOcupacional>(indiceOcupacional, new Uri(WebApp.BaseAddress), "api/Empleados/ListarManualPuestoporDependenciaTodosEstados");

                var mostrarLista = new List <ManualPuesto>();

                foreach (var item in listarmanualespuestos)
                {
                    if (item.IdManualPuesto == IdManualPuesto)
                    {
                        mostrarLista.Add(new ManualPuesto {
                            IdManualPuesto = item.ManualPuesto.IdManualPuesto, Nombre = item.ManualPuesto.Nombre
                        });
                        break;
                    }
                }

                ViewData["IdManualPuesto"] = new SelectList(mostrarLista, "IdManualPuesto", "Nombre");
            }
            catch (Exception ex) { }
        }
Ejemplo n.º 2
0
        public async Task<List<Estudio>> ListarEstudiosNoAsignadasIndiceOcupacional([FromBody]IndiceOcupacional indiceOcupacional)
        {
            try
            {
                var Lista = await db.Estudio
                                   .Where(e => !db.IndiceOcupacionalEstudio
                                                   .Where(a => a.IndiceOcupacional.IdIndiceOcupacional == indiceOcupacional.IdIndiceOcupacional)
                                                   .Select(ioe => ioe.IdEstudio)
                                                   .Contains(e.IdEstudio))
                                          .ToListAsync();
                return Lista;
            }
            catch (Exception ex)
            {
                await GuardarLogService.SaveLogEntry(new LogEntryTranfer
                {
                    ApplicationName = Convert.ToString(Aplicacion.SwTH),
                    ExceptionTrace = ex,
                    Message = Mensaje.Excepcion,
                    LogCategoryParametre = Convert.ToString(LogCategoryParameter.Critical),
                    LogLevelShortName = Convert.ToString(LogLevelParameter.ERR),
                    UserName = "",

                });
                return new List<Estudio>();
            }
        }
Ejemplo n.º 3
0
        public async Task <List <Mision> > ListarMisionNoAsignadasIndiceOcupacional([FromBody] IndiceOcupacional indiceOcupacional)
        {
            try
            {
                var ListaMision = await db.Mision
                                  .Where(m => !db.MisionIndiceOcupacional
                                         .Where(a => a.IndiceOcupacional.IdIndiceOcupacional == indiceOcupacional.IdIndiceOcupacional)
                                         .Select(iom => iom.IdMision)
                                         .Contains(m.IdMision))
                                  .ToListAsync();



                return(ListaMision);
            }
            catch (Exception ex)
            {
                await GuardarLogService.SaveLogEntry(new LogEntryTranfer
                {
                    ApplicationName      = Convert.ToString(Aplicacion.SwTH),
                    ExceptionTrace       = ex,
                    Message              = Mensaje.Excepcion,
                    LogCategoryParametre = Convert.ToString(LogCategoryParameter.Critical),
                    LogLevelShortName    = Convert.ToString(LogLevelParameter.ERR),
                    UserName             = "",
                });

                return(new List <Mision>());
            }
        }
        public async Task <IActionResult> AdicionarCapacitaciones(string id)
        {
            var lista = new List <Capacitacion>();

            try
            {
                var indiceOcupacional = new IndiceOcupacional
                {
                    IdIndiceOcupacional = Convert.ToInt32(id),
                };
                lista = await apiServicio.Listar <Capacitacion>(indiceOcupacional,
                                                                new Uri(WebApp.BaseAddress),
                                                                "/api/IndiceOcupacionalCapacitaciones/ListaFiltradaCapacitaciones");

                ViewData["IdCapacitacion"] = new Microsoft.AspNetCore.Mvc.Rendering.SelectList(lista, "IdCapacitacion", "Nombre");

                //ViewBag.listacap = new SelectList(lista, "IdCapacitacion", "Nombre");


                var Indice = new IndiceOcupacionalCapacitaciones
                {
                    IdIndiceOcupacional = Convert.ToInt32(id),
                };

                return(PartialView("..//IndicesOcupacionales//AdicionarCapacitaciones", Indice));
            }
            catch (Exception)
            {
                return(BadRequest());
            }
        }
        public async Task <ActionResult> AdicionarExperienciaLaboralRequerida(string idIndiceOcupacional, string mensaje)
        {
            var indiceOcupacional = new IndiceOcupacional
            {
                IdIndiceOcupacional = Convert.ToInt32(idIndiceOcupacional),
            };



            var indiceExperienciaLaboralRequerida = new IndiceOcupacionalExperienciaLaboralRequeridaView
            {
                IdIndiceOcupacional = Convert.ToInt32(idIndiceOcupacional),
                ListaExperienciaLaboralRequerida = await apiServicio.Listar <ExperienciaLaboralRequerida>(indiceOcupacional, new Uri(WebApp.BaseAddress)
                                                                                                          , "/api/ExperienciaLaboralRequeridas/ListarExperienciaLaboralRequeridaNoAsignadasIndiceOcupacional")
            };

            var resultado = await CargarComboExperienciaLaboralRequerida(indiceOcupacional);

            if (resultado)
            {
                InicializarMensaje(mensaje);
                return(PartialView(indiceExperienciaLaboralRequerida));
            }


            ViewData["Mensaje"] = Mensaje.NoExistenRegistrosPorAsignar;
            return(PartialView("NoExisteElemento"));
        }
        public async Task <ActionResult> AdicionarRIE(string idIndiceOcupacional, string mensaje)
        {
            var indiceOcupacional = new IndiceOcupacional
            {
                IdIndiceOcupacional = Convert.ToInt32(idIndiceOcupacional),
            };

            var listaElementos = await apiServicio.Listar <RelacionesInternasExternasIndiceOcupacional>(indiceOcupacional, new Uri(WebApp.BaseAddress)
                                                                                                        , "/api/RelacionesInternasExternas/ListarElementosRIE");



            if (listaElementos.Count == 0)
            {
                var indiceRIE = new IndiceOcupacionalRIEView
                {
                    IdIndiceOcupacional             = Convert.ToInt32(idIndiceOcupacional),
                    ListaRelacionesInternasExternas = await apiServicio.Listar <RelacionesInternasExternas>(indiceOcupacional, new Uri(WebApp.BaseAddress)
                                                                                                            , "/api/RelacionesInternasExternas/ListarRIENoAsignadasIndiceOcupacional")
                };

                InicializarMensaje(mensaje);
                return(PartialView(indiceRIE));
            }

            ViewData["Mensaje"] = Mensaje.NoExistenRegistrosPorAsignar;
            return(PartialView("NoExisteElemento"));
        }
        public async Task <ActionResult> AdicionarEstudio(string idIndiceOcupacional, string mensaje)

        {
            var indiceEstudio = new IndiceOcupacionalEstudio
            {
                IdIndiceOcupacional = Convert.ToInt32(idIndiceOcupacional),
            };

            var indiceOcupacional = new IndiceOcupacional
            {
                IdIndiceOcupacional = Convert.ToInt32(idIndiceOcupacional),
            };


            var resultado = await CargarComboEstudio(indiceOcupacional);

            if (resultado)
            {
                InicializarMensaje(mensaje);
                return(PartialView(indiceEstudio));
            }

            ViewData["Mensaje"] = Mensaje.NoExistenRegistrosPorAsignar;
            return(PartialView("NoExisteElemento"));
        }
        public async Task <ActionResult> AdicionarActividesEsenciales(string idIndiceOcupacional, string mensaje)

        {
            var indideactividedesEsenciales = new IndiceOcupacionalActividadesEsenciales
            {
                IdIndiceOcupacional = Convert.ToInt32(idIndiceOcupacional),
            };

            var indiceOcupacional = new IndiceOcupacional
            {
                IdIndiceOcupacional = Convert.ToInt32(idIndiceOcupacional),
            };


            var resultado = await CargarComboActividedesEsenciales(indiceOcupacional);

            if (resultado)
            {
                InicializarMensaje(mensaje);
                return(PartialView(indideactividedesEsenciales));
            }

            ViewData["Mensaje"] = Mensaje.NoExistenRegistrosPorAsignar;
            return(PartialView("NoExisteElemento"));
        }
Ejemplo n.º 9
0
        public async Task <IActionResult> PutIndiceOcupacional([FromRoute] int id, [FromBody] IndiceOcupacional indiceOcupacional)
        {
            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }

            if (id != indiceOcupacional.IdIndiceOcupacional)
            {
                return(BadRequest());
            }

            db.Entry(indiceOcupacional).State = EntityState.Modified;

            try
            {
                await db.SaveChangesAsync();
            }
            catch (DbUpdateConcurrencyException)
            {
                if (!IndiceOcupacionalExists(id))
                {
                    return(NotFound());
                }
                else
                {
                    throw;
                }
            }

            return(NoContent());
        }
Ejemplo n.º 10
0
        public async Task <IActionResult> CargarComportamientosObservables(string id)
        {
            var lista = new List <ComportamientoObservable>();

            try
            {
                var indiceOcupacional = new IndiceOcupacional
                {
                    IdIndiceOcupacional = Convert.ToInt32(id),
                };
                lista = await apiServicio.Listar <ComportamientoObservable>(indiceOcupacional,
                                                                            new Uri(WebApp.BaseAddress),
                                                                            "api/IndiceOcupacionalComportamientosObservables/ListaFiltradaComportamientosObservables");

                //ViewData["IdComportamientoObservable"] = new Microsoft.AspNetCore.Mvc.Rendering.SelectList(lista, "IdComportamientoObservable", "Nombre");

                ViewBag.listacap = new SelectList(lista, "IdComportamientoObservable", "Nombre");


                var Indice = new IndiceOcupacionalComportamientoObservable
                {
                    IdIndiceOcupacional = Convert.ToInt32(id),
                };

                return(PartialView("_PartialViewIndiceOcupacionalComportamientoObservable"));
            }
            catch (Exception)
            {
                return(BadRequest());
            }
        }
        public async Task <IActionResult> Create(IndiceOcupacional indiceOcupacional)
        {
            Response response = new Response();

            try
            {
                if (ModelState.IsValid)
                {
                    if (indiceOcupacional.Nivel == "0")
                    {
                        indiceOcupacional.Nivel = Constantes.NivelProfesional;
                    }
                    else
                    {
                        indiceOcupacional.Nivel = Constantes.NivelNoProfesional;
                    }
                    response = await apiServicio.InsertarAsync(indiceOcupacional,
                                                               new Uri(WebApp.BaseAddress),
                                                               "api/IndicesOcupacionales/InsertarIndiceOcupacional");

                    if (response.IsSuccess)
                    {
                        var responseLog = await GuardarLogService.SaveLogEntry(new LogEntryTranfer
                        {
                            ApplicationName      = Convert.ToString(Aplicacion.WebAppTh),
                            ExceptionTrace       = null,
                            Message              = "Se ha creado un indice ocupacional",
                            UserName             = "******",
                            LogCategoryParametre = Convert.ToString(LogCategoryParameter.Create),
                            LogLevelShortName    = Convert.ToString(LogLevelParameter.ADV),
                            EntityID             = string.Format("{0} {1}", "Indice Ocupacional:", indiceOcupacional.IdIndiceOcupacional),
                        });

                        return(RedirectToAction("Index"));
                    }
                }
                await CargarListaCombox();

                InicializarMensaje(response.Message);
                var indiceDetalle = new IndiceOcupacionalDetalle {
                    IndiceOcupacional = indiceOcupacional
                };
                return(View(indiceDetalle));
            }
            catch (Exception ex)
            {
                await GuardarLogService.SaveLogEntry(new LogEntryTranfer
                {
                    ApplicationName      = Convert.ToString(Aplicacion.WebAppTh),
                    Message              = "Creando un Indice ocupacional ",
                    ExceptionTrace       = ex.Message,
                    LogCategoryParametre = Convert.ToString(LogCategoryParameter.Create),
                    LogLevelShortName    = Convert.ToString(LogLevelParameter.ERR),
                    UserName             = "******"
                });

                return(BadRequest());
            }
        }
        public async Task <IActionResult> AdicionarRIE(int idRIE, int IdIndiceOcupacional)
        {
            Response response = new Response();

            try
            {
                var RIEIndiceOcupacional = new RelacionesInternasExternasIndiceOcupacional
                {
                    IdRelacionesInternasExternas = idRIE,
                    IdIndiceOcupacional          = IdIndiceOcupacional,
                };


                response = await apiServicio.InsertarAsync(RIEIndiceOcupacional,
                                                           new Uri(WebApp.BaseAddress),
                                                           "/api/IndicesOcupacionales/InsertarRelacionesInternasExternas");

                if (response.IsSuccess)
                {
                    var responseLog = await GuardarLogService.SaveLogEntry(new LogEntryTranfer
                    {
                        ApplicationName      = Convert.ToString(Aplicacion.WebAppTh),
                        ExceptionTrace       = null,
                        Message              = "Se ha creado un indice ocupacional relaciones internas externas",
                        UserName             = "******",
                        LogCategoryParametre = Convert.ToString(LogCategoryParameter.Create),
                        LogLevelShortName    = Convert.ToString(LogLevelParameter.ADV),
                        EntityID             = string.Format("{0} {1} {2} {3}", "Índice ocupacional relaciones internas externas:", RIEIndiceOcupacional.IdIndiceOcupacional, "Relaciones Internas Externas:", RIEIndiceOcupacional.IdRelacionesInternasExternas),
                    });

                    return(RedirectToAction("Detalles", new { id = RIEIndiceOcupacional.IdIndiceOcupacional }));
                }


                var indiceOcupacional = new IndiceOcupacional
                {
                    IdIndiceOcupacional = RIEIndiceOcupacional.IdIndiceOcupacional,
                };

                await CargarComboMision(indiceOcupacional);

                InicializarMensaje(response.Message);
                return(PartialView("AdicionarRIE", RIEIndiceOcupacional));
            }
            catch (Exception ex)
            {
                await GuardarLogService.SaveLogEntry(new LogEntryTranfer
                {
                    ApplicationName      = Convert.ToString(Aplicacion.WebAppTh),
                    Message              = "Creando un Indice ocupacional ",
                    ExceptionTrace       = ex,
                    LogCategoryParametre = Convert.ToString(LogCategoryParameter.Create),
                    LogLevelShortName    = Convert.ToString(LogLevelParameter.ERR),
                    UserName             = "******"
                });

                return(BadRequest());
            }
        }
        public async Task <IActionResult> AdicionarComportamientosObservables(int idIndiceOcupacional, int idComportamientoObservable)
        {
            Response response = new Response();

            try
            {
                var indiceOcupacionalComportamientoObservable = new  bd.webappth.entidades.Negocio.IndiceOcupacionalComportamientoObservable();

                indiceOcupacionalComportamientoObservable.IdComportamientoObservable = Convert.ToInt32(idComportamientoObservable);
                indiceOcupacionalComportamientoObservable.IdIndiceOcupacional        = Convert.ToInt32(idIndiceOcupacional);

                response = await apiServicio.InsertarAsync(indiceOcupacionalComportamientoObservable,
                                                           new Uri(WebApp.BaseAddress),
                                                           "/api/IndicesOcupacionales/InsertarComportamientoObservable");

                if (response.IsSuccess)
                {
                    var responseLog = await GuardarLogService.SaveLogEntry(new LogEntryTranfer
                    {
                        ApplicationName      = Convert.ToString(Aplicacion.WebAppTh),
                        ExceptionTrace       = null,
                        Message              = "Se ha creado un indice ocupacional",
                        UserName             = "******",
                        LogCategoryParametre = Convert.ToString(LogCategoryParameter.Create),
                        LogLevelShortName    = Convert.ToString(LogLevelParameter.ADV),
                        EntityID             = string.Format("{0} {1} {2} {3}", "Índice ocupacional:", indiceOcupacionalComportamientoObservable.IdIndiceOcupacional, "Comportamiento Observable:", indiceOcupacionalComportamientoObservable.IdComportamientoObservable),
                    });

                    return(RedirectToAction("Detalles", new { id = indiceOcupacionalComportamientoObservable.IdIndiceOcupacional }));
                }

                var indiceOcupacional = new IndiceOcupacional
                {
                    IdIndiceOcupacional = indiceOcupacionalComportamientoObservable.IdIndiceOcupacional,
                };

                await CargarComboComportamientosObservables(indiceOcupacional);

                InicializarMensaje(response.Message);
                //return PartialView("AdicionarComportamientosObservables", indiceOcupacionalComportamientoObservable);
                return(PartialView("AdicionarComportamientosObservables", indiceOcupacionalComportamientoObservable));
            }
            catch (Exception ex)
            {
                await GuardarLogService.SaveLogEntry(new LogEntryTranfer
                {
                    ApplicationName      = Convert.ToString(Aplicacion.WebAppTh),
                    Message              = "Creando un Indice ocupacional ",
                    ExceptionTrace       = ex,
                    LogCategoryParametre = Convert.ToString(LogCategoryParameter.Create),
                    LogLevelShortName    = Convert.ToString(LogLevelParameter.ERR),
                    UserName             = "******"
                });

                return(BadRequest());
            }
        }
        public async Task <IActionResult> ExperienciaLaboralRequerida(int id)
        {
            var indiceOcupacional = new IndiceOcupacional
            {
                IdIndiceOcupacional = id,
            };

            var ListaExperienciaLaboralRequerida = await apiServicio.Listar <ExperienciaLaboralRequeridaViewModel>(indiceOcupacional, new Uri(WebApp.BaseAddress), "api/ExperienciaLaboralRequeridas/ListarExperienciaLaboralRequeridaPorIndiceOcupacional");

            return(View(ListaExperienciaLaboralRequerida));
        }
        public async Task <IActionResult> ComportamientoObservable(int id)
        {
            var indiceOcupacional = new IndiceOcupacional
            {
                IdIndiceOcupacional = id,
            };

            var ListaEstudios = await apiServicio.Listar <ComportamientoObservableViewModel>(indiceOcupacional, new Uri(WebApp.BaseAddress), "api/ComportamientosObservables/ListarComportamientosObservablesPorIndiceOcupacional");

            return(View(ListaEstudios));
        }
        public async Task <IActionResult> ConocimientosAdicionales(int id)
        {
            var indiceOcupacional = new IndiceOcupacional
            {
                IdIndiceOcupacional = id,
            };

            var ListaConocimientosAdicionales = await apiServicio.Listar <ConocimientosAdicionalesViewModel>(indiceOcupacional, new Uri(WebApp.BaseAddress), "api/ConocimientosAdicionales/ListarConocimientosAdicionalesPorIndiceOcupacional");

            return(View(ListaConocimientosAdicionales));
        }
        public async Task <IActionResult> Estudios(int id)
        {
            var indiceOcupacional = new IndiceOcupacional
            {
                IdIndiceOcupacional = id,
            };

            var ListaEstudios = await apiServicio.Listar <EstudioViewModel>(indiceOcupacional, new Uri(WebApp.BaseAddress), "api/Estudios/ListarEstudiosPorIndiceOcupacional");

            return(View(ListaEstudios));
        }
        public async Task <IActionResult> ActividadesEsenciales(int id)
        {
            var indiceOcupacional = new IndiceOcupacional
            {
                IdIndiceOcupacional = id,
            };

            var ListaActividadesEsenciales = await apiServicio.Listar <ActividadesEsencialesViewModel>(indiceOcupacional, new Uri(WebApp.BaseAddress), "api/ActividadesEsenciales/ListarActividadesEsencialesPorIndiceOcupacional");

            return(View(ListaActividadesEsenciales));
        }
        public async Task <IActionResult> Detalle(int id)
        {
            var indiceOcupacional = new IndiceOcupacional
            {
                IdIndiceOcupacional = id,
            };

            var indiceOcupacionalDetalle = await apiServicio.ObtenerElementoAsync1 <IndiceOcupacionalViewModel>(indiceOcupacional, new Uri(WebApp.BaseAddress), "api/IndicesOcupacionales/InformacionBasicaIndiceOcupacional");

            return(View(indiceOcupacionalDetalle));
        }
        public async Task <Response> PostEstadoCivil([FromBody] IndiceOcupacional indiceOcupacional)
        {
            try
            {
                IndiceOcupacional IndiceOcupacional = new IndiceOcupacional();
                if (indiceOcupacional.IdEscalaGrados != 0)
                {
                    IndiceOcupacional = await db.IndiceOcupacional.Where(m => m.IdDependencia == indiceOcupacional.IdDependencia &&
                                                                         m.IdManualPuesto == indiceOcupacional.IdManualPuesto &&
                                                                         m.IdRolPuesto == indiceOcupacional.IdRolPuesto &&
                                                                         m.IdEscalaGrados == indiceOcupacional.IdEscalaGrados).FirstOrDefaultAsync();
                }
                else
                {
                    IndiceOcupacional = await db.IndiceOcupacional.SingleOrDefaultAsync(m => m.IdDependencia == indiceOcupacional.IdDependencia &&
                                                                                        m.IdManualPuesto == indiceOcupacional.IdManualPuesto &&
                                                                                        m.IdRolPuesto == indiceOcupacional.IdRolPuesto);
                }

                if (IndiceOcupacional == null)
                {
                    return(new Response
                    {
                        IsSuccess = false,
                        Message = Mensaje.RegistroNoEncontrado,
                    });
                }

                return(new Response
                {
                    IsSuccess = true,
                    Message = Mensaje.Satisfactorio,
                    Resultado = IndiceOcupacional,
                });
            }
            catch (Exception ex)
            {
                await GuardarLogService.SaveLogEntry(new LogEntryTranfer
                {
                    ApplicationName      = Convert.ToString(Aplicacion.SwTH),
                    ExceptionTrace       = ex.Message,
                    Message              = Mensaje.Excepcion,
                    LogCategoryParametre = Convert.ToString(LogCategoryParameter.Critical),
                    LogLevelShortName    = Convert.ToString(LogLevelParameter.ERR),
                    UserName             = "",
                });

                return(new Response
                {
                    IsSuccess = false,
                    Message = Mensaje.Error,
                });
            }
        }
 public async Task <List <IndiceOcupacional> > GetIndicesOcupacionales(IndiceOcupacional indiceOcupacional)
 {
     try
     {
         return(await db.IndiceOcupacional.Where(x => x.IdIndiceOcupacional == indiceOcupacional.IdIndiceOcupacional).Include(x => x.Dependencia).Include(x => x.ManualPuesto).Include(x => x.RolPuesto)
                .Include(x => x.EscalaGrados).ThenInclude(x => x.GrupoOcupacional).Include(x => x.EscalaGrados).ThenInclude(x => x.Remuneracion).ToListAsync());
     }
     catch (Exception ex)
     {
         return(new List <IndiceOcupacional>());
     }
 }
Ejemplo n.º 22
0
        public async Task <IActionResult> Evaluar(int idempleado)
        {
            try
            {
                var claim         = HttpContext.User.Identities.Where(x => x.NameClaimType == ClaimTypes.Name).FirstOrDefault();
                var NombreUsuario = claim.Claims.Where(c => c.Type == ClaimTypes.Name).FirstOrDefault().Value;

                var usuario = new ViewModelEvaluador
                {
                    IdEmpleado    = idempleado,
                    NombreUsuario = NombreUsuario
                };
                var lista = await apiServicio.ObtenerElementoAsync1 <ViewModelEvaluador>(usuario, new Uri(WebApp.BaseAddress)
                                                                                         , "api/EvaluacionDesempeno/Evaluar");

                var totalacti = lista.ListaActividad.Count();
                lista.totalactividades = totalacti;

                var indiceOcupacional = new IndiceOcupacional
                {
                    IdIndiceOcupacional = lista.IdIndiceOcupacional,
                };
                var ListaConocimientos = await apiServicio.Listar <AreaConocimientoViewModel>(indiceOcupacional, new Uri(WebApp.BaseAddress), "api/AreasConocimientos/ListarAreasConocimientosPorIndiceOcupacional");

                var valor = new VIewCompetencias
                {
                    IdIndiceOcupacional = lista.IdIndiceOcupacional,
                    CompetenciaTecnica  = true
                };
                var CompetenciasTecnicas = await apiServicio.Listar <ComportamientoObservableViewModel>(valor, new Uri(WebApp.BaseAddress), "api/ComportamientosObservables/ListarComportamientosObservablesPorIndiceOcupacionalEstado");

                var competenciasUniversales = new VIewCompetencias
                {
                    IdIndiceOcupacional = lista.IdIndiceOcupacional,
                    CompetenciaTecnica  = false
                };
                var CompetenciasUniversales = await apiServicio.Listar <ComportamientoObservableViewModel>(competenciasUniversales, new Uri(WebApp.BaseAddress), "api/ComportamientosObservables/ListarComportamientosObservablesPorIndiceOcupacionalEstado");

                lista.ListaConocimientos           = ListaConocimientos;
                lista.ListaCompetenciasTecnicas    = CompetenciasTecnicas;
                lista.ListaCompetenciasUniversales = CompetenciasUniversales;
                InicializarMensaje(null);
                ViewData["IdNivelConocimiento"]    = new SelectList(await apiServicio.Listar <NivelConocimiento>(new Uri(WebApp.BaseAddress), "api/NivelesConocimiento/ListarNivelesConocimiento"), "IdNivelConocimiento", "Nombre");
                ViewData["IdNivelDesarrollo"]      = new SelectList(await apiServicio.Listar <NivelDesarrollo>(new Uri(WebApp.BaseAddress), "api/NivelesDesarrollo/ListarNivelesDesarrollo"), "IdNivelDesarrollo", "Nombre");
                ViewData["IdFrecuenciaAplicacion"] = new SelectList(await apiServicio.Listar <FrecuenciaAplicacion>(new Uri(WebApp.BaseAddress), "api/FrecuenciaAplicaciones/ListarFrecuenciaAplicaciones"), "IdFrecuenciaAplicacion", "Nombre");
                return(View(lista));
            }
            catch (Exception ex)
            {
                return(BadRequest());
            }
        }
        private async Task <bool> CargarComboExperienciaLaboralRequerida(IndiceOcupacional indiceOcupacional)
        {
            var listaExperienciaLaboralRequerida = await apiServicio.Listar <ExperienciaLaboralRequerida>(indiceOcupacional, new Uri(WebApp.BaseAddress), "api/ExperienciaLaboralRequeridas/ListarExperienciaLaboralRequeridaNoAsignadasIndiceOcupacional");

            var resultado = false;

            if (listaExperienciaLaboralRequerida.Count != 0)
            {
                resultado = true;
            }

            return(resultado);
        }
        //public async Task<ActionResult> AdicionarCapacitaciones(string idIndiceOcupacional, string mensaje)

        //{
        //    var indiceconocimientoad = new IndiceOcupacionalCapacitaciones
        //    {

        //        IdIndiceOcupacional = Convert.ToInt32(idIndiceOcupacional),
        //    };

        //    var indiceOcupacional = new IndiceOcupacional
        //    {
        //        IdIndiceOcupacional = Convert.ToInt32(idIndiceOcupacional),
        //    };


        //    var resultado = await CargarComboCapacitaciones(indiceOcupacional);

        //    if (resultado)
        //    {
        //        InicializarMensaje(mensaje);
        //        return PartialView(indiceconocimientoad);
        //    }

        //    ViewData["Mensaje"] = Mensaje.NoExistenRegistrosPorAsignar;
        //    return PartialView("NoExisteElemento");

        //}

        //[HttpGet]
        //public async Task<ActionResult> AdicionarComportamientosObservables(string idIndiceOcupacional, string mensaje)

        //{

        //    var indiceOcupacional = new IndiceOcupacional
        //    {
        //        IdIndiceOcupacional = Convert.ToInt32(idIndiceOcupacional),
        //    };
        //    var indiceconocimientoad = new IndiceOcupacionalComportamientoObservableView
        //    {
        //        IdIndiceOcupacional = Convert.ToInt32(idIndiceOcupacional),
        //        ComportamientoObservables= await apiServicio.Listar<ComportamientoObservable>(indiceOcupacional,
        //                                                     new Uri(WebApp.BaseAddress),
        //                                                     "api/ComportamientosObservables/ListarComportamientosObservablesNoAsignadasIndiceOcupacional"),
        //    };

        //    if (indiceconocimientoad.ComportamientoObservables.Count!=0)
        //    {
        //        InicializarMensaje(mensaje);
        //        return PartialView(indiceconocimientoad);
        //    }

        //    ViewData["Mensaje"] = Mensaje.NoExistenRegistrosPorAsignar;
        //    return PartialView("NoExisteElemento");

        //}

        //public async Task<ActionResult> AdicionarConocimientosAdicionales(string idIndiceOcupacional, string mensaje)

        //{
        //    var indiceconocimientoad = new IndiceOcupacionalConocimientosAdicionales
        //    {

        //        IdIndiceOcupacional = Convert.ToInt32(idIndiceOcupacional),
        //    };

        //    var indiceOcupacional = new IndiceOcupacional
        //    {
        //        IdIndiceOcupacional = Convert.ToInt32(idIndiceOcupacional),
        //    };


        //    var resultado = await CargarComboConocimientosAdicionales(indiceOcupacional);

        //    if (resultado)
        //    {
        //        InicializarMensaje(mensaje);
        //        return PartialView(indiceconocimientoad);
        //    }

        //    ViewData["Mensaje"] = Mensaje.NoExistenRegistrosPorAsignar;
        //    return PartialView("NoExisteElemento");

        //}



        private async Task <bool> CargarComboEstudio(IndiceOcupacional indiceOcupacional)
        {
            var listaEstudio = await apiServicio.Listar <Estudio>(indiceOcupacional, new Uri(WebApp.BaseAddress), "api/Estudios/ListarEstudiosNoAsignadasIndiceOcupacional");

            var resultado = false;

            if (listaEstudio.Count != 0)
            {
                ViewData["IdEstudio"] = new SelectList(listaEstudio, "IdEstudio", "Nombre");
                resultado             = true;
            }

            return(resultado);
        }
Ejemplo n.º 25
0
        public async Task <Response> InsertarIndiceOcupacional([FromBody] IndiceOcupacional indiceOcupacional)
        {
            try
            {
                if (!ModelState.IsValid)
                {
                    return(new Response
                    {
                        IsSuccess = false,
                        Message = Mensaje.ModeloInvalido,
                    });
                }

                var respuesta = Existe(indiceOcupacional);
                if (!respuesta.IsSuccess)
                {
                    db.IndiceOcupacional.Add(indiceOcupacional);
                    await db.SaveChangesAsync();

                    return(new Response
                    {
                        IsSuccess = true,
                        Message = Mensaje.Satisfactorio
                    });
                }
                return(new Response
                {
                    IsSuccess = false,
                    Message = Mensaje.ExisteRegistro
                });
            }
            catch (Exception ex)
            {
                await GuardarLogService.SaveLogEntry(new LogEntryTranfer
                {
                    ApplicationName      = Convert.ToString(Aplicacion.SwTH),
                    ExceptionTrace       = ex,
                    Message              = Mensaje.Excepcion,
                    LogCategoryParametre = Convert.ToString(LogCategoryParameter.Critical),
                    LogLevelShortName    = Convert.ToString(LogLevelParameter.ERR),
                    UserName             = "",
                });

                return(new Response
                {
                    IsSuccess = false,
                    Message = Mensaje.Error,
                });
            }
        }
        private async Task <bool> CargarComboMision(IndiceOcupacional indiceOcupacional)
        {
            var listaMision = await apiServicio.Listar <Mision>(indiceOcupacional, new Uri(WebApp.BaseAddress), "api/Misiones/ListarMisionNoAsignadasIndiceOcupacional");

            var resultado = false;

            if (listaMision.Count != 0)
            {
                ViewData["IdMision"] = new SelectList(listaMision, "IdMision", "Nombre");
                resultado            = true;
            }

            return(resultado);
        }
        private async Task <bool> CargarComboRelacionesInternasExternas(IndiceOcupacional indiceOcupacional)
        {
            var listaRelacionesInternasExternas = await apiServicio.Listar <RelacionesInternasExternas>(indiceOcupacional, new Uri(WebApp.BaseAddress), "api/RelacionesInternasExternas/ListarRelacionesInternasExternasNoAsignadasIndiceOcupacional");

            var resultado = false;

            if (listaRelacionesInternasExternas.Count != 0)
            {
                ViewData["IdRelacionesInternasExternas"] = new SelectList(listaRelacionesInternasExternas, "IdRelacionesInternasExternas", "Nombre");
                resultado = true;
            }

            return(resultado);
        }
        private async Task <bool> CargarComboActividedesEsenciales(IndiceOcupacional indiceOcupacional)
        {
            var listaActividadesEsenciales = await apiServicio.Listar <ActividadesEsenciales>(indiceOcupacional, new Uri(WebApp.BaseAddress), "api/ActividadesEsenciales/ListarActividedesEsencialesNoAsignadasIndiceOcupacional");

            var resultado = false;

            if (listaActividadesEsenciales.Count != 0)
            {
                ViewData["IdActividadesEsenciales"] = new SelectList(listaActividadesEsenciales, "IdActividadesEsenciales", "Descripcion");
                resultado = true;
            }

            return(resultado);
        }
        private async Task <bool> CargarComboAreaConocimiento(IndiceOcupacional indiceOcupacional)
        {
            var listaAreasConocimientos = await apiServicio.Listar <AreaConocimiento>(indiceOcupacional, new Uri(WebApp.BaseAddress), "api/AreasConocimientos/ListarAreasConocimientosNoAsignadasIndiceOcupacional");

            var resultado = false;

            if (listaAreasConocimientos.Count != 0)
            {
                ViewData["IdAreaConocimiento"] = new SelectList(listaAreasConocimientos, "IdAreaConocimiento", "Descripcion");
                resultado = true;
            }

            return(resultado);
        }
        public async Task <ActionResult> NuevoActividadEsencial(int id)
        {
            var indiceOcupacional = new IndiceOcupacional
            {
                IdIndiceOcupacional = id,
            };
            var listaActividadesEsenciales = await apiServicio.Listar <ActividadesEsencialesViewModel>(indiceOcupacional, new Uri(WebApp.BaseAddress), "api/ActividadesEsenciales/ListarActividedesEsencialesNoAsignadasIndiceOcupacional");

            if (listaActividadesEsenciales.Count == 0)
            {
                return(RedirectToAction("ActividadesEsenciales", new { id }));
            }

            return(View(listaActividadesEsenciales));
        }