Пример #1
0
        protected void grdMercadoSalarial_NeedDataSource(object sender, Telerik.Web.UI.GridNeedDataSourceEventArgs e)
        {
            TabuladoresNegocio nTabuladores = new TabuladoresNegocio();

            vObtieneTabuladorPuesto = nTabuladores.ObtienePuestosTabulador(ID_TABULADOR: vIdTabulador).Select(s => new E_TABULADOR_PUESTO
            {
                NO_RENGLON          = (int)s.NO_RENGLON,
                ID_TABULADOR_PUESTO = s.ID_TABULADOR_PUESTO,
                ID_PUESTO           = s.ID_PUESTO,
                MN_MINIMO           = s.MN_MINIMO,
                MN_MAXIMO           = s.MN_MAXIMO,
                NB_DEPARTAMENTO     = s.NB_DEPARTAMENTO,
                NB_PUESTO           = s.NB_PUESTO,
                NO_NIVEL            = s.NO_NIVEL,
                CL_ORIGEN           = s.CL_ORIGEN
            }).ToList();
            grdMercadoSalarial.DataSource = vObtieneTabuladorPuesto;

            GridGroupByField field = new GridGroupByField();

            field.FieldName    = "NO_NIVEL";
            field.HeaderText   = "Nivel";
            field.HeaderText   = "<strong>Nivel</strong>";
            field.FormatString = "<strong>{0}</strong>";
            GridGroupByExpression ex = new GridGroupByExpression();

            ex.GroupByFields.Add(field);
            ex.SelectFields.Add(field);
            grdMercadoSalarial.MasterTableView.GroupByExpressions.Add(ex);
        }
Пример #2
0
        protected void btnGuardar_Click(object sender, EventArgs e)
        {
            if (rbPorcentaje.Checked == true && txtMontoIncremento.Text != "" || rbMonto.Checked == true && txtMontoIncremento.Text != "")
            {
                if (rbPorcentaje.Checked == true)
                {
                    vTipoIncremento = "P";
                }
                else if (rbMonto.Checked == true)
                {
                    vTipoIncremento = "M";
                }
                vMontoIncremento = decimal.Parse(txtMontoIncremento.Text);

                TabuladoresNegocio nTabulador = new TabuladoresNegocio();
                E_RESULTADO        vResultado = nTabulador.InsertarActualizarTabuladorSueldo(vIdTabulador, vTipoIncremento, vMontoIncremento, vClUsuario, vNbPrograma);
                string             vMensaje   = vResultado.MENSAJE.Where(w => w.CL_IDIOMA.Equals(vClIdioma.ToString())).FirstOrDefault().DS_MENSAJE;
                if (vResultado.CL_TIPO_ERROR.Equals(E_TIPO_RESPUESTA_DB.SUCCESSFUL))
                {
                    UtilMensajes.MensajeResultadoDB(rwmMensaje, vMensaje, vResultado.CL_TIPO_ERROR, pCallBackFunction: "OnCloseUpdate");
                }
                else
                {
                    UtilMensajes.MensajeResultadoDB(rwmMensaje, vMensaje, vResultado.CL_TIPO_ERROR, pCallBackFunction: "");
                }
            }
            else
            {
                UtilMensajes.MensajeResultadoDB(rwmMensaje, "Ingrese una cantidad valida.", E_TIPO_RESPUESTA_DB.ERROR, pCallBackFunction: "");
            }
        }
Пример #3
0
        protected void Page_Load(object sender, EventArgs e)
        {
            vClUsuario  = ContextoUsuario.oUsuario.CL_USUARIO;
            vNbPrograma = ContextoUsuario.nbPrograma;

            if (!IsPostBack)
            {
                if (Request.QueryString["ID"] != null)
                {
                    vIdTabulador = int.Parse((Request.QueryString["ID"]));
                    TabuladoresNegocio nTabulador = new TabuladoresNegocio();
                    var vTabulador = nTabulador.ObtenerTabuladores(ID_TABULADOR: vIdTabulador).FirstOrDefault();
                    SeguridadProcesos();

                    txtClTabulador.InnerText = vTabulador.CL_TABULADOR;
                    txtDescripción.InnerText = vTabulador.DS_TABULADOR;
                    txtNbTabulador.InnerText = vTabulador.NB_TABULADOR;
                    txtVigencia.InnerText    = vTabulador.FE_VIGENCIA.ToString("dd/MM/yyyy");
                    txtFecha.InnerText       = vTabulador.FE_CREACION.ToString("dd/MM/yyyy");
                    txtPuestos.InnerText     = vTabulador.CL_TIPO_PUESTO;
                    if (vTabulador.CL_ESTADO == "CERRADO")
                    {
                        btnGuardarCerrar.Enabled         = false;
                        btnGuardar.Enabled               = false;
                        btnCopiarMercadoSalarial.Enabled = false;
                        btnAjuste.Enabled = false;
                    }
                }
            }
            vTabuladorPuesto = new List <E_TABULADOR_PUESTO>();
        }
Пример #4
0
        protected void CargarDatosEmpleado(string pIdsSeleccionados)
        {
            List <int> vSeleccionados = null;

            if (pIdsSeleccionados != null & pIdsSeleccionados != "")
            {
                vSeleccionados = JsonConvert.DeserializeObject <List <int> >(pIdsSeleccionados);
            }

            vSeleccionEmpleados = new List <E_SELECCIONADOS>();

            foreach (int item in vSeleccionados)
            {
                vSeleccionEmpleados.Add(new E_SELECCIONADOS {
                    ID_SELECCIONADO = item
                });
            }

            var      vXelements    = vSeleccionEmpleados.Select(x => new XElement("EMPLEADO", new XAttribute("ID_EMPLEADO", x.ID_SELECCIONADO)));
            XElement SELECCIONADOS = new XElement("EMPLEADOS", vXelements);

            TabuladoresNegocio nTabulador = new TabuladoresNegocio();
            E_RESULTADO        vResultado = nTabulador.ActualizaPlaneacionIncrementosEmpleado(ID_TABULADOR: vIdTabulador, XML_EMPLEADOS: SELECCIONADOS.ToString(), usuario: vClUsuario, programa: vNbPrograma);
            string             vMensaje   = vResultado.MENSAJE.Where(w => w.CL_IDIOMA.Equals(vClIdioma.ToString())).FirstOrDefault().DS_MENSAJE;

            UtilMensajes.MensajeResultadoDB(rwmMensaje, vMensaje, vResultado.CL_TIPO_ERROR, 400, 150, pCallBackFunction: "CloseWindow");

            Actualizar();
        }
        protected void CargarDatosArea(string pIdsSeleccionados)
        {
            List <int> vSeleccionados = null;

            if (pIdsSeleccionados != null & pIdsSeleccionados != "")
            {
                vSeleccionados = JsonConvert.DeserializeObject <List <int> >(pIdsSeleccionados);
            }
            vSeleccionAreas = new List <E_SELECCIONADOS>();
            foreach (int item in vSeleccionados)
            {
                vSeleccionAreas.Add(new E_SELECCIONADOS {
                    ID_SELECCIONADO = item
                });
            }
            var vXelements = vSeleccionAreas.Select(x =>
                                                    new XElement("AREA",
                                                                 new XAttribute("CL_TIPO_PUESTO", vClTipoPuesto),
                                                                 new XAttribute("ID_AREA", x.ID_SELECCIONADO)
                                                                 ));
            XElement SELECCIONADOS =
                new XElement("AREAS", vXelements
                             );

            TabuladoresNegocio nTabulador = new TabuladoresNegocio();
            E_RESULTADO        vResultado = nTabulador.InsertaActualizaTabuladorEmpleado(pClTipoOperacion: E_TIPO_OPERACION_DB.I.ToString(), ID_TABULADOR: vIdTabulador, XML_SELECCIONADOS: SELECCIONADOS.ToString(), usuario: vClUsuario, programa: vNbPrograma);
            string             vMensaje   = vResultado.MENSAJE.Where(w => w.CL_IDIOMA.Equals(vClIdioma.ToString())).FirstOrDefault().DS_MENSAJE;

            //UtilMensajes.MensajeResultadoDB(rwmMensaje, vMensaje, vResultado.CL_TIPO_ERROR, 400, 150, pCallBackFunction: "onCloseWindowE");
            grdEmpleadosSeleccionados.Rebind();
        }
Пример #6
0
        protected void btnGuardarCopiar_Click(object sender, EventArgs e)
        {
            E_TABULADOR vTabulador = new E_TABULADOR();

            vTabulador.ID_TABULADOR           = vIdTabulador;
            vTabulador.CL_TABULADOR           = txtVersionTabuladorCopiar.Text;
            vTabulador.NB_TABULADOR           = txtNombreTabulador.Text;
            vTabulador.DS_TABULADOR           = txtDescripcion.Text;
            vTabulador.FE_CREACION            = rdpCreacion.SelectedDate ?? DateTime.Now;
            vTabulador.FE_VIGENCIA            = rdpVigencia.SelectedDate ?? DateTime.Now;
            vTabulador.CL_ESTADO              = "ABIERTO";
            vTabulador.CL_SUELDO_COMPARACION  = vTabula.CL_SUELDO_COMPARACION;
            vTabulador.CL_TIPO_PUESTO         = vTabula.CL_TIPO_PUESTO;
            vTabulador.ID_CUARTIL_INCREMENTO  = vTabula.ID_CUARTIL_INCREMENTO;
            vTabulador.ID_CUARTIL_INFLACIONAL = vTabula.ID_CUARTIL_INFLACIONAL;
            vTabulador.ID_CUARTIL_MERCADO     = vTabula.ID_CUARTIL_MERCADO;
            vTabulador.NO_CATEGORIAS          = vTabula.NO_CATEGORIAS;
            vTabulador.NO_NIVELES             = vTabula.NO_NIVELES;
            vTabulador.PR_INFLACION           = vTabula.PR_INFLACION;
            vTabulador.PR_PROGRESION          = vTabula.PR_PROGRESION;
            vTabulador.XML_VARIACION          = vTabula.XML_VARIACION;

            TabuladoresNegocio nTabulador = new TabuladoresNegocio();
            E_RESULTADO        vResultado = nTabulador.InsertaTabuladorCopia(usuario: vClUsuario, programa: vNbPrograma, pClTipoOperacion: "I", vTabulador: vTabulador);
            string             vMensaje   = vResultado.MENSAJE.Where(w => w.CL_IDIOMA.Equals(vClIdioma.ToString())).FirstOrDefault().DS_MENSAJE;

            UtilMensajes.MensajeResultadoDB(rwmMensaje, vMensaje, vResultado.CL_TIPO_ERROR, pCallBackFunction: "closeWindow");
        }
        protected void grdNiveles_NeedDataSource(object sender, GridNeedDataSourceEventArgs e)
        {
            TabuladoresNegocio nTabulador = new TabuladoresNegocio();
            var vTabuladorNivel           = nTabulador.ObtieneTabuladorNivel(ID_TABULADOR: vIdTabulador);

            grdNiveles.DataSource = vTabuladorNivel;
        }
        protected void btnEliminarCompetencias_Click(object sender, EventArgs e)
        {
            E_RESULTADO respuesta = new E_RESULTADO();

            if (grdCompetenciasSeleccionadas.Items.Count != 0)
            {
                XElement vXmlCompetencias = new XElement("COMPETENCIAS");

                if (grdCompetenciasSeleccionadas.SelectedItems != null)
                {
                    foreach (GridDataItem item in grdCompetenciasSeleccionadas.SelectedItems)
                    {
                        vXmlCompetencias.Add(new XElement("COMPETENCIA",
                                                          new XAttribute("ID_TABULADOR_FACTOR", item.GetDataKeyValue("ID_TABULADOR_FACTOR").ToString())));
                    }


                    TabuladoresNegocio nTabulador = new TabuladoresNegocio();
                    E_RESULTADO        vResultado = nTabulador.EliminaTabuladorFactor(vClUsuario, vNbPrograma, vXmlCompetencias.ToString());
                    string             vMensaje   = vResultado.MENSAJE.Where(w => w.CL_IDIOMA.Equals(vClIdioma.ToString())).FirstOrDefault().DS_MENSAJE;
                    UtilMensajes.MensajeResultadoDB(rwmMensaje, vMensaje, vResultado.CL_TIPO_ERROR, pCallBackFunction: "onCloseWindowC");
                }
                else
                {
                    UtilMensajes.MensajeResultadoDB(rwmMensaje, "Debes seleccionar al menos un elemento para eliminar", respuesta.CL_TIPO_ERROR, pCallBackFunction: "");
                }
            }
            else
            {
                UtilMensajes.MensajeResultadoDB(rwmMensaje, "No existen elementos para eliminar", respuesta.CL_TIPO_ERROR, pCallBackFunction: "");
            }
        }
        protected void GuardarConfiguracion()
        {
            E_TABULADOR vTabulador = new E_TABULADOR();

            vTabulador.ID_TABULADOR           = vIdTabulador;
            vTabulador.CL_TABULADOR           = txtClTabulador.InnerText;
            vTabulador.DS_TABULADOR           = txtDescripción.InnerText;
            vTabulador.NO_NIVELES             = byte.Parse(rntNivelesACrear.Text);
            vTabulador.NO_CATEGORIAS          = byte.Parse(rntNumeroCategorias.Text);
            vTabulador.PR_PROGRESION          = decimal.Parse(rntProgresion.Text);
            vTabulador.PR_INFLACION           = decimal.Parse(rntPorcentaje.Text);
            vTabulador.ID_CUARTIL_INFLACIONAL = int.Parse(cmbCuartilInflacional.SelectedValue);
            vTabulador.ID_CUARTIL_INCREMENTO  = int.Parse(cmbCuartilIncremento.SelectedValue);
            vTabulador.ID_CUARTIL_MERCADO     = int.Parse(cmbNivelMercado.SelectedValue ?? "0");

            TabuladoresNegocio nTabulador = new TabuladoresNegocio();
            E_RESULTADO        vResultado = nTabulador.InsertaActualizaTabulador(usuario: vClUsuario, programa: vNbPrograma, pClTipoOperacion: vTipoTransaccion.ToString(), vTabulador: vTabulador);
            string             vMensaje   = vResultado.MENSAJE.Where(w => w.CL_IDIOMA.Equals(vClIdioma.ToString())).FirstOrDefault().DS_MENSAJE;

            if (vResultado.CL_TIPO_ERROR == E_TIPO_RESPUESTA_DB.SUCCESSFUL)
            {
                UtilMensajes.MensajeResultadoDB(rwmMensaje, vMensaje, vResultado.CL_TIPO_ERROR, pCallBackFunction: "");
                lblAdvertencia.Visible           = false;
                rtsConfiguracion.Tabs[4].Enabled = true;
                rpvNiveles.Selected = true;
                rtsConfiguracion.Tabs[4].Selected = true;
                vNivelesTabulador = int.Parse(rntNivelesACrear.Text);
                grdNiveles.Rebind();
                //validacionNiveles(vResultado, vMensaje);
            }
            else
            {
                UtilMensajes.MensajeResultadoDB(rwmMensaje, vMensaje, vResultado.CL_TIPO_ERROR);
            }
        }
Пример #10
0
        protected void Page_Load(object sender, EventArgs e)
        {
            vClUsuario  = ContextoUsuario.oUsuario.CL_USUARIO;
            vNbPrograma = ContextoUsuario.nbPrograma;

            if (!IsPostBack)
            {
                if (Request.QueryString["ID"] != null)
                {
                    vIdTabulador = int.Parse((Request.QueryString["ID"]));
                    TabuladoresNegocio nTabulador = new TabuladoresNegocio();

                    var      vTabulador    = nTabulador.ObtenerTabuladores(ID_TABULADOR: vIdTabulador).FirstOrDefault();
                    XElement vXlmCuartiles = XElement.Parse(vTabulador.XML_VW_CUARTILES);
                    vCuartilesTabulador = vXlmCuartiles.Elements("ITEM").Select(x => new E_CUARTILES
                    {
                        ID_CUARTIL = UtilXML.ValorAtributo <int>(x.Attribute("NB_VALOR")),
                        NB_CUARTIL = UtilXML.ValorAtributo <string>(x.Attribute("NB_TEXTO")),
                    }).ToList();
                    SeguridadProcesos();

                    cmbCuartil.DataSource     = vCuartilesTabulador;
                    cmbCuartil.DataTextField  = "NB_CUARTIL";
                    cmbCuartil.DataValueField = "ID_CUARTIL".ToString();
                    cmbCuartil.DataBind();
                    //txtClTabulador.Text = vTabulador.CL_TABULADOR;
                    //txtNbTabulador.Text = vTabulador.DS_TABULADOR;
                    //rdpCreacion.SelectedDate = vTabulador.FE_CREACION;
                    //rdpVigencia.SelectedDate = vTabulador.FE_VIGENCIA;
                    if (vTabulador.CL_ESTADO == "CERRADO")
                    {
                        btnGuardarCerrar.Enabled = false;
                        //  btnGuardar.Enabled = false;
                        // btnConfiguracion.Enabled = false;
                        btnCopiarTabulador.Enabled = false;
                        // btnVerNiveles.Enabled = false;
                        //btnRecalcular.Enabled = false;
                    }
                    txtNbTabulador.InnerText     = vTabulador.NB_TABULADOR;
                    txtClTabulador.InnerText     = vTabulador.CL_TABULADOR;
                    txtDescripción.InnerText     = vTabulador.DS_TABULADOR;
                    txtVigencia.InnerText        = vTabulador.FE_VIGENCIA.ToString("dd/MM/yyyy");
                    txtFecha.InnerText           = vTabulador.FE_CREACION.ToString("dd/MM/yyyy");
                    txtPuestos.InnerText         = vTabulador.CL_TIPO_PUESTO;
                    txtNoCategorias.Text         = vTabulador.NO_CATEGORIAS.ToString();
                    vPrInflacional               = vTabulador.PR_INFLACION;
                    txtPorcentajeIncremento.Text = vTabulador.PR_INFLACION.ToString();
                    XElement vXlmCuartil = XElement.Parse(vTabulador.XML_CUARTILES);
                    foreach (XElement vXmlCuartilSeleccionado in vXlmCuartil.Elements("ITEM"))
                    {
                        if ((UtilXML.ValorAtributo <int>(vXmlCuartilSeleccionado.Attribute("FG_SELECCIONADO_INFLACIONAL")).Equals(1)))
                        {
                            cmbCuartil.SelectedValue = UtilXML.ValorAtributo <string>(vXmlCuartilSeleccionado.Attribute("ID_CUARTIL"));
                        }
                    }

                    Actualizar(null);
                }
            }
        }
Пример #11
0
        protected void Page_Load(object sender, EventArgs e)
        {
            vClUsuario  = ContextoUsuario.oUsuario.CL_USUARIO;
            vNbPrograma = ContextoUsuario.nbPrograma;

            if (!IsPostBack)
            {
                vIdTabulador = int.Parse((Request.QueryString["IDtabulador"]));

                if (Request.QueryString["IDFactor"] != null)
                {
                    vIdCompetencia = int.Parse((Request.QueryString["IDFactor"]));
                    TabuladoresNegocio nTabuladorCompetencia = new TabuladoresNegocio();
                    var vTavuladorCompetencia = nTabuladorCompetencia.ObtenieneCompetenciasTabulador(vIdCompetencia).FirstOrDefault();
                    txtNombre.Text           = vTavuladorCompetencia.NB_COMPETENCIA;
                    txtDescripccion.Text     = vTavuladorCompetencia.DS_COMPETENCIA;
                    vIdTabulador             = vTavuladorCompetencia.ID_TABULADOR;
                    radEditorPuesto0.Content = vTavuladorCompetencia.DS_NIVEL_COMPETENCIA_PUESTO_N0;
                    radEditorPuesto1.Content = vTavuladorCompetencia.DS_NIVEL_COMPETENCIA_PUESTO_N1;
                    radEditorPuesto2.Content = vTavuladorCompetencia.DS_NIVEL_COMPETENCIA_PUESTO_N2;
                    radEditorPuesto3.Content = vTavuladorCompetencia.DS_NIVEL_COMPETENCIA_PUESTO_N3;
                    radEditorPuesto4.Content = vTavuladorCompetencia.DS_NIVEL_COMPETENCIA_PUESTO_N4;
                    radEditorPuesto5.Content = vTavuladorCompetencia.DS_NIVEL_COMPETENCIA_PUESTO_N5;
                }
                else
                {
                    radEditorPuesto0.Content = "Este valor no aplica para el adecuado desempeño del puesto.";
                    radEditorPuesto1.Content = "El desempeño del puesto demanda solamente lo mínimo para aplicar este valor, pudiendo hacerlo bajo asistencia o supervisión. Los resultados de su trabajo se verán poco afectados por este valor.";
                    radEditorPuesto2.Content = "El puesto requiere de una aplicación regular de este valor, los resultados de su trabajo se facilitarían con este, sin embargo pudieran lograrse resultados con el adecuado desarrollo de otras competencias.";
                    radEditorPuesto3.Content = "El puesto requiere de un dominio ligeramente por encima del promedio de la competencia, los resultados de su trabajo dependerán frecuentemente del adecuado desarrollo de esta capacidad .";
                    radEditorPuesto4.Content = "El puesto requiere de una aplicación alta del valor, los resultados de su trabajo dependerán de manera importante de la aplicación de este.";
                    radEditorPuesto5.Content = "Requiere una aplicación superior y profunda de este valor. Los resultados de su trabajo dependen directamente del desarrollo de esta capacidad.";
                }
            }
        }
Пример #12
0
        protected void rgdMercadoSalarial_NeedDataSource(object sender, GridNeedDataSourceEventArgs e)
        {
            TabuladoresNegocio nTabuladores = new TabuladoresNegocio();
            var vTabuladorMercado           = nTabuladores.ObtienePuestosTabulador(ID_TABULADOR: vIdTabulador);

            rgdMercadoSalarial.DataSource = vTabuladorMercado;
        }
 protected void CargarDatos(int?pIdTabulador)
 {
     if (Request.QueryString["ID"] != null)
     {
         TabuladoresNegocio nTabulador = new TabuladoresNegocio();
         var vTavulador = nTabulador.ObtenerTabuladores(pIdTabulador).FirstOrDefault();
         txtVersionTabulador.Text = vTavulador.CL_TABULADOR;
         txtNombreTabulador.Text  = vTavulador.NB_TABULADOR;
         txtDescripcion.Text      = vTavulador.DS_TABULADOR;
         rdpCreacion.SelectedDate = vTavulador.FE_CREACION;
         rdpVigencia.SelectedDate = vTavulador.FE_VIGENCIA;
         if (vTavulador.CL_TIPO_PUESTO == "DIRECTO")
         {
             btDirectos.Checked = true;
             btAmbos.Checked    = false;
         }
         if (vTavulador.CL_TIPO_PUESTO == "INDIRECTO")
         {
             btIndirectos.Checked = true;
             btAmbos.Checked      = false;
         }
         if (vTavulador.CL_TIPO_PUESTO == "AMBOS")
         {
             btAmbos.Checked = true;
         }
     }
 }
Пример #14
0
        protected void btnGuardar_Click(object sender, EventArgs e)
        {
            int vIdTabuladorNivel = 0;

            vTabuladorNivel = new List <E_NIVELES>();
            foreach (GridDataItem item in grdNiveles.MasterTableView.Items)
            {
                vIdTabuladorNivel = (int.Parse(item.GetDataKeyValue("ID_TABULADOR_NIVEL").ToString()));
                RadTextBox        vClNivel    = (RadTextBox)item.FindControl("txtClNivel");
                RadTextBox        vNbNivel    = (RadTextBox)item.FindControl("txtNbNivel");
                RadNumericTextBox vOrden      = (RadNumericTextBox)item.FindControl("txnOrden");
                RadNumericTextBox vProgresion = (RadNumericTextBox)item.FindControl("txnProgresion");

                vTabuladorNivel.Add(new E_NIVELES {
                    ID_TABULADOR_NIVEL = vIdTabuladorNivel, CL_TABULADOR_NIVEL = vClNivel.Text, NB_TABULADOR_NIVEL = vNbNivel.Text, NO_ORDEN = int.Parse(vOrden.Text), PR_PROGRESION = decimal.Parse(vProgresion.Text)
                });
            }

            var dups = vTabuladorNivel.GroupBy(x => x.NO_ORDEN).Where(x => x.Count() > 1).Select(x => x.Key).ToList();

            if (dups.Count == 0)
            {
                TabuladoresNegocio nTabulador = new TabuladoresNegocio();
                var vTabuladorProgresion      = nTabulador.ObtieneTabuladorNivel(ID_TABULADOR: vIdTabulador).ToList();

                var vPrTavulador  = vTabuladorNivel.Select(s => s.PR_PROGRESION).ToList();
                var vPrProgresion = vTabuladorProgresion.Select(s => s.PR_PROGRESION).ToList();

                if (vPrTavulador.SequenceEqual(vPrProgresion))
                {
                    vCL_GUARDAR = "GUARDAR";
                }
                else
                {
                    vCL_GUARDAR = "PR_GUARDAR";
                }

                var vXelements = vTabuladorNivel.Select(x =>
                                                        new XElement("NIVEL",
                                                                     new XAttribute("ID_TABULADOR_NIVEL", x.ID_TABULADOR_NIVEL),
                                                                     new XAttribute("CL_TABULADOR_NIVEL", x.CL_TABULADOR_NIVEL),
                                                                     new XAttribute("NB_TABULADOR_NIVEL", x.NB_TABULADOR_NIVEL),
                                                                     new XAttribute("NO_ORDEN", x.NO_ORDEN),
                                                                     new XAttribute("PR_PROGRESION", x.PR_PROGRESION)
                                                                     ));
                XElement TABULADORNIVEL =
                    new XElement("NIVELES", vXelements
                                 );

                E_RESULTADO vResultado = nTabulador.ActualizaTabuladorNivel(vIdTabulador, TABULADORNIVEL.ToString(), vClUsuario, vNbPrograma);
                string      vMensaje   = vResultado.MENSAJE.Where(w => w.CL_IDIOMA.Equals(vClIdioma.ToString())).FirstOrDefault().DS_MENSAJE;
                UtilMensajes.MensajeResultadoDB(rwmMensaje, vMensaje, vResultado.CL_TIPO_ERROR, 400, 150, pCallBackFunction: "closeWindow");
            }

            else
            {
                UtilMensajes.MensajeResultadoDB(rwmMensaje, "No se pueden repetir valores en el número de orden.", E_TIPO_RESPUESTA_DB.ERROR);
            }
        }
        protected void Page_Load(object sender, EventArgs e)
        {
            vClUsuario  = ContextoUsuario.oUsuario.CL_USUARIO;
            vNbPrograma = ContextoUsuario.nbPrograma;

            if (!IsPostBack)
            {
                TabuladoresNegocio             nTabuladores = new TabuladoresNegocio();
                SPE_OBTIENE_TABULADORES_Result vCuartiles   = nTabuladores.ObtenerTabuladores().FirstOrDefault();
                XElement vXlmCuartiles       = XElement.Parse(vCuartiles.XML_VW_CUARTILES);
                var      vCuartilesTabulador = vXlmCuartiles.Elements("ITEM").Select(x => new E_CUARTILES
                {
                    ID_CUARTIL = UtilXML.ValorAtributo <int>(x.Attribute("NB_VALOR")),
                    NB_CUARTIL = UtilXML.ValorAtributo <string>(x.Attribute("NB_TEXTO")),
                }).ToList();



                if (Request.QueryString["ID"] != null)
                {
                    vIdTabulador = int.Parse((Request.QueryString["ID"]));
                    TabuladoresNegocio nTabulador = new TabuladoresNegocio();
                    var vTabulador = nTabulador.ObtenerTabuladores(ID_TABULADOR: vIdTabulador).FirstOrDefault();
                    txtClaveTabulador.InnerText = vTabulador.CL_TABULADOR;
                    txtDescripción.InnerText    = vTabulador.DS_TABULADOR;
                    txtVigencia.InnerText       = vTabulador.FE_VIGENCIA.ToString("dd/MM/yyyy");
                    txtFecha.InnerText          = vTabulador.FE_VIGENCIA.ToString("dd/MM/yyyy");
                    txtPuestos.InnerText        = vTabulador.CL_TIPO_PUESTO;

                    vPrInflacional = vTabulador.PR_INFLACION;
                    if (vTabulador.XML_VARIACION != null)
                    {
                        XElement vXlmVariacion = XElement.Parse(vTabulador.XML_VARIACION);
                        foreach (XElement vXmlVaria in vXlmVariacion.Elements("Rango"))
                        {
                            if ((UtilXML.ValorAtributo <string>(vXmlVaria.Attribute("COLOR")).Equals("green")))
                            {
                                vRangoVerde = UtilXML.ValorAtributo <int>(vXmlVaria.Attribute("RANGO_SUPERIOR"));
                            }
                        }
                        foreach (XElement vXmlVaria in vXlmVariacion.Elements("Rango"))
                        {
                            if ((UtilXML.ValorAtributo <string>(vXmlVaria.Attribute("COLOR")).Equals("yellow")))
                            {
                                vRangoAmarillo = UtilXML.ValorAtributo <int>(vXmlVaria.Attribute("RANGO_SUPERIOR"));
                            }
                        }
                    }
                    XElement vXlmCuartil = XElement.Parse(vTabulador.XML_CUARTILES);
                    foreach (XElement vXmlCuartilSeleccionado in vXlmCuartil.Elements("ITEM"))
                    {
                        if ((UtilXML.ValorAtributo <int>(vXmlCuartilSeleccionado.Attribute("FG_SELECCIONADO_INFLACIONAL")).Equals(1)))
                        {
                            vCuartilInflacional = UtilXML.ValorAtributo <int>(vXmlCuartilSeleccionado.Attribute("ID_CUARTIL"));
                        }
                    }
                }
            }
        }
Пример #16
0
        protected void btnAjuste_Click(object sender, EventArgs e)
        {
            TabuladoresNegocio nTabuladores = new TabuladoresNegocio();

            grdMercadoSalarial.DataSource = nTabuladores.ObtieneDescriptivosPuestosTabulador(ID_TABULADOR: vIdTabulador);
            grdMercadoSalarial.Rebind();
            VerificarMinimos();
        }
Пример #17
0
        public void MercadoSalarial()
        {
            TabuladoresNegocio nTabulador = new TabuladoresNegocio();
            E_RESULTADO        vResultado = nTabulador.ActualizaMercadoTabuladorNivel(vIdTabulador, vClUsuario, vNbPrograma);
            string             vMensaje   = vResultado.MENSAJE.Where(w => w.CL_IDIOMA.Equals(vClIdioma.ToString())).FirstOrDefault().DS_MENSAJE;

            UtilMensajes.MensajeResultadoDB(rwmMensaje, vMensaje, vResultado.CL_TIPO_ERROR, pCallBackFunction: "OnCloseWindow");
            Actualizar("RECALCULAR");
        }
        protected void Page_Load(object sender, EventArgs e)
        {
            if (!IsPostBack)
            {
                if (Request.QueryString["ID"] != null)
                {
                    vIdTabulador = int.Parse((Request.QueryString["ID"]));
                    TabuladoresNegocio nTabulador = new TabuladoresNegocio();
                    var vTabulador = nTabulador.ObtenerTabuladores(ID_TABULADOR: vIdTabulador).FirstOrDefault();
                    txtClaveTabulador.InnerText = vTabulador.CL_TABULADOR;
                    txtDescripción.InnerText    = vTabulador.DS_TABULADOR;
                    txtNbTabulador.InnerText    = vTabulador.NB_TABULADOR;
                    txtVigencia.InnerText       = vTabulador.FE_VIGENCIA.ToString("dd/MM/yyyy");
                    txtFecha.InnerText          = vTabulador.FE_CREACION.ToString("dd/MM/yyyy");
                    txtPuestos.InnerText        = vTabulador.CL_TIPO_PUESTO;

                    vPrInflacional = vTabulador.PR_INFLACION;
                    if (vTabulador.XML_VARIACION != null)
                    {
                        XElement vXlmVariacion = XElement.Parse(vTabulador.XML_VARIACION);
                        foreach (XElement vXmlVaria in vXlmVariacion.Elements("Rango"))
                        {
                            if ((UtilXML.ValorAtributo <string>(vXmlVaria.Attribute("COLOR")).Equals("green")))
                            {
                                vRangoVerde = UtilXML.ValorAtributo <int>(vXmlVaria.Attribute("RANGO_SUPERIOR"));
                            }
                        }
                        foreach (XElement vXmlVaria in vXlmVariacion.Elements("Rango"))
                        {
                            if ((UtilXML.ValorAtributo <string>(vXmlVaria.Attribute("COLOR")).Equals("yellow")))
                            {
                                vRangoAmarillo = UtilXML.ValorAtributo <int>(vXmlVaria.Attribute("RANGO_SUPERIOR"));
                            }
                        }
                    }

                    if (Request.QueryString["pNivelMercado"] != null)
                    {
                        vCuartilComparativo = int.Parse(Request.QueryString["pNivelMercado"].ToString());
                    }

                    vLstEmpleados = new List <E_EMPLEADOS_GRAFICAS>();
                    vLstEmpleadosSeleccionados = new List <E_EMPLEADOS_GRAFICAS>();
                    vListaTabuladorSueldos     = new List <E_PLANEACION_INCREMENTOS>();
                    ObtenerPlaneacionIncrementos();
                    if (ContextoTabuladores.oLstTabuladorAnalisis != null)
                    {
                        CargarDatosTabuladores(ContextoTabuladores.oLstTabuladorAnalisis.Where(w => w.ID_TABULADOR == vIdTabulador).FirstOrDefault().vLstEmpleadosTabulador);
                    }
                    if (ContextoTabuladores.oLstEmpleadoAnalisis != null)
                    {
                        CargarDatosEmpleados(ContextoTabuladores.oLstEmpleadoAnalisis.Where(w => w.ID_TABULADOR == vIdTabulador).FirstOrDefault().vLstEmpleadosTabulador);
                    }
                }
            }
        }
Пример #19
0
        public void GuardarTabuladorMaestro(bool pFgCerrarVentana)
        {
            int vIdTabuladorNivel = 0;
            int vCategoria        = 0;
            int vNoNivel          = 0;

            vTabuladorMaestro = new List <E_TABULADOR_MAESTRO>();
            foreach (GridDataItem item in grdTabuladorMaestro.MasterTableView.Items)
            {
                vIdTabuladorNivel = (int.Parse(item.GetDataKeyValue("ID_TABULADOR_NIVEL").ToString()));
                vCategoria        = (int.Parse(item.GetDataKeyValue("NO_CATEGORIA").ToString()));
                vNoNivel          = (int.Parse(item.GetDataKeyValue("NO_NIVEL").ToString()));
                RadNumericTextBox vMinimo         = (RadNumericTextBox)item.FindControl("txnMinimo");
                RadNumericTextBox vCuartilPrimero = (RadNumericTextBox)item.FindControl("txnCuartilPrimero");
                RadNumericTextBox vCuartilMedio   = (RadNumericTextBox)item.FindControl("txnCuartilMedio");
                RadNumericTextBox vCuartilSegundo = (RadNumericTextBox)item.FindControl("txnCuartilSegundo");
                RadNumericTextBox vMaximo         = (RadNumericTextBox)item.FindControl("txnMaximo");

                vTabuladorMaestro.Add(new E_TABULADOR_MAESTRO
                {
                    ID_TABULADOR_NIVEL = vIdTabuladorNivel,
                    NO_CATEGORIA       = vCategoria,
                    NO_NIVEL           = vNoNivel,
                    MN_MINIMO          = decimal.Parse(vMinimo.Text),
                    MN_PRIMER_CUARTIL  = decimal.Parse(vCuartilPrimero.Text),
                    MN_MEDIO           = decimal.Parse(vCuartilMedio.Text),
                    MN_SEGUNDO_CUARTIL = decimal.Parse(vCuartilSegundo.Text),
                    MN_MAXIMO          = decimal.Parse(vMaximo.Text),
                });
            }
            var vXelements = vTabuladorMaestro.Select(x =>
                                                      new XElement("MAESTRO",
                                                                   new XAttribute("ID_TABULADOR_NIVEL", x.ID_TABULADOR_NIVEL),
                                                                   new XAttribute("NO_NIVEL", x.NO_NIVEL),
                                                                   new XAttribute("SECUENCIA", x.NO_CATEGORIA),
                                                                   new XAttribute("MN_MINIMO", x.MN_MINIMO),
                                                                   new XAttribute("MN_PRIMER_CUARTIL", x.MN_PRIMER_CUARTIL),
                                                                   new XAttribute("MN_CUARTIL_MEDIO", x.MN_MEDIO),
                                                                   new XAttribute("MN_SEGUNDO_CUARTIL", x.MN_SEGUNDO_CUARTIL),
                                                                   new XAttribute("MN_MAXIMO", x.MN_MAXIMO)
                                                                   ));
            XElement TABULADORMAESTRO =
                new XElement("MAESTROS", vXelements
                             );

            TabuladoresNegocio nTabulador = new TabuladoresNegocio();
            E_RESULTADO        vResultado = nTabulador.InsertaActualizaTabuladorMaestro(vIdTabulador, TABULADORMAESTRO.ToString(), vClUsuario, vNbPrograma);
            string             vMensaje   = vResultado.MENSAJE.Where(w => w.CL_IDIOMA.Equals(vClIdioma.ToString())).FirstOrDefault().DS_MENSAJE;

            if (vResultado.CL_TIPO_ERROR.Equals(E_TIPO_RESPUESTA_DB.SUCCESSFUL))
            {
                bool   vCerrarVentana    = pFgCerrarVentana;
                string vCallBackFunction = vCerrarVentana ? "closeWindow" : null;
                UtilMensajes.MensajeResultadoDB(rwmMensaje, vMensaje, vResultado.CL_TIPO_ERROR, pCallBackFunction: vCallBackFunction);
            }
        }
Пример #20
0
        private void CopiarTabuladorMaestro(int pIdTabulador)
        {
            TabuladoresNegocio nTabuladores = new TabuladoresNegocio();
            E_RESULTADO        vResultado   = nTabuladores.CopiaTabuladorMaestro(vIdTabulador, pIdTabulador, vClUsuario, vNbPrograma);
            string             vMensaje     = vResultado.MENSAJE.Where(w => w.CL_IDIOMA.Equals(vClIdioma.ToString())).FirstOrDefault().DS_MENSAJE;
            TabuladoresNegocio nTabulador   = new TabuladoresNegocio();
            var vTabulador = nTabulador.ObtenerTabuladores(ID_TABULADOR: vIdTabulador).FirstOrDefault();

            txtPorcentajeIncremento.Text = vTabulador.PR_INFLACION.ToString();
            Actualizar(null);
            UtilMensajes.MensajeResultadoDB(rwmMensaje, vMensaje, vResultado.CL_TIPO_ERROR, pCallBackFunction: "");
        }
        protected void Actualizar()
        {
            TabuladoresNegocio nTabulador = new TabuladoresNegocio();

            //var vEmpleados = nTabulador.ObtieneEmpleadosPlaneacionIncrementos(ID_TABULADOR: vIdTabulador, pID_ROL: vIdRol).ToList();

            //if (vEmpleados.Count > 0)
            //    if (vEmpleados.Where(w => w.FG_PLANEACION_INCREMENTO == true).Count() > 0)
            //        vFgPlaneacion = true;


            vObtienePlaneacionIncrementos = nTabulador.ObtieneEmpleadosPlaneacionIncrementos(ID_TABULADOR: vIdTabulador, pID_ROL: vIdRol, pFG_PLANECAION: null).Select(s => new E_PLANEACION_INCREMENTOS()
            {
                NUM_ITEM                    = (int)s.NUM_RENGLON,
                NB_TABULADOR_NIVEL          = s.NB_TABULADOR_NIVEL,
                ID_TABULADOR_EMPLEADO       = s.ID_TABULADOR_EMPLEADO,
                NO_NIVEL                    = s.NO_NIVEL,
                NB_PUESTO                   = s.NB_PUESTO,
                NB_DEPARTAMENTO             = s.NB_DEPARTAMENTO,
                NB_EMPLEADO                 = s.NOMBRE,
                CL_EMPLEADO                 = s.CL_EMPLEADO,
                MN_MINIMO_MINIMO            = s.MN_MINIMO_MINIMO,
                MN_MAXIMO_MINIMO            = s.MN_MAXIMO_MINIMO,
                MN_MINIMO_PRIMER_CUARTIL    = s.MN_MINIMO_PRIMER_CUARTIL,
                MN_MAXIMO_PRIMER_CUARTIL    = s.MN_MAXIMO_PRIMER_CUARTIL,
                MN_MINIMO_MEDIO             = s.MN_MINIMO_MEDIO,
                MN_MAXIMO_MEDIO             = s.MN_MAXIMO_MEDIO,
                MN_MINIMO_SEGUNDO_CUARTIL   = s.MN_MINIMO_SEGUNDO_CUARTIL,
                MN_MAXIMO_SEGUNDO_CUARTIL   = s.MN_MAXIMO_SEGUNDO_CUARTIL,
                MN_MAXIMO_MAXIMO            = s.MN_MAXIMO_MAXIMO,
                MN_MINIMO_MAXIMO            = s.MN_MINIMO_MAXIMO,
                FG_SUELDO_VISIBLE_TABULADOR = s.FG_SUELDO_VISIBLE_TABULADOR,
                MN_SUELDO_ORIGINAL          = s.MN_SUELDO_ORIGINAL,
                MN_SUELDO_NUEVO             = s.MN_SUELDO_NUEVO,
                //MN_SUELDO_NUEVO_INICIAL = s.MN_SUELDO_NUEVO,
                FE_CAMBIO_SUELDO     = s.FE_CAMBIO_SUELDO,
                XML_CATEGORIAS       = s.XML_CATEGORIA,
                lstCategorias        = SeleccionCuartil(XElement.Parse(s.XML_CATEGORIA), s.ID_TABULADOR_EMPLEADO),
                CUARTIL_SELECCIONADO = int.Parse(cmbCuartilIncremento.SelectedValue)
            }).ToList();

            foreach (E_PLANEACION_INCREMENTOS item in vObtienePlaneacionIncrementos)
            {
                item.MN_MINIMO_CUARTIL      = CalculaMinimo(int.Parse(cmbCuartilIncremento.SelectedValue), item.MN_MINIMO_MINIMO, item.MN_MINIMO_PRIMER_CUARTIL, item.MN_MINIMO_MEDIO, item.MN_MINIMO_SEGUNDO_CUARTIL, item.MN_MINIMO_MAXIMO);
                item.MN_MAXIMO_CUARTIL      = CalculaMaximo(int.Parse(cmbCuartilIncremento.SelectedValue), item.MN_MAXIMO_MINIMO, item.MN_MAXIMO_PRIMER_CUARTIL, item.MN_MAXIMO_MEDIO, item.MN_MAXIMO_SEGUNDO_CUARTIL, item.MN_MAXIMO_MAXIMO);
                item.DIFERENCIA             = CalculoPrDiferencia(item.MN_MINIMO_CUARTIL, item.MN_MAXIMO_CUARTIL, item.MN_SUELDO_ORIGINAL);
                item.DIFERENCIA_NUEVO       = CalculoPrDiferencia(item.MN_MINIMO_CUARTIL, item.MN_MAXIMO_CUARTIL, item.MN_SUELDO_NUEVO);
                item.COLOR_DIFERENCIA       = VariacionColor(item.DIFERENCIA, item.MN_SUELDO_ORIGINAL);
                item.COLOR_DIFERENCIA_NUEVO = VariacionColor(item.DIFERENCIA_NUEVO, item.MN_SUELDO_NUEVO);
                item.ICONO       = ObtenerIconoDifrencia(item.DIFERENCIA, item.MN_SUELDO_ORIGINAL);
                item.ICONO_NUEVO = ObtenerIconoDifrencia(item.DIFERENCIA_NUEVO, item.MN_SUELDO_NUEVO);
            }
        }
        protected void grdEmpleadosSeleccionados_NeedDataSource(object sender, Telerik.Web.UI.GridNeedDataSourceEventArgs e)
        {
            TabuladoresNegocio nTabulador = new TabuladoresNegocio();

            XElement vXmlIdTabulador = new XElement("SELECCION",
                                                    new XElement("FILTRO",
                                                                 new XAttribute("CL_TIPO", "TABULADOR"),
                                                                 new XElement("TIPO",
                                                                              new XAttribute("ID_TABULADOR", vIdTabulador)))
                                                    );

            grdEmpleadosSeleccionados.DataSource = nTabulador.ObtenieneEmpleadosTabulador(XML_SELECCIONADOS: vXmlIdTabulador, pIdRol: vIdRol);
        }
Пример #23
0
        public void GuardarMercadoSalarial(bool pFgCerrarVentana)
        {
            int    vIdPuesto = 0;
            string vClOrigen = null;

            foreach (GridDataItem item in grdMercadoSalarial.MasterTableView.Items)
            {
                vIdPuesto = (int.Parse(item.GetDataKeyValue("ID_PUESTO").ToString()));
                vClOrigen = item.GetDataKeyValue("CL_ORIGEN").ToString();
                RadNumericTextBox vMinimo = (RadNumericTextBox)item.FindControl("txnMinimo");
                RadNumericTextBox vMaximo = (RadNumericTextBox)item.FindControl("txnMaximo");

                //if (!vMinimo.Text.Equals("") & !vMaximo.Text.Equals(""))
                //{
                vTabuladorPuesto.Add(new E_TABULADOR_PUESTO {
                    ID_PUESTO = vIdPuesto, MN_MINIMO = decimal.Parse((vMinimo.Text == "") ? "0" : vMinimo.Text), MN_MAXIMO = decimal.Parse((vMaximo.Text == "") ? "0" : vMaximo.Text), CL_ORIGEN = vClOrigen
                });
                //}
            }
            Actualizar();
            //for (int i = 0; i < vTabuladorPuesto.Count; i++)
            //{
            //    if (vTabuladorPuesto.ElementAt(i).MN_MAXIMO != vObtieneTabuladorPuesto.ElementAt(i).MN_MAXIMO || vTabuladorPuesto.ElementAt(i).MN_MINIMO != vObtieneTabuladorPuesto.ElementAt(i).MN_MINIMO)
            //    {
            //        vTabuladorPuesto.ElementAt(i).CL_ORIGEN = "MERCADO";
            //    }
            //}
            var vXelements = vTabuladorPuesto.Select(x =>
                                                     new XElement("MERCADO",
                                                                  new XAttribute("ID_PUESTO", x.ID_PUESTO),
                                                                  new XAttribute("MN_MINIMO", x.MN_MINIMO),
                                                                  new XAttribute("MN_MAXIMO", x.MN_MAXIMO),
                                                                  new XAttribute("CL_ORIGEN", x.CL_ORIGEN)
                                                                  ));
            XElement TABULADORPUESTO =
                new XElement("MERCADOS", vXelements
                             );

            vTipoTransaccion = E_TIPO_OPERACION_DB.I.ToString();
            TabuladoresNegocio nTabulador = new TabuladoresNegocio();
            E_RESULTADO        vResultado = nTabulador.InsertaActualizaTabuladorPuesto(vTipoTransaccion, vIdTabulador, TABULADORPUESTO.ToString(), vClUsuario, vNbPrograma);
            string             vMensaje   = vResultado.MENSAJE.Where(w => w.CL_IDIOMA.Equals(vClIdioma.ToString())).FirstOrDefault().DS_MENSAJE;

            if (vResultado.CL_TIPO_ERROR.Equals(E_TIPO_RESPUESTA_DB.SUCCESSFUL))
            {
                bool   vCerrarVentana    = pFgCerrarVentana;
                string vCallBackFunction = vCerrarVentana ? "closeWindow" : null;
                grdMercadoSalarial.Rebind();
                UtilMensajes.MensajeResultadoDB(rwmMensaje, vMensaje, vResultado.CL_TIPO_ERROR, pCallBackFunction: vCallBackFunction);
            }
        }
Пример #24
0
        protected void grdTabulador_NeedDataSource(object sender, Telerik.Web.UI.GridNeedDataSourceEventArgs e)
        {
            TabuladoresNegocio nTabulador = new TabuladoresNegocio();

            if (vIdTabulador != null)
            {
                var vTabuladorFiltrado = nTabulador.ObtenerTabuladoresNivel(vIdTabulador);
                grdTabulador.DataSource = vTabuladorFiltrado;
            }
            else
            {
                var vTabulador = nTabulador.ObtenerTabuladores();
                grdTabulador.DataSource = vTabulador;
            }
        }
        protected void Page_Load(object sender, EventArgs e)
        {
            vClUsuario  = ContextoUsuario.oUsuario.CL_USUARIO;
            vNbPrograma = ContextoUsuario.nbPrograma;

            if (!IsPostBack)
            {
                vIdTabulador = int.Parse((Request.QueryString["ID"]));
                TabuladoresNegocio nTabulador = new TabuladoresNegocio();
                var vTavulador = nTabulador.ObtenerTabuladores(vIdTabulador).FirstOrDefault();
                txtClTabulador.Text = vTavulador.CL_TABULADOR;
                txtNbTabulador.Text = vTavulador.DS_TABULADOR;
                vNivelesTabulador   = vTavulador.NO_NIVELES;
            }
        }
        protected void grdValuacionPuesto_NeedDataSource(object sender, GridNeedDataSourceEventArgs e)
        {
            TabuladoresNegocio nTabulador = new TabuladoresNegocio();
            var vNivelacion = nTabulador.ObtieneValuacionNivelacion(ID_TABULADOR: vIdTabulador);

            vVistaObtenida = new List <E_NIVELACION>();

            foreach (var Item in vNivelacion)
            {
                vVistaObtenida.Add(new E_NIVELACION {
                    ID_TABULADOR_PUESTO = int.Parse(Item.ID_TABULADOR_PUESTO.ToString()), NO_NIVEL = int.Parse(Item.NO_NIVEL.ToString())
                });
            }
            grdValuacionPuesto.DataSource = vNivelacion;
        }
Пример #27
0
        protected void Page_Load(object sender, EventArgs e)
        {
            vClUsuario  = ContextoUsuario.oUsuario.CL_USUARIO;
            vNbPrograma = ContextoUsuario.nbPrograma;

            if (!Page.IsPostBack)
            {
                //rdpCreacion.SelectedDate = DateTime.Now;
                if (Request.QueryString["ID"] != null)
                {
                    vIdTabulador = int.Parse((Request.QueryString["ID"]));
                    TabuladoresNegocio nTabulador = new TabuladoresNegocio();
                    var vTabulador = nTabulador.ObtenerTabuladores(ID_TABULADOR: vIdTabulador).FirstOrDefault();
                    vTabula = new E_TABULADOR
                    {
                        CL_TABULADOR           = vTabulador.CL_TABULADOR,
                        ID_TABULADOR           = vTabulador.ID_TABULADOR,
                        NB_TABULADOR           = vTabulador.NB_TABULADOR,
                        DS_TABULADOR           = vTabulador.DS_TABULADOR,
                        NO_NIVELES             = vTabulador.NO_NIVELES,
                        NO_CATEGORIAS          = vTabulador.NO_CATEGORIAS,
                        PR_INFLACION           = vTabulador.PR_INFLACION,
                        PR_PROGRESION          = vTabulador.PR_PROGRESION,
                        XML_VARIACION          = vTabulador.XML_VARIACION,
                        ID_CUARTIL_INCREMENTO  = vTabulador.ID_CUARTIL_INCREMENTO,
                        ID_CUARTIL_INFLACIONAL = vTabulador.ID_CUARTIL_INFLACIONAL,
                        ID_CUARTIL_MERCADO     = vTabulador.ID_CUARTIL_MERCADO,
                        FE_CREACION            = vTabulador.FE_CREACION,
                        FE_VIGENCIA            = vTabulador.FE_VIGENCIA,
                        CL_ESTADO             = vTabulador.CL_ESTADO,
                        CL_SUELDO_COMPARACION = vTabulador.CL_SUELDO_COMPARACION,
                        CL_TIPO_PUESTO        = vTabulador.CL_TIPO_PUESTO
                    };
                    txtCrearAPartir.Text           = vTabula.CL_TABULADOR;
                    txtVersionTabuladorCopiar.Text = vTabula.CL_TABULADOR;
                    txtNombreTabulador.Text        = vTabula.NB_TABULADOR;
                    txtDescripcion.Text            = vTabula.DS_TABULADOR;
                    rdpCreacion.SelectedDate       = vTabula.FE_CREACION;
                    //DateTime vFechaVigencia = DateTime.Now.AddYears(1);
                    // int mes = vFechaVigencia.Month;
                    // int vDiferencia = 12 - mes;
                    // DateTime vFechaUltimoDiaMes = GetLastDayOf(vFechaVigencia);
                    // rdpVigencia.SelectedDate = vFechaUltimoDiaMes.AddMonths(vDiferencia);
                    rdpVigencia.SelectedDate = vTabula.FE_VIGENCIA;
                }
                SeguridadProcesos();
            }
        }
        //public DataTable ConvertToDataTable<T>(IList<T> data, List<E_CATEGORIA> lstCategoria, string pCategorias)
        //{
        //    PropertyDescriptorCollection properties = TypeDescriptor.GetProperties(typeof(T));
        //    DataTable table = new DataTable();
        //    foreach (PropertyDescriptor prop in properties)
        //        table.Columns.Add(prop.Name, Nullable.GetUnderlyingType(prop.PropertyType) ?? prop.PropertyType);

        //    foreach (E_CATEGORIA vCategorias in lstCategoria)
        //        table.Columns.Add(vCategorias.NO_CATEGORIA.ToString());

        //    foreach (T item in data)
        //    {
        //        DataRow row = table.NewRow();
        //        foreach (PropertyDescriptor prop in properties)
        //        {
        //            if (!prop.Name.Equals(pCategorias))
        //                row[prop.Name] = prop.GetValue(item) ?? DBNull.Value;
        //            else
        //            {
        //                object opCategorias = prop.GetValue(item);
        //                if (opCategorias != null)
        //                {
        //                    XElement vXmlCamposAdicionales = XElement.Parse(opCategorias.ToString());
        //                    foreach (E_CATEGORIA vCategoriaItem in lstCategoria)
        //                    {
        //                        XElement vXmlCampoAdicional = vXmlCamposAdicionales.Elements("ITEM").FirstOrDefault(f => UtilXML.ValorAtributo<string>(f.Attribute("NO_CATEGORIA")) == vCategoriaItem.NO_CATEGORIA.ToString());
        //                        if (vXmlCampoAdicional != null)
        //                        {
        //                            if (int.Parse(cmbCuartilIncremento.SelectedValue) == 1)
        //                                row[vCategoriaItem.NO_CATEGORIA.ToString()] = UtilXML.ValorAtributo<string>(vXmlCampoAdicional.Attribute("MN_MINIMO"));
        //                            else if (int.Parse(cmbCuartilIncremento.SelectedValue) == 2)
        //                                row[vCategoriaItem.NO_CATEGORIA.ToString()] = UtilXML.ValorAtributo<string>(vXmlCampoAdicional.Attribute("MN_PRIMER_CUARTIL"));
        //                            else if (int.Parse(cmbCuartilIncremento.SelectedValue) == 3)
        //                                row[vCategoriaItem.NO_CATEGORIA.ToString()] = UtilXML.ValorAtributo<string>(vXmlCampoAdicional.Attribute("MN_MEDIO"));
        //                            else if (int.Parse(cmbCuartilIncremento.SelectedValue) == 4)
        //                                row[vCategoriaItem.NO_CATEGORIA.ToString()] = UtilXML.ValorAtributo<string>(vXmlCampoAdicional.Attribute("MN_SEGUNDO_CUARTIL"));
        //                            else if (int.Parse(cmbCuartilIncremento.SelectedValue) == 5)
        //                                row[vCategoriaItem.NO_CATEGORIA.ToString()] = UtilXML.ValorAtributo<string>(vXmlCampoAdicional.Attribute("MN_MAXIMO"));
        //                        }
        //                    }
        //                }
        //            }
        //        }
        //        table.Rows.Add(row);
        //    }
        //    return table;
        //}

        //protected DataTable CrearDataTable<T>(IList<T> pLista, RadGrid pCtrlGrid)
        //{

        //    List<E_CATEGORIA> lstCategoria = new List<E_CATEGORIA>();

        //    lstCategoria = vObtienePlaneacionIncrementos.FirstOrDefault().lstCategorias;

        //    DataTable vColumnas = ConvertToDataTable(pLista, lstCategoria, "XML_CATEGORIAS");

        //    foreach (E_CATEGORIA item in lstCategoria)
        //    {
        //        GridBoundColumn vBoundColumn = new GridBoundColumn();
        //        vBoundColumn.DataField = item.NO_CATEGORIA.ToString();
        //        vBoundColumn.UniqueName = item.NO_CATEGORIA.ToString();
        //        vBoundColumn.HeaderText = ((char)(item.NO_CATEGORIA + 64)).ToString();
        //        vBoundColumn.ColumnGroupName = "TABMEDIO";
        //        (vBoundColumn as GridBoundColumn).AllowFiltering = false;
        //        vBoundColumn.HeaderStyle.HorizontalAlign = HorizontalAlign.Center;
        //        vBoundColumn.ItemStyle.Font.Bold = true;
        //        vBoundColumn.ItemStyle.HorizontalAlign = HorizontalAlign.Right;
        //        vBoundColumn.HeaderStyle.Width = System.Web.UI.WebControls.Unit.Pixel(100);
        //        vBoundColumn.AutoPostBackOnFilter = true;
        //        grdPlaneacionIncrementos.MasterTableView.Columns.Add(vBoundColumn);
        //    }

        //    return vColumnas;
        //}

        protected void GuardarPlaneacionIncrementos(bool pFgCerrarVentana, bool pAfectarInventario)
        {
            int vIdTabuladorEmpleado = 0;

            vPlaneacionIncrementos = new List <E_PLANEACION_INCREMENTOS>();
            foreach (GridDataItem item in grdPlaneacionIncrementos.MasterTableView.Items)
            {
                vIdTabuladorEmpleado = (int.Parse(item.GetDataKeyValue("ID_TABULADOR_EMPLEADO").ToString()));
                RadNumericTextBox vNuevoSueldo = (RadNumericTextBox)item.FindControl("txnSueldoNuevo");

                if (!vNuevoSueldo.Equals(""))
                {
                    vPlaneacionIncrementos.Add(new E_PLANEACION_INCREMENTOS
                    {
                        ID_TABULADOR_EMPLEADO = vIdTabuladorEmpleado,
                        MN_SUELDO_NUEVO       = decimal.Parse(vNuevoSueldo.Text),
                    });
                }
            }

            List <E_PLANEACION_INCREMENTOS> vResultadoPaneacion = new List <E_PLANEACION_INCREMENTOS>();

            for (int i = 0; i < vPlaneacionIncrementos.Count; i++)
            {
                if (vPlaneacionIncrementos.ElementAt(i).MN_SUELDO_NUEVO != vObtienePlaneacionIncrementos.ElementAt(i).MN_SUELDO_ORIGINAL&& vPlaneacionIncrementos.ElementAt(i).MN_SUELDO_NUEVO > 0)
                {
                    vResultadoPaneacion.Add(vPlaneacionIncrementos.ElementAt(i));
                }
            }

            var      vXelements           = vResultadoPaneacion.Select(x => CrearNodoIncremento(x));
            XElement PLANEACIONINCREMENTO = new XElement("INCREMENTOS", vXelements);

            TabuladoresNegocio nTabulador = new TabuladoresNegocio();
            E_RESULTADO        vResultado = nTabulador.InsertaActualizaNuevoSueldo(vIdTabulador, PLANEACIONINCREMENTO.ToString(), pAfectarInventario, vClUsuario, vNbPrograma);
            string             vMensaje   = vResultado.MENSAJE.Where(w => w.CL_IDIOMA.Equals(vClIdioma.ToString())).FirstOrDefault().DS_MENSAJE;

            if (vResultado.CL_TIPO_ERROR.Equals(E_TIPO_RESPUESTA_DB.SUCCESSFUL))
            {
                bool   vCerrarVentana    = pFgCerrarVentana;
                string vCallBackFunction = vCerrarVentana ? "onCloseWindow" : null;
                UtilMensajes.MensajeResultadoDB(rwmMensaje, vMensaje, vResultado.CL_TIPO_ERROR, pCallBackFunction: vCallBackFunction);
                grdPlaneacionIncrementos.Rebind();
            }
        }
Пример #29
0
        protected void rgdIncrementosPlaneados_NeedDataSource(object sender, GridNeedDataSourceEventArgs e)
        {
            TabuladoresNegocio nTabuladores = new TabuladoresNegocio();

            vObtienePlaneacionIncremento = nTabuladores.ObtienePlaneacionIncrementos(ID_TABULADOR: vIdTabulador).Select(s => new E_PLANEACION_INCREMENTOS()
            {
                NUM_ITEM = (int)s.NUM_RENGLON,
                ID_TABULADOR_EMPLEADO     = s.ID_TABULADOR_EMPLEADO,
                NB_TABULADOR_NIVEL        = s.NB_TABULADOR_NIVEL,
                CL_PUESTO                 = s.CL_PUESTO,
                NB_PUESTO                 = s.NB_PUESTO,
                CL_EMPLEADO               = s.CL_EMPLEADO,
                CL_DEPARTAMENTO           = s.CL_DEPARTAMENTO,
                NB_DEPARTAMENTO           = s.NB_DEPARTAMENTO,
                NB_EMPLEADO               = s.NOMBRE,
                MN_MINIMO_MINIMO          = s.MN_MINIMO_MINIMO,
                MN_MAXIMO_MINIMO          = s.MN_MAXIMO_MINIMO,
                MN_MINIMO_PRIMER_CUARTIL  = s.MN_MINIMO_PRIMER_CUARTIL,
                MN_MAXIMO_PRIMER_CUARTIL  = s.MN_MAXIMO_PRIMER_CUARTIL,
                MN_MINIMO_MEDIO           = s.MN_MINIMO_MEDIO,
                MN_MAXIMO_MEDIO           = s.MN_MAXIMO_MEDIO,
                MN_MINIMO_SEGUNDO_CUARTIL = s.MN_MINIMO_SEGUNDO_CUARTIL,
                MN_MAXIMO_SEGUNDO_CUARTIL = s.MN_MAXIMO_SEGUNDO_CUARTIL,
                MN_MAXIMO_MAXIMO          = s.MN_MAXIMO_MAXIMO,
                MN_MINIMO_MAXIMO          = s.MN_MINIMO_MAXIMO,
                MN_SUELDO_ORIGINAL        = s.MN_SUELDO_ORIGINAL,
                MN_SUELDO_NUEVO           = s.MN_SUELDO_NUEVO,
                MN_MINIMO                 = s.MN_MINIMO,
                MN_MAXIMO                 = s.MN_MAXIMO,
                INCREMENTO                = Math.Abs(s.MN_SUELDO_NUEVO - s.MN_SUELDO_ORIGINAL),
                NO_NIVEL             = s.NO_NIVEL,
                XML_CATEGORIAS       = s.XML_CATEGORIA,
                CUARTIL_SELECCIONADO = vCuartilComparativo,
                NO_VALUACION         = s.NO_VALUACION
            }).ToList();
            rgdIncrementosPlaneados.DataSource = vObtienePlaneacionIncremento;
            foreach (E_PLANEACION_INCREMENTOS item in vObtienePlaneacionIncremento)
            {
                if (item.MN_SUELDO_ORIGINAL != 0)
                {
                    item.PR_INCREMENTO = (item.INCREMENTO / item.MN_SUELDO_ORIGINAL) * 100;
                }
            }
        }
        protected void CargarDatosTabuladoresTodos()
        {
            vSeleccionadosTabuladores = new List <E_SELECCIONADOS>();
            foreach (RadListBoxItem item in lstTabuladores.Items)
            {
                vSeleccionadosTabuladores.Add(new E_SELECCIONADOS {
                    ID_SELECCIONADO = int.Parse(item.Value)
                });
            }
            vSeleccionadosTabuladores.Add(new E_SELECCIONADOS {
                ID_SELECCIONADO = vIdTabulador
            });

            List <int> vLstTabulador = new List <int>();

            vLstTabulador.Add(vIdTabulador);
            GuardarListaTabulador(vLstTabulador);


            var vXelements = vSeleccionadosTabuladores.Select(s =>
                                                              new XElement("FILTRO",
                                                                           new XAttribute("CL_TIPO", "TABULADORES"),
                                                                           new XElement("TIPO",
                                                                                        new XAttribute("ID_TABULADOR", s.ID_SELECCIONADO))
                                                                           ));
            XElement vXmlIdTabuladores =
                new XElement("SELECCION", vXelements);

            TabuladoresNegocio nTabuladores = new TabuladoresNegocio();

            vEmpTabuladores = nTabuladores.ObtenieneEmpleadosTabulador(XML_SELECCIONADOS: vXmlIdTabuladores, pIdRol: vIdRol).Select(s =>
                                                                                                                                    new E_EMPLEADOS_GRAFICAS()
            {
                ID_TABULADOR_EMPLEADO = s.ID_TABULADOR_EMPLEADO,
                ID_EMPLEADO           = s.M_EMPLEADO_ID_EMPLEADO,
                ID_TABULADOR          = s.ID_TABULADOR,
                NB_TABULADOR          = s.NB_TABULADOR,
                NB_EMPLEADO           = s.NB_EMPLEADO,
                NB_PUESTO             = s.NB_PUESTO,
                MN_SUELDO_ORIGINAL    = s.MN_SUELDO_ORIGINAL,
                NO_NIVEL     = s.NO_NIVEL,
                CL_TABULADOR = s.CL_TABULADOR
            }).ToList();
        }