public string LeerCompetencias()
        {
            XML formato = new XML();

            Competencia          com    = new Competencia();
            CompetenciaOperacion comOp  = new CompetenciaOperacion(com);
            List <Competencia>   compes = comOp.Listar();

            return(formato.Serializar(compes));
        }
Example #2
0
        public void EliminarCompetencia()
        {
            WFBS.Business.Entities.Competencia a = new WFBS.Business.Entities.Competencia();

            a.ID_COMPETENCIA = 21;

            bool esperando             = true;
            CompetenciaOperacion comOp = new CompetenciaOperacion(a);
            bool actua = comOp.Delete();

            comOp = null;
            Assert.AreEqual(esperando, actua);
        }
 public bool EliminarCompetencia(string xml)
 {
     try
     {
         XML                  formato = new XML();
         Competencia          com     = formato.Deserializar <Competencia>(xml);
         CompetenciaOperacion comOp   = new CompetenciaOperacion(com);
         return(comOp.Delete());
     }
     catch (Exception ex)
     {
         Logger.log("No se pudo Desactivar la Competencia: " + ex.ToString());
         return(false);
     }
 }
 public string obtenerHabilidadesCompetencia(string competenciaxml)
 {
     try
     {
         XML                  formato = new XML();
         Competencia          com     = formato.Deserializar <Competencia>(competenciaxml);
         CompetenciaOperacion comOp   = new CompetenciaOperacion(com);
         return(formato.Serializar(comOp.ObtenerHabPorCom(com.ID_COMPETENCIA)));
     }
     catch (Exception ex)
     {
         Logger.log("No se pudo Crear la Competencia: " + ex.ToString());
         return(null);
     }
 }
 public string obtenerComptentenciasArea(string areaxml)
 {
     try
     {
         XML                  formato = new XML();
         Area                 ar      = formato.Deserializar <Area>(areaxml);
         Competencia          com     = new Competencia();
         CompetenciaOperacion comOp   = new CompetenciaOperacion(com);
         return(formato.Serializar <List <Competencia> >(comOp.competenciasArea(ar)));
     }
     catch (Exception ex)
     {
         Logger.log("No se pudo obtenet competencias por Área: " + ex.ToString());
         return(null);
     }
 }
Example #6
0
        public void crearCompetencia()
        {
            WFBS.Business.Entities.Competencia a = new WFBS.Business.Entities.Competencia();

            a.ID_COMPETENCIA        = 2;
            a.NOMBRE                = "Prueba 3";
            a.DESCRIPCION           = "Descripcion de prueba";
            a.SIGLA                 = "p3";
            a.OBSOLETA              = 0;
            a.NIVEL_OPTIMO_ESPERADO = 3;

            bool esperando             = true;
            CompetenciaOperacion comOp = new CompetenciaOperacion(a);
            bool actua = comOp.Create();

            comOp = null;
            Assert.AreEqual(esperando, actua);
        }
        private void cmbId_Competencia_Loaded(object sender, RoutedEventArgs e)
        {
            int                  select = 0, i = 0;
            Competencia          com          = new Competencia();
            CompetenciaOperacion comOp        = new CompetenciaOperacion(com);
            List <Competencia>   competencias = comOp.Listar();

            foreach (Competencia item in competencias)
            {
                if (item.ID_COMPETENCIA == id_comp)
                {
                    cmbId_Competencia.Items.Add(item.NOMBRE);
                    select = i;
                    i++;
                }
            }
            cmbId_Competencia.SelectedIndex = select;
            cmbId_Competencia.IsEnabled     = false;
        }
        public string competenciasPerfildeCargo(string perfildecargoxml)
        {
            try
            {
                XML                    formato   = new XML();
                PerfildeCargo          perfilC   = formato.Deserializar <PerfildeCargo>(perfildecargoxml);
                PerfildeCargoOperacion perfilCOp = new PerfildeCargoOperacion(perfilC);

                Competencia          c    = new Competencia();
                CompetenciaOperacion coOp = new CompetenciaOperacion(c);

                return(formato.Serializar <List <Competencia> >(coOp.competenciasPerfilC(perfilC.ID_PERFIL_DE_CARGO)));
            }
            catch (Exception ex)
            {
                Logger.log("No se pudo leer el perfil de cargo: " + ex.ToString());
                return(null);
            }
        }
        private void dgCompetencias_Loaded(object sender, RoutedEventArgs e)
        {
            Competencia          com   = new Competencia();
            CompetenciaOperacion comOp = new CompetenciaOperacion(com);

            WFBS.Presentation.ServiceWFBS.ServiceWFBSClient servicio = new WFBS.Presentation.ServiceWFBS.ServiceWFBSClient();
            XML formato = new XML();

            dgCompetencias.ItemsSource = formato.Deserializar <List <Competencia> >(servicio.LeerCompetencias());

            dgCompetencias.Columns[0].Visibility = Visibility.Collapsed;
            dgCompetencias.Columns[4].Visibility = Visibility.Collapsed;
            dgCompetencias.Columns[1].Header     = "Nombre";
            dgCompetencias.Columns[2].Header     = "Descripción";
            dgCompetencias.Columns[3].Header     = "Sigla";
            dgCompetencias.Columns[5].Header     = "Nivel Óptimo";
            dgCompetencias.Columns[6].Header     = "Pregunta Asociada";
            dgCompetencias.Columns[7].Header     = "Obsoleta";
        }
 public string LeerCompetencia(string xml)
 {
     try
     {
         XML                  formato = new XML();
         Competencia          com     = formato.Deserializar <Competencia>(xml);
         CompetenciaOperacion comOp   = new CompetenciaOperacion(com);
         //comOp.Read();
         if (comOp.Read())
         {
             return(formato.Serializar(com));
         }
         else
         {
             return(null);
         }
     }
     catch (Exception ex)
     {
         Logger.log("No se pudo Leer la Competencia: " + ex.ToString());
         return(null);
     }
 }
        private void btnIngresar_Click(object sender, RoutedEventArgs e)
        {
            Competencia          com          = new Competencia();
            CompetenciaOperacion comOp        = new CompetenciaOperacion(com);
            List <Competencia>   competencias = comOp.Listar();

            try
            {
                Habilidad hab = new Habilidad();
                if (txtNombre.Text.Length > 0 && txtNombre.Text.Trim() != "")
                {
                    foreach (Competencia c in competencias)
                    {
                        if (c.NOMBRE == (string)cmbId_Competencia.SelectedItem)
                        {
                            hab.ID_COMPETENCIA = Convert.ToInt32(c.ID_COMPETENCIA);
                            id_comp            = Convert.ToInt32(c.ID_COMPETENCIA);
                        }
                    }
                    hab.NOMBRE = txtNombre.Text;
                    #region Nivel
                    switch (cmbOrden.SelectedIndex)
                    {
                    case 0:
                        hab.ORDEN_ASIGNADO = 0;
                        break;

                    case 1:
                        hab.ORDEN_ASIGNADO = 1;
                        break;

                    case 2:
                        hab.ORDEN_ASIGNADO = 2;
                        break;

                    case 3:
                        hab.ORDEN_ASIGNADO = 3;
                        break;

                    case 4:
                        hab.ORDEN_ASIGNADO = 4;
                        break;

                    case 5:
                        hab.ORDEN_ASIGNADO = 5;
                        break;

                    default:
                        hab.ORDEN_ASIGNADO = 0;
                        break;
                    }
                    #endregion Nivel
                    hab.ALTERNATIVA_PREGUNTA = txtAlternativa.Text;

                    XML    formato = new XML();
                    string xml     = formato.Serializar(hab);
                    WFBS.Presentation.ServiceWFBS.ServiceWFBSClient servicio = new WFBS.Presentation.ServiceWFBS.ServiceWFBSClient();

                    if (servicio.CrearHabilidad(xml))
                    {
                        MessageBox.Show("Habilidad agregada correctamente", "Éxito!");
                        this.Limpiar();
                        NavigationService     navService = NavigationService.GetNavigationService(this);
                        MantenedorHabilidades nextPage   = new MantenedorHabilidades(Convert.ToInt32(hab.ID_COMPETENCIA));
                        navService.Navigate(nextPage);
                    }
                    else
                    {
                        MessageBox.Show("No se pudo agregar la Habilidad, verifique que los datos sean correctos", "Aviso");
                    }
                }
                else
                {
                    MessageBox.Show("El campo Descripción es obligatorio", "Aviso");
                }
            }
            catch (Exception)
            {
                MessageBox.Show("No se pudo agregar la Habilidad!", "Alerta");
            }
        }