示例#1
0
        private void cargaCombo()
        {
            cnx = new SqlConnection(cdn);
            cmd = new SqlCommand();
            cmd.Connection = cnx;
            ch = new Conceptos.Core.ConceptosHelper();
            ch.Command = cmd;

            Conceptos.Core.Conceptos concepto = new Conceptos.Core.Conceptos();
            concepto.idempresa = GLOBALES.IDEMPRESA;

            if (rbtnDeducciones.Checked)
                concepto.tipoconcepto = "D";
            if (rbtnPercepcion.Checked)
                concepto.tipoconcepto = "P";

            List<Conceptos.Core.Conceptos> lstConceptos = new List<Conceptos.Core.Conceptos>();

            try
            {
                cnx.Open();
                lstConceptos = ch.obtenerConceptosDeducciones(concepto, _periodo);
                cnx.Close();
                cnx.Dispose();
            }
            catch (Exception error)
            {
                MessageBox.Show("Error: \r\n \r\n" + error.Message, "Error");
            }

            cmbConcepto.DataSource = lstConceptos;
            cmbConcepto.DisplayMember = "concepto";
            cmbConcepto.ValueMember = "id";
        }
        private void ListaConceptosEmpleado()
        {
            cnx = new SqlConnection(cdn);
            cmd = new SqlCommand();
            cmd.Connection = cnx;
            ch = new Conceptos.Core.ConceptosHelper();
            ch.Command = cmd;

            Conceptos.Core.ConceptoTrabajador ct = new Conceptos.Core.ConceptoTrabajador();
            ct.idempleado = _idEmpleado;

            Conceptos.Core.Conceptos concepto = new Conceptos.Core.Conceptos();
            concepto.idempresa = GLOBALES.IDEMPRESA;

            Empleados.Core.EmpleadosHelper eh = new Empleados.Core.EmpleadosHelper();
            eh.Command = cmd;

            try
            {
                int periodo = 0;
                cnx.Open();
                periodo = int.Parse(eh.obtenerDiasPeriodo(_idEmpleado).ToString());
                lstConcepto = ch.obtenerConceptos(concepto, periodo);
                lstCT = ch.obtenerConceptosTrabajador(ct);
                cnx.Close();
                cnx.Dispose();

                var conceptotrab = from ctrab in lstCT join con in lstConcepto on ctrab.idconcepto equals con.id
                         select new
                         {
                             Id = ctrab.id,
                             Concepto = con.concepto,
                             TipoConcepto = (con.tipoconcepto == "P") ? "PERCEPCION" : "DEDUCCION"
                         };
                dgvConceptosEmpleado.DataSource = conceptotrab.ToList();

                for (int i = 0; i < dgvConceptosEmpleado.Columns.Count; i++)
                {
                    dgvConceptosEmpleado.AutoResizeColumn(i);
                }
            }
            catch (Exception error)
            {
                MessageBox.Show("Error: \r\n \r\n " + error.Message, "Error");
            }

            dgvConceptosEmpleado.Columns["Id"].Visible = false;

            int contenido = dgvConceptosEmpleado.Rows.Count;
            if (contenido == 0)
                toolBaja.Enabled = false;
            else
                toolBaja.Enabled = true;
        }
示例#3
0
        private void toolCalcular_Click(object sender, EventArgs e)
        {
            int existeConcepto = 0;
            int estatus = 0;
            int existeAltaReingreso = 0;
            //string noConceptosPercepciones = "", noConceptosDeducciones = "";
            cnx = new SqlConnection(cdn);
            cmd = new SqlCommand();
            cmd.Connection = cnx;

            List<CalculoNomina.Core.Nomina> lstConceptosPercepciones = new List<CalculoNomina.Core.Nomina>();
            List<CalculoNomina.Core.Nomina> lstConceptosDeducciones = new List<CalculoNomina.Core.Nomina>();

            List<CalculoNomina.Core.Nomina> lstConceptosPercepcionesModificados = new List<CalculoNomina.Core.Nomina>();
            List<CalculoNomina.Core.Nomina> lstConceptosDeduccionesModificados = new List<CalculoNomina.Core.Nomina>();

            CalculoNomina.Core.NominaHelper nh = new CalculoNomina.Core.NominaHelper();
            nh.Command = cmd;

            Empleados.Core.EmpleadosHelper eh = new Empleados.Core.EmpleadosHelper();
            eh.Command = cmd;

            Altas.Core.AltasHelper ah = new Altas.Core.AltasHelper();
            ah.Command = cmd;

            Reingreso.Core.ReingresoHelper rh = new Reingreso.Core.ReingresoHelper();
            rh.Command = cmd;

            if (_periodo == 7)
            {
                periodoInicioPosterior = _finPeriodo.AddDays(1);
                periodoFinPosterior = _finPeriodo.AddDays(7);
            }
            else
            {
                periodoInicioPosterior = _finPeriodo.AddDays(1);

                if (periodoInicioPosterior.Day <= 15)
                    periodoFinPosterior = _finPeriodo.AddDays(15);
                else
                    periodoFinPosterior = new DateTime(periodoInicioPosterior.Year, periodoInicioPosterior.Month,
                        DateTime.DaysInMonth(periodoInicioPosterior.Year, periodoInicioPosterior.Month));
            }

            try
            {
                cnx.Open();
                estatus = int.Parse(eh.obtenerEstatus(idTrabajador).ToString());
                cnx.Close();

                if (estatus == 0)
                {
                    cnx.Open();
                    nh.eliminaPreNomina(idTrabajador);
                    cnx.Close();
                 }
                else
                {

                    cnx.Open();
                    existeAltaReingreso = ah.existeAlta(GLOBALES.IDEMPRESA, idTrabajador, periodoInicioPosterior, periodoFinPosterior);
                    cnx.Close();

                    if (existeAltaReingreso != 0)
                    {
                        cnx.Open();
                        nh.eliminaPreNomina(idTrabajador);
                        cnx.Close();
                        MessageBox.Show("INFORMACION:\r\n\r\nEl trabajador a calcular fue dado de alta con fecha posterior al calculo actual.\r\nNo se calcula el trabajador.", "Información");
                        return;
                    }

                    cnx.Open();
                    existeAltaReingreso = rh.existeReingreso(GLOBALES.IDEMPRESA, idTrabajador, periodoInicioPosterior, periodoFinPosterior);
                    cnx.Close();

                    if (existeAltaReingreso != 0)
                    {
                        cnx.Open();
                        nh.eliminaPreNomina(idTrabajador);
                        cnx.Close();
                        MessageBox.Show("INFORMACION:\r\n\r\nEl trabajador a calcular fue dado de alta con fecha posterior al calculo actual.\r\nNo se calcula el trabajador.", "Información");
                        return;
                    }
                }
            }
            catch (Exception error)
            {
                MessageBox.Show("Error al verificar el estatus del trabajador(ID): " + idTrabajador + "\r\n\r\n" + error.Message, "Error");
                cnx.Close();
            }

            #region CONCEPTOS Y FORMULAS DEL TRABAJADOR
            try
            {
                /*************************************************************
                    * Se obtienen los conceptos con el campo modificado en 1
                    * de la tabla tmpPagoNomina con el SP stp_DatosNominaRecalculoTrabajador
                    *************************************************************/
                //cnx.Open();
                //lstConceptosPercepcionesModificados = nh.conceptosNominaTrabajador(GLOBALES.IDEMPRESA, "P", idTrabajador,
                //    _tipoNormalEspecial, _inicioPeriodo.Date, _finPeriodo.Date);
                //lstConceptosDeduccionesModificados = nh.conceptosNominaTrabajador(GLOBALES.IDEMPRESA, "D", idTrabajador,
                //    _tipoNormalEspecial, _inicioPeriodo.Date, _finPeriodo.Date);
                //cnx.Close();
                /***************** TERMINA *****************************/

                /*********************************************************
                    * Se verifica si las listas de los conceptos modificados
                    * son diferentes de 0, si son diferentes, se acumulan en la varible
                    * noConceptosPercepciones y noConceptosDeducciones
                    *********************************************************/
                //if (lstConceptosPercepcionesModificados.Count != 0)
                //{
                //    for (int i = 0; i < lstConceptosPercepcionesModificados.Count; i++)
                //        if (lstConceptosPercepcionesModificados[i].modificado)
                //            noConceptosPercepciones += lstConceptosPercepcionesModificados[i].noconcepto + ",";
                //    if (noConceptosPercepciones != "")
                //        noConceptosPercepciones = noConceptosPercepciones.Substring(0, noConceptosPercepciones.Length - 1);
                //}
                //else
                //    noConceptosPercepciones = "";

                //if (lstConceptosDeduccionesModificados.Count != 0)
                //{
                //    for (int i = 0; i < lstConceptosDeduccionesModificados.Count; i++)
                //        if (lstConceptosDeduccionesModificados[i].modificado)
                //            noConceptosDeducciones += lstConceptosDeduccionesModificados[i].noconcepto + ",";
                //    if (noConceptosDeducciones != "")
                //        noConceptosDeducciones = noConceptosDeducciones.Substring(0, noConceptosDeducciones.Length - 1);
                //}
                //else
                //    noConceptosDeducciones = "";
                /************************TERMINA***************************/

                /*****************************************************************
                    * Se llenan las listas con los conceptos que no estan modificados
                    * con el SP stp_DatosNominaTrabajador para el calculo.
                    *****************************************************************/
                cnx.Open();
                nh.eliminaNominaTrabajador(idTrabajador, _inicioPeriodo, _finPeriodo, _tipoNormalEspecial);
                lstConceptosPercepciones = nh.conceptosNominaTrabajador(GLOBALES.IDEMPRESA, "P", idTrabajador, _inicioPeriodo, _finPeriodo, _periodo);
                lstConceptosDeducciones = nh.conceptosNominaTrabajador(GLOBALES.IDEMPRESA, "D", idTrabajador, _inicioPeriodo, _finPeriodo, _periodo);
                cnx.Close();
                /**************************TERMINA*********************************/
            }
            catch
            {
                MessageBox.Show("Error: Al Obtener los conceptos del trabajador.\r\n \r\n La ventan se cerrara.", "Error");
                this.Dispose();
            }
            #endregion

            #region CALCULO DE PERCEPCIONES
            List<CalculoNomina.Core.tmpPagoNomina> lstPercepciones = new List<CalculoNomina.Core.tmpPagoNomina>();
            lstPercepciones = CALCULO.PERCEPCIONES(lstConceptosPercepciones, _inicioPeriodo.Date, _finPeriodo.Date, _tipoNormalEspecial);
            #endregion

            #region BULK DATOS PERCEPCIONES
            BulkData(lstPercepciones);
            #endregion

            #region OBTENCION DE PERCEPCIONES
            lstPercepciones = new List<CalculoNomina.Core.tmpPagoNomina>();
            CalculoNomina.Core.tmpPagoNomina per = new CalculoNomina.Core.tmpPagoNomina();
            per.idempresa = GLOBALES.IDEMPRESA;
            per.idtrabajador = idTrabajador;
            per.fechainicio = _inicioPeriodo.Date;
            per.fechafin = _finPeriodo.Date;
            per.tipoconcepto = "P";
            per.tiponomina = _tipoNormalEspecial;
            cnx = new SqlConnection(cdn);
            cnx.Open();
            lstPercepciones = nh.obtenerPercepcionesTrabajador(per);
            cnx.Close();
            #endregion

            #region CALCULO DE DEDUCCIONES
            List<CalculoNomina.Core.tmpPagoNomina> lstDeducciones = new List<CalculoNomina.Core.tmpPagoNomina>();
            lstDeducciones = CALCULO.DEDUCCIONES(lstConceptosDeducciones, lstPercepciones, _inicioPeriodo.Date, _finPeriodo.Date, _tipoNormalEspecial);
            #endregion

            #region BULK DATOS DEDUCCIONES
            BulkData(lstDeducciones);
            #endregion

            #region PROGRAMACION DE MOVIMIENTOS
            List<CalculoNomina.Core.tmpPagoNomina> lstOtrasDeducciones = new List<CalculoNomina.Core.tmpPagoNomina>();

            decimal percepciones = lstPercepciones.Where(f => f.tipoconcepto == "P").Sum(f => f.cantidad);

            if (percepciones != 0)
            {
                cnx = new SqlConnection(cdn);
                cmd = new SqlCommand();
                cmd.Connection = cnx;

                int existe = 0;
                ProgramacionConcepto.Core.ProgramacionHelper pch = new ProgramacionConcepto.Core.ProgramacionHelper();
                pch.Command = cmd;

                ProgramacionConcepto.Core.ProgramacionConcepto programacion = new ProgramacionConcepto.Core.ProgramacionConcepto();
                programacion.idtrabajador = idTrabajador;

                List<ProgramacionConcepto.Core.ProgramacionConcepto> lstProgramacion = new List<ProgramacionConcepto.Core.ProgramacionConcepto>();

                try
                {
                    cnx.Open();
                    existe = (int)pch.existeProgramacion(programacion);
                    cnx.Close();
                }
                catch (Exception error)
                {
                    MessageBox.Show("Error: \r\n \r\n" + error.Message, "Error");
                    cnx.Dispose();
                }

                if (existe != 0)
                {
                    try
                    {
                        cnx.Open();
                        lstProgramacion = pch.obtenerProgramacion(programacion);
                        cnx.Close();
                    }
                    catch (Exception error)
                    {
                        MessageBox.Show("Error: \r\n \r\n" + error.Message, "Error");
                        cnx.Dispose();
                    }

                    for (int i = 0; i < lstProgramacion.Count; i++)
                    {
                        if (_finPeriodo.Date <= lstProgramacion[i].fechafin)
                        {
                            Conceptos.Core.ConceptosHelper ch = new Conceptos.Core.ConceptosHelper();
                            ch.Command = cmd;
                            Conceptos.Core.Conceptos concepto = new Conceptos.Core.Conceptos();
                            concepto.id = lstProgramacion[i].idconcepto;
                            List<Conceptos.Core.Conceptos> lstNoConcepto = new List<Conceptos.Core.Conceptos>();
                            try
                            {
                                cnx.Open();
                                lstNoConcepto = ch.obtenerConcepto(concepto);
                                cnx.Close();
                            }
                            catch (Exception error) { MessageBox.Show("Error: \r\n \r\n" + error.Message, "Error"); }

                            CalculoNomina.Core.tmpPagoNomina pne = new CalculoNomina.Core.tmpPagoNomina();
                            pne.idempresa = GLOBALES.IDEMPRESA;
                            pne.idtrabajador = idTrabajador;
                            pne.fechainicio = _inicioPeriodo.Date;
                            pne.fechafin = _finPeriodo.Date;
                            pne.noconcepto = lstNoConcepto[0].noconcepto;

                            nh = new CalculoNomina.Core.NominaHelper();
                            nh.Command = cmd;
                            try
                            {
                                cnx.Open();
                                existeConcepto = (int)nh.existeConcepto(pne);
                                cnx.Close();
                            }
                            catch (Exception error)
                            {
                                MessageBox.Show("Error al obtener la existencia del concepto." + error.Message + "\r\n" + error.Source, "Error");
                                cnx.Dispose();
                            }

                            CalculoNomina.Core.tmpPagoNomina vn = new CalculoNomina.Core.tmpPagoNomina();
                            vn.idtrabajador = idTrabajador;
                            vn.idempresa = GLOBALES.IDEMPRESA;
                            vn.idconcepto = lstProgramacion[i].idconcepto;
                            vn.noconcepto = lstNoConcepto[0].noconcepto;
                            vn.tipoconcepto = lstNoConcepto[0].tipoconcepto;
                            vn.fechainicio = _inicioPeriodo.Date;
                            vn.fechafin = _finPeriodo.Date;
                            vn.exento = 0;
                            vn.gravado = 0;
                            vn.cantidad = lstProgramacion[i].cantidad;
                            vn.guardada = true;
                            vn.tiponomina = _tipoNormalEspecial;
                            vn.modificado = false;

                            if (lstNoConcepto[0].gravado && !lstNoConcepto[0].exento)
                            {
                                vn.gravado = lstProgramacion[i].cantidad;
                                vn.exento = 0;
                            }

                            if (lstNoConcepto[0].gravado && lstNoConcepto[0].exento)
                            {
                                CalculoFormula formulaExcento = new CalculoFormula(idTrabajador, _inicioPeriodo.Date, _finPeriodo.Date, lstNoConcepto[0].formulaexento);
                                vn.exento = decimal.Parse(formulaExcento.calcularFormula().ToString());
                                if (vn.cantidad <= vn.exento)
                                {
                                    vn.exento = vn.cantidad;
                                    vn.gravado = 0;
                                }
                                else
                                {
                                    vn.gravado = vn.cantidad - vn.exento;
                                }
                            }

                            if (existeConcepto == 0)
                            {
                                lstOtrasDeducciones.Add(vn);
                            }
                            else
                            {
                                try
                                {
                                    cnx.Open();
                                    nh.actualizaConceptoModificado(vn);
                                    cnx.Close();
                                }
                                catch
                                {
                                    MessageBox.Show("Error al actualizar el concepto.", "Error");
                                    cnx.Dispose();
                                }
                            }
                        }
                    }
                }
            }
            else
            {
                decimal vacacion = lstPercepciones.Where(f => f.noconcepto == 7).Sum(f => f.cantidad);
                if (vacacion != 0)
                {
                    cnx = new SqlConnection(cdn);
                    cmd = new SqlCommand();
                    cmd.Connection = cnx;

                    int existe = 0;
                    ProgramacionConcepto.Core.ProgramacionHelper pch = new ProgramacionConcepto.Core.ProgramacionHelper();
                    pch.Command = cmd;

                    ProgramacionConcepto.Core.ProgramacionConcepto programacion = new ProgramacionConcepto.Core.ProgramacionConcepto();
                    programacion.idtrabajador = idTrabajador;

                    List<ProgramacionConcepto.Core.ProgramacionConcepto> lstProgramacion = new List<ProgramacionConcepto.Core.ProgramacionConcepto>();

                    try
                    {
                        cnx.Open();
                        existe = (int)pch.existeProgramacion(programacion);
                        cnx.Close();
                    }
                    catch (Exception error)
                    {
                        MessageBox.Show("Error: \r\n \r\n" + error.Message, "Error");
                        cnx.Dispose();
                    }

                    if (existe != 0)
                    {
                        try
                        {
                            cnx.Open();
                            lstProgramacion = pch.obtenerProgramacion(programacion);
                            cnx.Close();
                        }
                        catch (Exception error)
                        {
                            MessageBox.Show("Error: \r\n \r\n" + error.Message, "Error");
                            cnx.Dispose();
                        }

                        for (int i = 0; i < lstProgramacion.Count; i++)
                        {
                            if (_finPeriodo.Date <= lstProgramacion[i].fechafin)
                            {
                                Conceptos.Core.ConceptosHelper ch = new Conceptos.Core.ConceptosHelper();
                                ch.Command = cmd;
                                Conceptos.Core.Conceptos concepto = new Conceptos.Core.Conceptos();
                                concepto.id = lstProgramacion[i].idconcepto;
                                List<Conceptos.Core.Conceptos> lstNoConcepto = new List<Conceptos.Core.Conceptos>();
                                try
                                {
                                    cnx.Open();
                                    lstNoConcepto = ch.obtenerConcepto(concepto);
                                    cnx.Close();
                                }
                                catch (Exception error) { MessageBox.Show("Error: \r\n \r\n" + error.Message, "Error"); }

                                CalculoNomina.Core.tmpPagoNomina pne = new CalculoNomina.Core.tmpPagoNomina();
                                pne.idempresa = GLOBALES.IDEMPRESA;
                                pne.idtrabajador = idTrabajador;
                                pne.fechainicio = _inicioPeriodo.Date;
                                pne.fechafin = _finPeriodo.Date;
                                pne.noconcepto = lstNoConcepto[0].noconcepto;

                                try
                                {
                                    cnx.Open();
                                    existeConcepto = (int)nh.existeConcepto(pne);
                                    cnx.Close();
                                }
                                catch
                                {
                                    MessageBox.Show("Error al obtener la existencia del concepto.", "Error");
                                    cnx.Dispose();
                                }

                                CalculoNomina.Core.tmpPagoNomina vn = new CalculoNomina.Core.tmpPagoNomina();
                                vn.idtrabajador = idTrabajador;
                                vn.idempresa = GLOBALES.IDEMPRESA;
                                vn.idconcepto = lstProgramacion[i].idconcepto;
                                vn.noconcepto = lstNoConcepto[0].noconcepto;
                                vn.tipoconcepto = lstNoConcepto[0].tipoconcepto;
                                vn.fechainicio = _inicioPeriodo.Date;
                                vn.fechafin = _finPeriodo.Date;
                                vn.exento = 0;
                                vn.gravado = 0;
                                vn.cantidad = lstProgramacion[i].cantidad;
                                vn.guardada = true;
                                vn.tiponomina = _tipoNormalEspecial;
                                vn.modificado = false;

                                if (lstNoConcepto[0].gravado && !lstNoConcepto[0].exento)
                                {
                                    vn.gravado = lstProgramacion[i].cantidad;
                                    vn.exento = 0;
                                }

                                if (lstNoConcepto[0].gravado && lstNoConcepto[0].exento)
                                {
                                    CalculoFormula formulaExcento = new CalculoFormula(idTrabajador, _inicioPeriodo.Date, _finPeriodo.Date, lstNoConcepto[0].formulaexento);
                                    vn.exento = decimal.Parse(formulaExcento.calcularFormula().ToString());
                                    if (vn.cantidad <= vn.exento)
                                    {
                                        vn.exento = vn.cantidad;
                                        vn.gravado = 0;
                                    }
                                    else
                                    {
                                        vn.gravado = vn.cantidad - vn.exento;
                                    }
                                }

                                if (existeConcepto == 0)
                                {
                                    lstOtrasDeducciones.Add(vn);
                                }
                                else
                                {
                                    try
                                    {
                                        cnx.Open();
                                        nh.actualizaConceptoModificado(vn);
                                        cnx.Close();
                                    }
                                    catch
                                    {
                                        MessageBox.Show("Error al actualizar el concepto.", "Error");
                                        cnx.Dispose();
                                    }
                                }
                            }
                        }
                    }
                }
            }
            #endregion

            #region MOVIMIENTOS

            cnx = new SqlConnection(cdn);
            cmd = new SqlCommand();
            cmd.Connection = cnx;

            Movimientos.Core.MovimientosHelper mh = new Movimientos.Core.MovimientosHelper();
            mh.Command = cmd;
            nh = new CalculoNomina.Core.NominaHelper();
            nh.Command = cmd;

            percepciones = lstPercepciones.Where(f => f.tipoconcepto == "P").Sum(f => f.cantidad);

            if (percepciones != 0)
            {
                int existe = 0;
                Movimientos.Core.Movimientos mov = new Movimientos.Core.Movimientos();
                mov.idtrabajador = idTrabajador;
                mov.fechainicio = _inicioPeriodo.Date;
                mov.fechafin = _finPeriodo.Date;

                List<Movimientos.Core.Movimientos> lstMovimiento = new List<Movimientos.Core.Movimientos>();

                try
                {
                    cnx.Open();
                    existe = (int)mh.existeMovimiento(mov);
                    cnx.Close();
                }
                catch (Exception error)
                {
                    MessageBox.Show("Error: \r\n \r\n" + error.Message, "Error");
                    cnx.Dispose();
                }

                if (existe != 0)
                {
                    try
                    {
                        cnx.Open();
                        lstMovimiento = mh.obtenerMovimiento(mov);
                        cnx.Close();
                    }
                    catch (Exception error)
                    {
                        MessageBox.Show("Error: \r\n \r\n" + error.Message, "Error");
                        cnx.Dispose();
                    }

                    for (int i = 0; i < lstMovimiento.Count; i++)
                    {
                        Conceptos.Core.ConceptosHelper ch = new Conceptos.Core.ConceptosHelper();
                        ch.Command = cmd;
                        Conceptos.Core.Conceptos concepto = new Conceptos.Core.Conceptos();
                        concepto.id = lstMovimiento[i].idconcepto;
                        List<Conceptos.Core.Conceptos> lstNoConcepto = new List<Conceptos.Core.Conceptos>();
                        try
                        {
                            cnx.Open();
                            lstNoConcepto = ch.obtenerConcepto(concepto);
                            cnx.Close();
                        }
                        catch (Exception error) { MessageBox.Show("Error: \r\n \r\n" + error.Message, "Error"); }

                        CalculoNomina.Core.tmpPagoNomina vn = new CalculoNomina.Core.tmpPagoNomina();
                        vn.idtrabajador = idTrabajador;
                        vn.idempresa = GLOBALES.IDEMPRESA;
                        vn.idconcepto = lstMovimiento[i].idconcepto;
                        vn.noconcepto = lstNoConcepto[0].noconcepto;
                        vn.tipoconcepto = lstNoConcepto[0].tipoconcepto;
                        vn.fechainicio = _inicioPeriodo.Date;
                        vn.fechafin = _finPeriodo.Date;
                        vn.exento = 0;
                        vn.gravado = 0;
                        vn.cantidad = lstMovimiento[i].cantidad;
                        vn.guardada = true;
                        vn.tiponomina = _tipoNormalEspecial;
                        vn.modificado = false;

                        if (lstNoConcepto[0].gravado && !lstNoConcepto[0].exento)
                        {
                            vn.gravado = lstMovimiento[i].cantidad;
                            vn.exento = 0;
                        }

                        if (lstNoConcepto[0].gravado && lstNoConcepto[0].exento)
                        {
                            CalculoFormula formulaExcento = new CalculoFormula(idTrabajador, _inicioPeriodo.Date, _finPeriodo.Date, lstNoConcepto[0].formulaexento);
                            vn.exento = decimal.Parse(formulaExcento.calcularFormula().ToString());
                            if (vn.cantidad <= vn.exento)
                            {
                                vn.exento = vn.cantidad;
                                vn.gravado = 0;
                            }
                            else
                            {
                                vn.gravado = vn.cantidad - vn.exento;
                            }
                        }

                        if (!lstNoConcepto[0].gravado && lstNoConcepto[0].exento)
                        {
                            vn.gravado = 0;
                            vn.exento = lstMovimiento[i].cantidad;
                        }

                        try
                        {
                            cnx.Open();
                            existe = (int)nh.existeConcepto(vn);
                            cnx.Close();
                        }
                        catch (Exception error)
                        {
                            MessageBox.Show("Error: Al verificar existencia de los movimientos. \r\n" + error.Message, "Error");
                        }

                        if (existe == 0)
                        {
                            lstOtrasDeducciones.Add(vn);
                        }
                        else
                        {
                            try
                            {
                                cnx.Open();
                                nh.actualizaConcepto(vn);
                                cnx.Close();
                            }
                            catch (Exception error)
                            {
                                MessageBox.Show("Error: Al actualizar los movimientos. " +  error.Message, "Error");
                            }

                        }
                    }
                }
            }
            #endregion

            #region BULK DATOS PROGRAMACION DE MOVIMIENTOS
            BulkData(lstOtrasDeducciones);
            #endregion

            #region MOSTRAR DATOS
            muestraDatos();
            #endregion

            #region PERIODO
            cnx = new SqlConnection(cdn);
            cmd = new SqlCommand();
            cmd.Connection = cnx;
            nh = new CalculoNomina.Core.NominaHelper();
            nh.Command = cmd;
            int noPeriodo = 0;
            try
            {
                if (_tipoNormalEspecial == GLOBALES.NORMAL)
                {
                    cnx.Open();
                    noPeriodo = int.Parse(nh.obtenerNoPeriodo(_periodo, _inicioPeriodo).ToString());
                    nh.actualizarNoPeriodo(GLOBALES.IDEMPRESA, _inicioPeriodo.Date, _finPeriodo.Date, noPeriodo);
                    cnx.Close();
                }
                else if (_tipoNormalEspecial == GLOBALES.EXTRAORDINARIO_NORMAL)
                {
                    cnx.Open();
                    noPeriodo = (int)(nh.obtenerNoPeriodoExtraordinario(GLOBALES.IDEMPRESA, _tipoNormalEspecial));
                    noPeriodo = noPeriodo + 1;
                    nh.actualizarNoPeriodo(GLOBALES.IDEMPRESA, _inicioPeriodo.Date, _finPeriodo.Date, noPeriodo);
                    cnx.Close();
                }

            }
            catch (Exception)
            {
                MessageBox.Show("Error: Al actualizar el No. de Periodo", "Error");
                cnx.Dispose();
                return;
            }
            #endregion
        }
示例#4
0
        private void muestraProgramacion()
        {
            cnx = new SqlConnection(cdn);
            cmd = new SqlCommand();
            cmd.Connection = cnx;

            ProgramacionConcepto.Core.ProgramacionHelper pch = new ProgramacionConcepto.Core.ProgramacionHelper();
            pch.Command = cmd;

            Conceptos.Core.ConceptosHelper ch = new Conceptos.Core.ConceptosHelper();
            ch.Command = cmd;

            Empleados.Core.EmpleadosHelper emph = new Empleados.Core.EmpleadosHelper();
            emph.Command = cmd;

            ProgramacionConcepto.Core.ProgramacionConcepto pc = new ProgramacionConcepto.Core.ProgramacionConcepto();
            pc.idtrabajador = idTrabajador;

            Conceptos.Core.Conceptos c = new Conceptos.Core.Conceptos();
            c.idempresa = GLOBALES.IDEMPRESA;

            Empleados.Core.Empleados empleado = new Empleados.Core.Empleados();
            empleado.idtrabajador = idTrabajador;

            List<ProgramacionConcepto.Core.ProgramacionConcepto> lstProgramacionConcepto = new List<ProgramacionConcepto.Core.ProgramacionConcepto>();
            List<Conceptos.Core.Conceptos> lstConceptos = new List<Conceptos.Core.Conceptos>();
            List<Empleados.Core.Empleados> lstEmpleado = new List<Empleados.Core.Empleados>();

            try
            {
                cnx.Open();
                lstProgramacionConcepto = pch.obtenerProgramacion(pc);
                lstConceptos = ch.obtenerConceptos(c, _periodo);
                lstEmpleado = emph.obtenerEmpleado(empleado);
                cnx.Close();
                cnx.Dispose();
            }
            catch (Exception error)
            {
                MessageBox.Show("Error: Al obtener las Programaciones. (Función Muestra Programación.)\r\n \r\n" + error.Message, "Error");
            }

            var prog = from p in lstProgramacionConcepto
                       join co in lstConceptos on p.idconcepto equals co.id
                       join em in lstEmpleado on p.idtrabajador equals em.idtrabajador
                       select new {
                           p.idprogramacion,
                           p.idtrabajador,
                           co.id,
                           em.noempleado,
                           em.nombrecompleto,
                           co.concepto,
                           p.cantidad,
                           p.fechafin
                       };

            dgvProgramacion.Columns["idpc"].DataPropertyName = "idprogramacion";
            dgvProgramacion.Columns["idtrabajadorpc"].DataPropertyName = "idtrabajador";
            dgvProgramacion.Columns["idconceptopc"].DataPropertyName = "id";
            dgvProgramacion.Columns["noempleadopc"].DataPropertyName = "noempleado";
            dgvProgramacion.Columns["nombrepc"].DataPropertyName = "nombrecompleto";
            dgvProgramacion.Columns["conceptopc"].DataPropertyName = "concepto";
            dgvProgramacion.Columns["cantidadpc"].DataPropertyName = "cantidad";
            dgvProgramacion.Columns["fechafinpc"].DataPropertyName = "fechafin";
            dgvProgramacion.DataSource = prog.ToList();

            DataGridViewCellStyle estilo = new DataGridViewCellStyle();
            estilo.Alignment = DataGridViewContentAlignment.MiddleRight;
            estilo.Format = "C2";

            dgvProgramacion.AutoSizeColumnsMode = DataGridViewAutoSizeColumnsMode.Fill;
            dgvProgramacion.Columns[5].DefaultCellStyle = estilo;
        }
示例#5
0
        private void muestraMovimientos()
        {
            cnx = new SqlConnection(cdn);
            cmd = new SqlCommand();
            cmd.Connection = cnx;

            Movimientos.Core.MovimientosHelper mh = new Movimientos.Core.MovimientosHelper();
            mh.Command = cmd;

            Conceptos.Core.ConceptosHelper ch = new Conceptos.Core.ConceptosHelper();
            ch.Command = cmd;

            Empleados.Core.EmpleadosHelper emph = new Empleados.Core.EmpleadosHelper();
            emph.Command = cmd;

            Movimientos.Core.Movimientos m = new Movimientos.Core.Movimientos();
            m.idtrabajador = idTrabajador;

            Conceptos.Core.Conceptos c = new Conceptos.Core.Conceptos();
            c.idempresa = GLOBALES.IDEMPRESA;

            Empleados.Core.Empleados empleado = new Empleados.Core.Empleados();
            empleado.idtrabajador = idTrabajador;

            List<Movimientos.Core.Movimientos> lstMovimientos = new List<Movimientos.Core.Movimientos>();
            List<Conceptos.Core.Conceptos> lstConceptos = new List<Conceptos.Core.Conceptos>();
            List<Empleados.Core.Empleados> lstEmpleado = new List<Empleados.Core.Empleados>();

            try
            {
                cnx.Open();
                lstMovimientos = mh.obtenerMovimientosTrabajador(m);
                lstConceptos = ch.obtenerConceptos(c, _periodo);
                lstEmpleado = emph.obtenerEmpleado(empleado);
                cnx.Close();
                cnx.Dispose();
            }
            catch (Exception error)
            {
                MessageBox.Show("Error: Al obtener los Movimientos. (Función Muestra Movimientos.) \r\n \r\n" + error.Message, "Error");
            }

            var prog = from mov in lstMovimientos
                       join co in lstConceptos on mov.idconcepto equals co.id
                       join em in lstEmpleado on mov.idtrabajador equals em.idtrabajador
                       select new
                       {
                           mov.id,
                           mov.idtrabajador,
                           em.noempleado,
                           em.nombrecompleto,
                           co.concepto,
                           mov.cantidad,
                           mov.fechainicio,
                           mov.fechafin
                       };

            dgvMovimientos.Columns["idm"].DataPropertyName = "id";
            dgvMovimientos.Columns["idtrabajadorm"].DataPropertyName = "idtrabajador";
            dgvMovimientos.Columns["noempleadom"].DataPropertyName = "noempleado";
            dgvMovimientos.Columns["nombrem"].DataPropertyName = "nombrecompleto";
            dgvMovimientos.Columns["conceptom"].DataPropertyName = "concepto";
            dgvMovimientos.Columns["cantidadm"].DataPropertyName = "cantidad";
            dgvMovimientos.Columns["periodoiniciom"].DataPropertyName = "fechainicio";
            dgvMovimientos.Columns["periodofinm"].DataPropertyName = "fechafin";
            dgvMovimientos.DataSource = prog.ToList();

            DataGridViewCellStyle estilo = new DataGridViewCellStyle();
            estilo.Alignment = DataGridViewContentAlignment.MiddleRight;
            estilo.Format = "C2";

            dgvProgramacion.AutoSizeColumnsMode = DataGridViewAutoSizeColumnsMode.Fill;
            dgvProgramacion.Columns[5].DefaultCellStyle = estilo;
        }
示例#6
0
        private void muestraDatos()
        {
            dgvPercepciones.DataSource = null;
            dgvPercepciones.Columns.Clear();
            dgvDeducciones.DataSource = null;
            dgvDeducciones.Columns.Clear();

            cnx = new SqlConnection(cdn);
            cmd = new SqlCommand();
            cmd.Connection = cnx;

            CalculoNomina.Core.NominaHelper nh = new CalculoNomina.Core.NominaHelper();
            nh.Command = cmd;

            List<CalculoNomina.Core.tmpPagoNomina> lstReciboPercepciones = new List<CalculoNomina.Core.tmpPagoNomina>();
            List<CalculoNomina.Core.tmpPagoNomina> lstReciboDeducciones = new List<CalculoNomina.Core.tmpPagoNomina>();

            CalculoNomina.Core.tmpPagoNomina pnp = new CalculoNomina.Core.tmpPagoNomina();
            pnp.idtrabajador = idTrabajador;
            pnp.fechainicio = _inicioPeriodo.Date;
            pnp.fechafin = _finPeriodo.Date;
            pnp.tipoconcepto = "P";

            CalculoNomina.Core.tmpPagoNomina pnd = new CalculoNomina.Core.tmpPagoNomina();
            pnd.idtrabajador = idTrabajador;
            pnd.fechainicio = _inicioPeriodo.Date;
            pnd.fechafin = _finPeriodo.Date;
            pnd.tipoconcepto = "D";

            try
            {
                cnx.Open();
                lstReciboPercepciones = nh.obtenerDatosRecibo(pnp, _periodo);
                lstReciboDeducciones = nh.obtenerDatosRecibo(pnd, _periodo);
                cnx.Close();

            }
            catch {
                MessageBox.Show("Error: Al obtener la prenomina del trabajador. Se cerrará la ventana","Error");
                this.Dispose();
            }

            if (lstReciboPercepciones.Count != 0)
            {
                string formulaDiasAPagar = "[DiasLaborados]-[Faltas]-[DiasIncapacidad]";

                Conceptos.Core.ConceptosHelper conceptoh = new Conceptos.Core.ConceptosHelper();
                conceptoh.Command = cmd;

                Conceptos.Core.Conceptos c = new Conceptos.Core.Conceptos();
                c.idempresa = GLOBALES.IDEMPRESA;

                List<Conceptos.Core.Conceptos> lstConceptos = new List<Conceptos.Core.Conceptos>();

                CalculoFormula cf = new CalculoFormula(idTrabajador, _inicioPeriodo, _finPeriodo, formulaDiasAPagar);
                int diasAPagar = int.Parse(cf.calcularFormula().ToString());

                try
                {
                    cnx.Open();
                    lstConceptos = conceptoh.obtenerConceptos(c, _periodo);
                    cnx.Close();
                    cnx.Dispose();
                }
                catch (Exception error)
                {
                    MessageBox.Show("Error: Al obtener lista de conceptos. (Función Muestra Datos.)\r\n \r\n" + error.Message, "Error");
                }

                var percepcion = from r in lstReciboPercepciones
                                 join co in lstConceptos on r.idconcepto equals co.id
                                 where co.visible == true && r.cantidad != 0
                                 select new
                                 {
                                     NoConcepto = co.noconcepto,
                                     Concepto = co.concepto,
                                     Importe = r.cantidad
                                 };

                var deduccion = from r in lstReciboDeducciones
                                join co in lstConceptos on r.idconcepto equals co.id
                                where co.visible == true && r.cantidad != 0
                                select new
                                {
                                    NoConcepto = co.noconcepto,
                                    Concepto = co.concepto,
                                    Importe = r.cantidad
                                };

                DataGridViewCellStyle estilo = new DataGridViewCellStyle();
                estilo.Alignment = DataGridViewContentAlignment.MiddleRight;
                estilo.Format = "C2";

                dgvPercepciones.DataSource = percepcion.ToList();
                dgvPercepciones.AutoSizeColumnsMode = DataGridViewAutoSizeColumnsMode.Fill;
                dgvPercepciones.Columns[0].Width = 10;
                dgvPercepciones.Columns[1].Width = 70;
                dgvPercepciones.Columns[2].Width = 90;
                dgvPercepciones.Columns[2].DefaultCellStyle = estilo;

                dgvDeducciones.DataSource = deduccion.ToList();
                dgvDeducciones.AutoSizeColumnsMode = DataGridViewAutoSizeColumnsMode.Fill;
                dgvDeducciones.Columns[0].Width = 10;
                dgvDeducciones.Columns[1].Width = 70;
                dgvDeducciones.Columns[2].Width = 90;
                dgvDeducciones.Columns[2].DefaultCellStyle = estilo;

                decimal sumaPercepciones = 0, sumaDeducciones = 0, netoPagar = 0;
                decimal subsidio = lstReciboDeducciones.Where(d => d.noconcepto == 16).Sum(d => d.cantidad);
                foreach (DataGridViewRow fila in dgvPercepciones.Rows)
                {
                    sumaPercepciones += decimal.Parse(fila.Cells[2].Value.ToString());
                }

                foreach (DataGridViewRow fila in dgvDeducciones.Rows)
                {
                    sumaDeducciones += decimal.Parse(fila.Cells[2].Value.ToString());
                }

                sumaPercepciones += subsidio;
                sumaDeducciones = sumaDeducciones - subsidio;

                netoPagar = sumaPercepciones - sumaDeducciones;
                txtPercepciones.Text = "$ " + sumaPercepciones.ToString("#,##0.00");
                txtDeducciones.Text = "$ " + sumaDeducciones.ToString("#,##0.00");
                txtNeto.Text = "$ " + netoPagar.ToString("#,##0.00");

                dgvPercepciones.Columns.Add("dias", "dias");
                if (diasAPagar != 0)
                    dgvPercepciones.Rows[0].Cells[3].Value = diasAPagar.ToString() + " dias";
                if (netoPagar < 0)
                    MessageBox.Show("El neto a pagar es negativo: " + netoPagar.ToString("#,##0.00"), "Información");
            }
        }
        private void cmbPeriodo_SelectedIndexChanged(object sender, EventArgs e)
        {
            int periodo = 0;
            if (cmbPeriodo.Text == "SEMANAL")
                periodo = 7;
            else if (cmbPeriodo.Text == "QUINCENAL")
                periodo = 15;

            cnx = new SqlConnection(cdn);
            cmd = new SqlCommand();
            cmd.Connection = cnx;

            Conceptos.Core.ConceptosHelper ch = new Conceptos.Core.ConceptosHelper();
            ch.Command = cmd;

            Conceptos.Core.Conceptos c = new Conceptos.Core.Conceptos();
            c.idempresa = GLOBALES.IDEMPRESA;

            Conceptos.Core.ConceptosEmpresa ce = new Conceptos.Core.ConceptosEmpresa();
            ce.idempresa = GLOBALES.IDEMPRESA;
            ce.periodo = periodo;

            List<Conceptos.Core.Conceptos> lstConceptos = new List<Conceptos.Core.Conceptos>();
            List<Conceptos.Core.ConceptosEmpresa> lstConceptosEmpresa = new List<Conceptos.Core.ConceptosEmpresa>();

            try
            {
                cnx.Open();
                lstConceptos = ch.obtenerConceptos(c, periodo);
                lstConceptosEmpresa = ch.obtenerConceptosEmpresa(ce);
                cnx.Close();
                cnx.Dispose();
            }
            catch (Exception)
            {
                MessageBox.Show("Error: Al Obtener los conceptos de la empresa.", "Error");
                cnx.Dispose();
            }

            var a = from concepto in lstConceptos
                    join cempresa in lstConceptosEmpresa on concepto.id equals cempresa.idconcepto
                    select new
                    {
                        concepto.id,
                        concepto.noconcepto,
                        concepto.concepto,
                        cempresa.asignacion
                    };

            DataTable dt = new DataTable();
            DataRow dtFila;
            dt.Columns.Add("id", typeof(Int32));
            dt.Columns.Add("noconcepto", typeof(Int32));
            dt.Columns.Add("concepto", typeof(String));
            dt.Columns.Add("asignacion", typeof(Boolean));

            foreach (var b in a)
            {
                dtFila = dt.NewRow();
                dtFila["id"] = b.id;
                dtFila["noconcepto"] = b.noconcepto;
                dtFila["concepto"] = b.concepto;
                dtFila["asignacion"] = b.asignacion;
                dt.Rows.Add(dtFila);
            }

            dgvConceptos.Columns["id"].DataPropertyName = "id";
            dgvConceptos.Columns["noconcepto"].DataPropertyName = "noconcepto";
            dgvConceptos.Columns["concepto"].DataPropertyName = "concepto";
            dgvConceptos.Columns["asignacion"].DataPropertyName = "asignacion";

            dgvConceptos.DataSource = dt;
            for (int i = 0; i < dgvConceptos.Columns.Count; i++)
                dgvConceptos.AutoResizeColumn(i);
        }
示例#8
0
        private void guardar(int tipoGuardar)
        {
            //SE VALIDA SI TODOS LOS TEXTBOX HAN SIDO LLENADOS.
            string control = GLOBALES.VALIDAR(this, typeof(TextBox));
            if (!control.Equals(""))
            {
                MessageBox.Show("Falta el campo: " + control, "Información");
                return;
            }

            cnx = new SqlConnection();
            cnx.ConnectionString = cdn;
            cmd = new SqlCommand();
            cmd.Connection = cnx;
            ch = new Conceptos.Core.ConceptosHelper();
            ch.Command = cmd;

            Conceptos.Core.Conceptos concepto = new Conceptos.Core.Conceptos();
            concepto.idempresa = GLOBALES.IDEMPRESA;
            concepto.concepto = txtConcepto.Text;
            concepto.tipoconcepto = TipoConcepto;
            concepto.noconcepto = int.Parse(txtNoConcepto.Text);
            concepto.formula = txtFormula.Text;
            concepto.formulaexento = txtExento.Text;
            concepto.gravado = chkGrava.Checked;
            concepto.exento = chkExenta.Checked;
            concepto.visible = chkVisible.Checked;
            concepto.gruposat = txtGrupoSat.Text;
            concepto.periodo = int.Parse(cmbPeriodo.SelectedValue.ToString());

            switch (_tipoOperacion)
            {
                case 0:
                    try
                    {
                        cnx.Open();
                        ch.insertaConcepto(concepto);
                        cnx.Close();
                        cnx.Dispose();
                    }
                    catch (Exception error)
                    {
                        MessageBox.Show("Error al ingresar el concepto. \r\n \r\n Error: " + error.Message);
                    }
                    break;
                case 2:
                    try
                    {
                        concepto.id = _idConcepto;
                        cnx.Open();
                        ch.actualizaConcepto(concepto);
                        cnx.Close();
                        cnx.Dispose();
                    }
                    catch (Exception error)
                    {
                        MessageBox.Show("Error al actualizar el concepto. \r\n \r\n Error: " + error.Message);
                    }
                    break;
            }

            switch (tipoGuardar)
            {
                case 0:
                    GLOBALES.LIMPIAR(this, typeof(TextBox));
                    break;
                case 1:
                    if (OnNuevoConcepto != null)
                        OnNuevoConcepto(_tipoOperacion);
                    this.Dispose();
                    break;
            }
        }
        private void ListaConceptos()
        {
            cnx = new SqlConnection(cdn);
            cmd = new SqlCommand();
            cmd.Connection = cnx;
            ch = new Conceptos.Core.ConceptosHelper();
            ch.Command = cmd;

            Conceptos.Core.Conceptos concepto = new Conceptos.Core.Conceptos();
            concepto.idempresa = GLOBALES.IDEMPRESA;

            int periodo = 0;
            if (cmbPeriodos.Text == "SEMANAL")
                periodo = 7;
            else if (cmbPeriodos.Text == "QUINCENAL")
                periodo = 15;

            try
            {
                cnx.Open();
                lstConceptos = ch.obtenerConceptos(concepto, periodo);
                cnx.Close();
                cnx.Dispose();

                var con = from c in lstConceptos
                             select new
                             {
                                 Id = c.id,
                                 Concepto = c.concepto,
                                 Tipo = (c.tipoconcepto == "P") ? "PERCEPCION" : "DEDUCCION",
                                 NoConcepto = c.noconcepto,
                                 Formula = c.formula,
                                 Exento = c.formulaexento
                             };
                dgvConceptos.DataSource = con.ToList();

                for (int i = 0; i < dgvConceptos.Columns.Count; i++)
                {
                    dgvConceptos.AutoResizeColumn(i);
                }
            }
            catch (Exception error)
            {
                MessageBox.Show("Error: \r\n \r\n " + error.Message, "Error");
            }

            dgvConceptos.Columns["Id"].Visible = false;
        }
示例#10
0
        private void frmBuscaConcepto_Load(object sender, EventArgs e)
        {
            lblNombreEmpleado.Text = _nombreEmpleado;

            cnx = new SqlConnection();
            cnx.ConnectionString = cdn;
            cmd = new SqlCommand();
            cmd.Connection = cnx;
            Conceptos.Core.ConceptosHelper ch = new Conceptos.Core.ConceptosHelper();
            ch.Command = cmd;
            Conceptos.Core.Conceptos concepto = new Conceptos.Core.Conceptos();
            concepto.idempresa = GLOBALES.IDEMPRESA;

            Empleados.Core.EmpleadosHelper eh = new Empleados.Core.EmpleadosHelper();
            eh.Command = cmd;

            List<Conceptos.Core.Conceptos> lstConceptos = new List<Conceptos.Core.Conceptos>();

            try
            {
                int periodo = 0;
                cnx.Open();
                periodo = int.Parse(eh.obtenerDiasPeriodo(_idEmpleado).ToString());
                lstConceptos = ch.obtenerConceptos(concepto, periodo);
                cnx.Close();
                cnx.Dispose();
            }
            catch (Exception error)
            {
                MessageBox.Show("Error: \r\n \r\n" + error.Message, "Error");
            }

            cmbConcepto.DataSource = lstConceptos.ToList();
            cmbConcepto.DisplayMember = "concepto";
            cmbConcepto.ValueMember = "id";
        }
示例#11
0
        public static List<CalculoNomina.Core.tmpPagoNomina> PERCEPCIONES(List<CalculoNomina.Core.Nomina> lstConceptosPercepciones,
            DateTime inicio, DateTime fin, int tipoNomina)
        {
            #region VARIABLES GLOBALES
            string cdn = ConfigurationManager.ConnectionStrings["cdnNomina"].ConnectionString;
            SqlConnection cnx = new SqlConnection(cdn);
            SqlCommand cmd = new SqlCommand();
            cmd.Connection = cnx;
            #endregion

            #region LISTA PARA DATOS DEL TRABAJADOR
            List<CalculoNomina.Core.tmpPagoNomina> lstValoresNomina;
            List<CalculoNomina.Core.tmpPagoNomina> lstValoresDefinitivos;
            #endregion

            #region CALCULO
            lstValoresNomina = new List<CalculoNomina.Core.tmpPagoNomina>();
            for (int i = 0; i < lstConceptosPercepciones.Count; i++)
            {
                CalculoNomina.Core.tmpPagoNomina vn = new CalculoNomina.Core.tmpPagoNomina();
                vn.idtrabajador = lstConceptosPercepciones[i].idtrabajador;
                vn.idempresa = GLOBALES.IDEMPRESA;
                vn.idconcepto = lstConceptosPercepciones[i].id;
                vn.noconcepto = lstConceptosPercepciones[i].noconcepto;
                vn.tipoconcepto = lstConceptosPercepciones[i].tipoconcepto;
                vn.fechainicio = inicio.Date;
                vn.fechafin = fin.Date;
                vn.guardada = false;
                vn.tiponomina = tipoNomina;
                vn.modificado = false;

                CalculoFormula formula = new CalculoFormula(lstConceptosPercepciones[i].idtrabajador, inicio.Date, fin.Date, lstConceptosPercepciones[i].formula);
                vn.cantidad = decimal.Parse(formula.calcularFormula().ToString());

                CalculoFormula formulaExcento = new CalculoFormula(lstConceptosPercepciones[i].idtrabajador, inicio.Date, fin.Date, lstConceptosPercepciones[i].formulaexento);
                vn.exento = decimal.Parse(formulaExcento.calcularFormula().ToString());

                Empleados.Core.EmpleadosHelper eh = new Empleados.Core.EmpleadosHelper();
                eh.Command = cmd;

                cnx.Open();
                int idperiodo = (int)eh.obtenerIdPeriodo(lstConceptosPercepciones[i].idtrabajador);
                cnx.Close();

                Periodos.Core.PeriodosHelper ph = new Periodos.Core.PeriodosHelper();
                ph.Command = cmd;

                Periodos.Core.Periodos p = new Periodos.Core.Periodos();
                p.idperiodo = idperiodo;

                cnx.Open();
                int dias = (int)ph.DiasDePago(p);
                cnx.Close();

                Conceptos.Core.ConceptosHelper ch = new Conceptos.Core.ConceptosHelper();
                ch.Command = cmd;

                Conceptos.Core.Conceptos c = new Conceptos.Core.Conceptos();
                c.idempresa = GLOBALES.IDEMPRESA;
                c.noconcepto = lstConceptosPercepciones[i].noconcepto;
                c.tipoconcepto = lstConceptosPercepciones[i].tipoconcepto;
                c.periodo = dias;

                cnx.Open();
                bool grava = (bool)ch.gravaConcepto(c);
                bool exenta = (bool)ch.exentaConcepto(c);
                cnx.Close();

                if (grava && !exenta)
                    vn.gravado = vn.cantidad;

                if (grava && exenta)
                {
                    if (vn.cantidad <= vn.exento)
                    {
                        vn.exento = vn.cantidad;
                        vn.gravado = 0;
                    }
                    else
                    {
                        vn.gravado = vn.cantidad - vn.exento;
                    }
                }

                if (!grava && exenta)
                {
                    vn.gravado = 0;
                    vn.exento = vn.cantidad;
                }

                #region SWITCH SUELDO CERO
                switch (lstConceptosPercepciones[i].noconcepto)
                {
                    case 1:
                        if (vn.cantidad == 0)
                        {
                            vn.gravado = 0;
                            lstValoresNomina.Add(vn);

                            Vacaciones.Core.VacacionesHelper vh = new Vacaciones.Core.VacacionesHelper();
                            vh.Command = cmd;
                            Vacaciones.Core.VacacionesPrima vp = new Vacaciones.Core.VacacionesPrima();
                            vp.idtrabajador = lstConceptosPercepciones[i].idtrabajador;
                            vp.idempresa = GLOBALES.IDEMPRESA;
                            vp.periodofin = fin.Date;
                            vp.periodoinicio = inicio.Date;
                            vp.vacacionesprima = "V";

                            cnx.Open();
                            int diasVacaciones = (int)vh.pagoVacacionesPrima(vp);
                            cnx.Close();

                            if (diasVacaciones == 0)
                            {
                                i++;
                                int contadorDatosNomina = i;
                                for (int j = i; j < lstConceptosPercepciones.Count; j++)
                                {
                                    contadorDatosNomina = j;
                                    if (lstConceptosPercepciones[j].idtrabajador == vn.idtrabajador)
                                    {
                                        CalculoNomina.Core.tmpPagoNomina vnCero = new CalculoNomina.Core.tmpPagoNomina();
                                        vnCero.idtrabajador = lstConceptosPercepciones[j].idtrabajador;
                                        vnCero.idempresa = GLOBALES.IDEMPRESA;
                                        vnCero.idconcepto = lstConceptosPercepciones[j].id;
                                        vnCero.noconcepto = lstConceptosPercepciones[j].noconcepto;
                                        vnCero.tipoconcepto = lstConceptosPercepciones[j].tipoconcepto;
                                        vnCero.fechainicio = inicio.Date;
                                        vnCero.fechafin = fin.Date;
                                        vnCero.guardada = false;
                                        vnCero.tiponomina = tipoNomina;
                                        vnCero.modificado = false;
                                        vnCero.cantidad = 0;
                                        vnCero.exento = 0;
                                        vnCero.gravado = 0;
                                        lstValoresNomina.Add(vnCero);
                                    }
                                    else
                                    {
                                        --contadorDatosNomina;
                                        break;
                                    }
                                }
                                i = contadorDatosNomina;
                            }
                        }
                        else
                            lstValoresNomina.Add(vn);
                        break;
                    default:
                        lstValoresNomina.Add(vn);
                        break;
                }
                #endregion
            }
            #endregion

            #region EXISTENCIA DEL CONCEPTO EN TABLA
            int existe = 0;
            CalculoNomina.Core.NominaHelper nh = new CalculoNomina.Core.NominaHelper();
            nh.Command = cmd;
            lstValoresDefinitivos = new List<CalculoNomina.Core.tmpPagoNomina>();
            for (int i = 0; i < lstValoresNomina.Count; i++)
            {
                CalculoNomina.Core.tmpPagoNomina vn = new CalculoNomina.Core.tmpPagoNomina();
                vn.idtrabajador = lstValoresNomina[i].idtrabajador;
                vn.idempresa = GLOBALES.IDEMPRESA;
                vn.idconcepto = lstValoresNomina[i].idconcepto;
                vn.noconcepto = lstValoresNomina[i].noconcepto;
                vn.tipoconcepto = lstValoresNomina[i].tipoconcepto;
                vn.fechainicio = lstValoresNomina[i].fechainicio;
                vn.fechafin = lstValoresNomina[i].fechafin;
                vn.guardada = lstValoresNomina[i].guardada;
                vn.tiponomina = lstValoresNomina[i].tiponomina;
                vn.modificado = lstValoresNomina[i].modificado;
                vn.exento = lstValoresNomina[i].exento;
                vn.gravado = lstValoresNomina[i].gravado;
                vn.cantidad = lstValoresNomina[i].cantidad;

                cnx.Open();
                existe = (int)nh.existeConcepto(vn);
                cnx.Close();

                if (existe == 0)
                {
                    lstValoresDefinitivos.Add(vn);
                }
                else
                {
                    cnx.Open();
                    nh.actualizaConcepto(vn);
                    cnx.Close();
                }
            }
            #endregion

            return lstValoresDefinitivos;
        }
        private void dgvEmpleados_CellValueChanged(object sender, DataGridViewCellEventArgs e)
        {
            if (lstValoresNomina == null)
                return;

            cnx = new SqlConnection(cdn);
            cmd.Connection = cnx;

            if (dgvEmpleados.Columns[e.ColumnIndex].Name == "horas")
            {
                for (int i = 0; i < lstValoresNomina.Count(); i++)
                {
                    if (int.Parse(dgvEmpleados.Rows[e.RowIndex].Cells["idtrabajador"].Value.ToString()) == lstValoresNomina[i].idtrabajador && lstValoresNomina[i].noconcepto == 2)
                    {
                        nh = new CalculoNomina.Core.NominaHelper();
                        nh.Command = cmd;

                        Conceptos.Core.ConceptosHelper ch = new Conceptos.Core.ConceptosHelper();
                        ch.Command = cmd;

                        Conceptos.Core.Conceptos concepto = new Conceptos.Core.Conceptos();
                        concepto.noconcepto = 2;
                        concepto.idempresa = GLOBALES.IDEMPRESA;

                        cnx.Open();
                        string formulaexento = ch.obtenerFormulaExento(concepto).ToString();
                        cnx.Close();

                        CalculoFormula cf = new CalculoFormula(lstValoresNomina[i].idtrabajador, periodoInicio.Date, periodoFin.Date, formulaexento);
                        decimal exento = decimal.Parse(cf.calcularFormula().ToString());
                        decimal cantidad = decimal.Parse(dgvEmpleados.Rows[e.RowIndex].Cells["horas"].Value.ToString());
                        decimal gravado = 0;

                        if (cantidad <= exento)
                        {
                            exento = cantidad;
                            gravado = 0;
                        }
                        else
                        {
                            gravado = cantidad - exento;
                        }

                        CalculoNomina.Core.tmpPagoNomina hora = new CalculoNomina.Core.tmpPagoNomina();
                        hora.idempresa = GLOBALES.IDEMPRESA;
                        hora.idtrabajador = int.Parse(dgvEmpleados.Rows[e.RowIndex].Cells["idtrabajador"].Value.ToString());
                        hora.noconcepto = 2; //CONCEPTO HORAS EXTRAS DOBLES
                        hora.fechainicio = periodoInicio.Date;
                        hora.fechafin = periodoFin.Date;
                        hora.cantidad = cantidad;
                        hora.exento = exento;
                        hora.gravado = gravado;
                        hora.modificado = true;
                        try
                        {
                            cnx.Open();
                            nh.actualizaHorasExtrasDespensa(hora);
                            cnx.Close();
                        }
                        catch (Exception error)
                        {
                            MessageBox.Show("Error: \r\n \r\n" + error.Message, "Error");
                        }
                    }
                }
            }

            if (dgvEmpleados.Columns[e.ColumnIndex].Name == "despensa")
            {
                for (int i = 0; i < lstValoresNomina.Count(); i++)
                {
                    if (int.Parse(dgvEmpleados.Rows[e.RowIndex].Cells["idtrabajador"].Value.ToString()) == lstValoresNomina[i].idtrabajador && lstValoresNomina[i].noconcepto == 6)
                    {
                        nh = new CalculoNomina.Core.NominaHelper();
                        nh.Command = cmd;
                        lstValoresNomina[i].cantidad = decimal.Parse(dgvEmpleados.Rows[e.RowIndex].Cells["despensa"].Value.ToString());
                        lstValoresNomina[i].gravado = decimal.Parse(dgvEmpleados.Rows[e.RowIndex].Cells["despensa"].Value.ToString());
                        CalculoNomina.Core.tmpPagoNomina despensa = new CalculoNomina.Core.tmpPagoNomina();
                        despensa.idempresa = GLOBALES.IDEMPRESA;
                        despensa.idtrabajador = int.Parse(dgvEmpleados.Rows[e.RowIndex].Cells["idtrabajador"].Value.ToString());
                        despensa.noconcepto = 6; //CONCEPTO DESPENSA
                        despensa.fechainicio = periodoInicio.Date;
                        despensa.fechafin = periodoFin.Date;
                        despensa.cantidad = lstValoresNomina[i].cantidad;
                        despensa.gravado = lstValoresNomina[i].gravado;
                        despensa.modificado = true;
                        try
                        {
                            cnx.Open();
                            nh.actualizaHorasExtrasDespensa(despensa);
                            cnx.Close();
                        }
                        catch (Exception error)
                        {
                            MessageBox.Show("Error: \r\n \r\n" + error.Message, "Error");
                        }
                    }
                }
            }
        }
        private void workerCalculo_DoWork(object sender, DoWorkEventArgs e)
        {
            cnx = new SqlConnection(cdn);
            cmd = new SqlCommand();
            cmd.Connection = cnx;

            CalculoNomina.Core.NominaHelper nh = new CalculoNomina.Core.NominaHelper();
            nh.Command = cmd;

            Empleados.Core.EmpleadosHelper eh = new Empleados.Core.EmpleadosHelper();
            eh.Command = cmd;

            Altas.Core.AltasHelper ah = new Altas.Core.AltasHelper();
            ah.Command = cmd;

            Reingreso.Core.ReingresoHelper rh = new Reingreso.Core.ReingresoHelper();
            rh.Command = cmd;

            int estatus = 0;
            int existeAltaReingreso = 0;

            #region LISTAS
            List<CalculoNomina.Core.Nomina> lstConceptosPercepciones = new List<CalculoNomina.Core.Nomina>();
            List<CalculoNomina.Core.Nomina> lstConceptosDeducciones = new List<CalculoNomina.Core.Nomina>();

            List<CalculoNomina.Core.Nomina> lstConceptosPercepcionesModificados = new List<CalculoNomina.Core.Nomina>();
            List<CalculoNomina.Core.Nomina> lstConceptosDeduccionesModificados = new List<CalculoNomina.Core.Nomina>();
            #endregion

            int progreso = 0, total = 0, indice = 0;
            int existeConcepto = 0;
            total = dgvEmpleados.Rows.Count;

            StreamWriter swLog = new StreamWriter(@"C:\Temp\LogHealthTrabajador" + DateTime.Now.Year.ToString() + "_" + DateTime.Now.Month.ToString() + "_" +
                        DateTime.Now.Day.ToString() + "_" + DateTime.Now.Minute.ToString() + ".txt", true);
            swLog.WriteLine(String.Format("Calculo de Nómina: Del {0} al {1}", periodoInicio.ToShortDateString(), periodoFin.ToShortDateString()));

            foreach (DataGridViewRow fila in dgvEmpleados.Rows)
            {
                try
                {
                    cnx.Open();
                    estatus = int.Parse(eh.obtenerEstatus(int.Parse(fila.Cells["idtrabajador"].Value.ToString())).ToString());
                    cnx.Close();

                    swLog.WriteLine(String.Format("Empleado: {0}, Estatus: {1}", fila.Cells["idtrabajador"].Value.ToString(), estatus.ToString()));

                    if (estatus == 0)
                    {
                        cnx.Open();
                        nh.eliminaPreNomina(int.Parse(fila.Cells["idtrabajador"].Value.ToString()));
                        cnx.Close();
                        swLog.WriteLine(String.Format("Empleado: {0}, Se elimina Prenomina", fila.Cells["idtrabajador"].Value.ToString()));
                        continue;
                    }
                    else
                    {

                        cnx.Open();
                        existeAltaReingreso = ah.existeAlta(GLOBALES.IDEMPRESA, int.Parse(fila.Cells["idtrabajador"].Value.ToString()), periodoInicioPosterior, periodoFinPosterior);
                        cnx.Close();
                        swLog.WriteLine(String.Format("Empleado: {0}, Existencia de Alta: {1}, Fecha Inicio: {2}, Fecha Fin: {3} ", fila.Cells["idtrabajador"].Value.ToString(), existeAltaReingreso, periodoInicioPosterior.ToShortDateString(), periodoFinPosterior.ToShortDateString()));
                        if (existeAltaReingreso != 0)
                        {
                            cnx.Open();
                            nh.eliminaPreNomina(int.Parse(fila.Cells["idtrabajador"].Value.ToString()));
                            cnx.Close();
                            swLog.WriteLine(String.Format("Empleado: {0}, Se elimina Prenomina", fila.Cells["idtrabajador"].Value.ToString()));
                            continue;
                        }

                        cnx.Open();
                        existeAltaReingreso = rh.existeReingreso(GLOBALES.IDEMPRESA, int.Parse(fila.Cells["idtrabajador"].Value.ToString()), periodoInicioPosterior, periodoFinPosterior);
                        cnx.Close();
                        swLog.WriteLine(String.Format("Empleado: {0}, Existencia de Reingreso: {1}, Fecha Inicio: {2}, Fecha Fin: {3} ", fila.Cells["idtrabajador"].Value.ToString(), existeAltaReingreso, periodoInicioPosterior.ToShortDateString(), periodoFinPosterior.ToShortDateString()));
                        if (existeAltaReingreso != 0)
                        {
                            cnx.Open();
                            nh.eliminaPreNomina(int.Parse(fila.Cells["idtrabajador"].Value.ToString()));
                            cnx.Close();
                            swLog.WriteLine(String.Format("Empleado: {0}, Se elimina Prenomina", fila.Cells["idtrabajador"].Value.ToString()));
                            continue;
                        }

                    }
                }
                catch (Exception error)
                {
                    MessageBox.Show("Error al verificar el estatus del trabajador: " + fila.Cells["noempleado"].Value.ToString() + "\r\n\r\n" + error.Message, "Error");
                    cnx.Close();
                    continue;
                }

                progreso = (indice * 100) / total;
                indice++;

                if (FLAGPRIMERCALCULO)
                {
                    workerCalculo.ReportProgress(progreso, "CARGANDO DATOS DE LOS TRABAJADORES. ESPERE A QUE TERMINE EL PROCESO.");
                }
                else
                    workerCalculo.ReportProgress(progreso, "CALCULANDO.");

                #region CONCEPTOS Y FORMULAS DEL TRABAJADOR
                try
                {
                    cnx.Open();
                    nh.eliminaNominaTrabajador(int.Parse(fila.Cells["idtrabajador"].Value.ToString()), periodoInicio.Date, periodoFin.Date, _tipoNomina);
                    lstConceptosPercepciones = nh.conceptosNominaTrabajador(GLOBALES.IDEMPRESA, "P", int.Parse(fila.Cells["idtrabajador"].Value.ToString()), periodoInicio.Date, periodoFin.Date, _periodo);
                    lstConceptosDeducciones = nh.conceptosNominaTrabajador(GLOBALES.IDEMPRESA, "D", int.Parse(fila.Cells["idtrabajador"].Value.ToString()), periodoInicio.Date, periodoFin.Date, _periodo);
                    cnx.Close();
                }
                catch (Exception error)
                {
                    MessageBox.Show("Error: CONCEPTOS Y FORMULAS DEL TRABAJADOR. Primer Calculo." +
                        " ID Trabajador: " + int.Parse(fila.Cells["idtrabajador"].Value.ToString()) +
                        "\r\n \r\n" + error.Message, "Error");
                    cnx.Dispose();
                    return;
                }
                #endregion

                #region CALCULO DE PERCEPCIONES
                List<CalculoNomina.Core.tmpPagoNomina> lstPercepciones = new List<CalculoNomina.Core.tmpPagoNomina>();
                lstPercepciones = CALCULO.PERCEPCIONES(lstConceptosPercepciones, periodoInicio.Date, periodoFin.Date, _tipoNomina);
                #endregion

                #region BULK DATOS PERCEPCIONES
                BulkData(lstPercepciones);
                #endregion

                #region OBTENCION DE PERCEPCIONES
                lstPercepciones = new List<CalculoNomina.Core.tmpPagoNomina>();
                CalculoNomina.Core.tmpPagoNomina per = new CalculoNomina.Core.tmpPagoNomina();
                per.idempresa = GLOBALES.IDEMPRESA;
                per.idtrabajador = int.Parse(fila.Cells["idtrabajador"].Value.ToString());
                per.fechainicio = periodoInicio.Date;
                per.fechafin = periodoFin;
                per.tipoconcepto = "P";
                per.tiponomina = _tipoNomina;
                cnx.Open();
                lstPercepciones = nh.obtenerPercepcionesTrabajador(per);
                cnx.Close();
                #endregion

                #region CALCULO DE DEDUCCIONES
                List<CalculoNomina.Core.tmpPagoNomina> lstDeducciones = new List<CalculoNomina.Core.tmpPagoNomina>();
                lstDeducciones = CALCULO.DEDUCCIONES(lstConceptosDeducciones, lstPercepciones, periodoInicio.Date, periodoFin.Date, _tipoNomina);
                #endregion

                #region BULK DATOS DEDUCCIONES
                BulkData(lstDeducciones);
                #endregion

                #region PROGRAMACION DE MOVIMIENTOS
                List<CalculoNomina.Core.tmpPagoNomina> lstOtrasDeducciones = new List<CalculoNomina.Core.tmpPagoNomina>();
                ProgramacionConcepto.Core.ProgramacionHelper pch = new ProgramacionConcepto.Core.ProgramacionHelper();
                pch.Command = cmd;

                decimal percepciones = lstPercepciones.Where(f => f.tipoconcepto == "P").Sum(f => f.cantidad);

                if (percepciones != 0)
                {
                    int existe = 0;
                    ProgramacionConcepto.Core.ProgramacionConcepto programacion = new ProgramacionConcepto.Core.ProgramacionConcepto();
                    programacion.idtrabajador = int.Parse(fila.Cells["idtrabajador"].Value.ToString());

                    List<ProgramacionConcepto.Core.ProgramacionConcepto> lstProgramacion = new List<ProgramacionConcepto.Core.ProgramacionConcepto>();

                    try
                    {
                        cnx.Open();
                        existe = (int)pch.existeProgramacion(programacion);
                        cnx.Close();
                    }
                    catch (Exception error)
                    {
                        MessageBox.Show("Error: \r\n \r\n" + error.Message, "Error");
                        cnx.Dispose();
                    }

                    if (existe != 0)
                    {
                        try
                        {
                            cnx.Open();
                            lstProgramacion = pch.obtenerProgramacion(programacion);
                            cnx.Close();
                        }
                        catch (Exception error)
                        {
                            MessageBox.Show("Error: \r\n \r\n" + error.Message, "Error");
                            cnx.Dispose();
                        }

                        for (int i = 0; i < lstProgramacion.Count; i++)
                        {
                            if (periodoFin.Date <= lstProgramacion[i].fechafin)
                            {
                                Conceptos.Core.ConceptosHelper ch = new Conceptos.Core.ConceptosHelper();
                                ch.Command = cmd;
                                Conceptos.Core.Conceptos concepto = new Conceptos.Core.Conceptos();
                                concepto.id = lstProgramacion[i].idconcepto;
                                List<Conceptos.Core.Conceptos> lstNoConcepto = new List<Conceptos.Core.Conceptos>();
                                try
                                {
                                    cnx.Open();
                                    lstNoConcepto = ch.obtenerConcepto(concepto);
                                    cnx.Close();
                                }
                                catch (Exception error) { MessageBox.Show("Error: \r\n \r\n" + error.Message, "Error"); }

                                CalculoNomina.Core.tmpPagoNomina pne = new CalculoNomina.Core.tmpPagoNomina();
                                pne.idempresa = GLOBALES.IDEMPRESA;
                                pne.idtrabajador = int.Parse(fila.Cells["idtrabajador"].Value.ToString());
                                pne.fechainicio = periodoInicio.Date;
                                pne.fechafin = periodoFin.Date;
                                pne.noconcepto = lstNoConcepto[0].noconcepto;

                                try
                                {
                                    cnx.Open();
                                    existeConcepto = (int)nh.existeConcepto(pne);
                                    cnx.Close();
                                }
                                catch
                                {
                                    MessageBox.Show("Error al obtener la existencia del concepto.", "Error");
                                    cnx.Dispose();
                                }

                                CalculoNomina.Core.tmpPagoNomina vn = new CalculoNomina.Core.tmpPagoNomina();
                                vn.idtrabajador = int.Parse(fila.Cells["idtrabajador"].Value.ToString());
                                vn.idempresa = GLOBALES.IDEMPRESA;
                                vn.idconcepto = lstProgramacion[i].idconcepto;
                                vn.noconcepto = lstNoConcepto[0].noconcepto;
                                vn.tipoconcepto = lstNoConcepto[0].tipoconcepto;
                                vn.fechainicio = periodoInicio.Date;
                                vn.fechafin = periodoFin.Date;
                                vn.exento = 0;
                                vn.gravado = 0;
                                vn.cantidad = lstProgramacion[i].cantidad;
                                vn.guardada = false;
                                vn.tiponomina = _tipoNomina;
                                vn.modificado = false;
                                vn.obracivil = _obracivil;

                                if (lstNoConcepto[0].gravado && !lstNoConcepto[0].exento)
                                {
                                    vn.gravado = lstProgramacion[i].cantidad;
                                    vn.exento = 0;
                                }

                                if (lstNoConcepto[0].gravado && lstNoConcepto[0].exento)
                                {
                                    CalculoFormula formulaExcento = new CalculoFormula(int.Parse(fila.Cells["idtrabajador"].Value.ToString()), periodoInicio.Date, periodoFin.Date, lstNoConcepto[0].formulaexento);
                                    vn.exento = decimal.Parse(formulaExcento.calcularFormula().ToString());
                                    if (vn.cantidad <= vn.exento)
                                    {
                                        vn.exento = vn.cantidad;
                                        vn.gravado = 0;
                                    }
                                    else
                                    {
                                        vn.gravado = vn.cantidad - vn.exento;
                                    }
                                }

                                if (!lstNoConcepto[0].gravado && lstNoConcepto[0].exento)
                                {
                                    vn.gravado = 0;
                                    vn.exento = lstProgramacion[i].cantidad;
                                }

                                if (existeConcepto == 0)
                                {
                                    lstOtrasDeducciones.Add(vn);
                                }
                                else
                                {
                                    try
                                    {
                                        cnx.Open();
                                        nh.actualizaConceptoModificado(vn);
                                        cnx.Close();
                                    }
                                    catch
                                    {
                                        MessageBox.Show("Error al actualizar el concepto.", "Error");
                                        cnx.Dispose();
                                    }
                                }
                            }
                        }
                    }
                }
                #endregion

                #region MOVIMIENTOS
                Movimientos.Core.MovimientosHelper mh = new Movimientos.Core.MovimientosHelper();
                mh.Command = cmd;

                if (percepciones != 0)
                {
                    int existe = 0;
                    Movimientos.Core.Movimientos mov = new Movimientos.Core.Movimientos();
                    mov.idtrabajador = int.Parse(fila.Cells["idtrabajador"].Value.ToString());
                    mov.fechainicio = periodoInicio.Date;
                    mov.fechafin = periodoFin.Date;

                    List<Movimientos.Core.Movimientos> lstMovimiento = new List<Movimientos.Core.Movimientos>();

                    try
                    {
                        cnx.Open();
                        existe = (int)mh.existeMovimiento(mov);
                        cnx.Close();
                    }
                    catch (Exception error)
                    {
                        MessageBox.Show("Error: \r\n \r\n" + error.Message, "Error");
                        cnx.Dispose();
                    }

                    if (existe != 0)
                    {
                        try
                        {
                            cnx.Open();
                            lstMovimiento = mh.obtenerMovimiento(mov);
                            cnx.Close();
                        }
                        catch (Exception error)
                        {
                            MessageBox.Show("Error: \r\n \r\n" + error.Message, "Error");
                            cnx.Dispose();
                        }

                        for (int i = 0; i < lstMovimiento.Count; i++)
                        {
                            Conceptos.Core.ConceptosHelper ch = new Conceptos.Core.ConceptosHelper();
                            ch.Command = cmd;
                            Conceptos.Core.Conceptos concepto = new Conceptos.Core.Conceptos();
                            concepto.id = lstMovimiento[i].idconcepto;
                            List<Conceptos.Core.Conceptos> lstNoConcepto = new List<Conceptos.Core.Conceptos>();
                            try
                            {
                                cnx.Open();
                                lstNoConcepto = ch.obtenerConcepto(concepto);
                                cnx.Close();
                            }
                            catch (Exception error) { MessageBox.Show("Error: \r\n \r\n" + error.Message, "Error"); }

                            CalculoNomina.Core.tmpPagoNomina vn = new CalculoNomina.Core.tmpPagoNomina();
                            vn.idtrabajador = int.Parse(fila.Cells["idtrabajador"].Value.ToString()); ;
                            vn.idempresa = GLOBALES.IDEMPRESA;
                            vn.idconcepto = lstMovimiento[i].idconcepto;
                            vn.noconcepto = lstNoConcepto[0].noconcepto;
                            vn.tipoconcepto = lstNoConcepto[0].tipoconcepto;
                            vn.fechainicio = periodoInicio.Date;
                            vn.fechafin = periodoFin.Date;
                            vn.exento = 0;
                            vn.gravado = 0;
                            vn.cantidad = lstMovimiento[i].cantidad;
                            vn.guardada = false;
                            vn.tiponomina = _tipoNomina;
                            vn.modificado = false;

                            if (lstNoConcepto[0].gravado && !lstNoConcepto[0].exento)
                            {
                                vn.gravado = lstMovimiento[i].cantidad;
                                vn.exento = 0;
                            }

                            if (lstNoConcepto[0].gravado && lstNoConcepto[0].exento)
                            {
                                CalculoFormula formulaExcento = new CalculoFormula(int.Parse(fila.Cells["idtrabajador"].Value.ToString()), periodoInicio.Date, periodoFin.Date, lstNoConcepto[0].formulaexento);
                                vn.exento = decimal.Parse(formulaExcento.calcularFormula().ToString());
                                if (vn.cantidad <= vn.exento)
                                {
                                    vn.exento = vn.cantidad;
                                    vn.gravado = 0;
                                }
                                else
                                {
                                    vn.gravado = vn.cantidad - vn.exento;
                                }
                            }

                            if (!lstNoConcepto[0].gravado && lstNoConcepto[0].exento)
                            {
                                vn.gravado = 0;
                                vn.exento = lstMovimiento[i].cantidad;
                            }

                            cnx.Open();
                            existe = (int)nh.existeConcepto(vn);
                            cnx.Close();

                            if (existe == 0)
                            {
                                lstOtrasDeducciones.Add(vn);
                            }
                            else
                            {
                                cnx.Open();
                                nh.actualizaConcepto(vn);
                                cnx.Close();
                            }
                        }
                    }
                }
                #endregion

                #region BULK DATOS PROGRAMACION DE MOVIMIENTOS
                BulkData(lstOtrasDeducciones);
                #endregion

                #region APLICACION DE DEPTOS/PUESTOS
                Aplicaciones.Core.AplicacionesHelper aplicah = new Aplicaciones.Core.AplicacionesHelper();
                aplicah.Command = cmd;
                Aplicaciones.Core.Aplicaciones aplicacion = new Aplicaciones.Core.Aplicaciones();
                aplicacion.periodoinicio = periodoInicio;
                aplicacion.periodofin = periodoFin;
                aplicacion.idempresa = GLOBALES.IDEMPRESA;
                List<Aplicaciones.Core.Aplicaciones> lstAplicaciones = new List<Aplicaciones.Core.Aplicaciones>();
                try
                {
                    cnx.Open();
                    lstAplicaciones = aplicah.obtenerFechasDeAplicacion(aplicacion);
                    cnx.Close();
                }
                catch (Exception)
                {

                    throw;
                }

                if (lstAplicaciones.Count != 0)
                {
                    for (int i = 0; i < lstAplicaciones.Count; i++)
                    {
                        Empleados.Core.EmpleadosHelper emph = new Empleados.Core.EmpleadosHelper();
                        emph.Command = cmd;

                        try
                        {
                            cnx.Open();
                            emph.actualizaDeptoPuesto(lstAplicaciones[i].iddeptopuesto, lstAplicaciones[i].idtrabajador, lstAplicaciones[i].deptopuesto);
                            aplicah.eliminaAplicacion(lstAplicaciones[i].id);
                            cnx.Close();
                        }
                        catch (Exception)
                        {
                            MessageBox.Show("Error: Al modificar y/o eliminar el depto/puesto o aplicación.", "Error");
                            cnx.Dispose();
                        }
                    }
                }
                #endregion
            }
            swLog.Close();

            #region PERIODO
            calculoNoPeriodo();
            #endregion

            #region NETOS NEGATIVOS
            nh = new CalculoNomina.Core.NominaHelper();
            nh.Command = cmd;
            List<CalculoNomina.Core.NetosNegativos> lstNetos;
            int contadorNetosNegativos = 0;
            StreamWriter sw = new StreamWriter(@"C:\Temp\NetosNegativos" + periodoInicio.Year.ToString() + "_" + periodoInicio.Month.ToString() + "_" +
                        periodoInicio.Day.ToString() + ".txt", true);

            foreach (DataGridViewRow fila in dgvEmpleados.Rows)
            {
                lstNetos = new List<CalculoNomina.Core.NetosNegativos>();
                try
                {
                    cnx.Open();
                    lstNetos = nh.obtenerNetosNegativos(GLOBALES.IDEMPRESA, periodoInicio.Date, periodoFin.Date,
                        int.Parse(fila.Cells["idtrabajador"].Value.ToString()));
                    cnx.Close();

                    decimal sumaPercepciones =  lstNetos.Where(n => n.tipoconcepto == "P").Sum(n => n.cantidad);
                    decimal sumaDeducciones = lstNetos.Where(n => n.tipoconcepto == "D").Sum(n => n.cantidad);
                    decimal subsidio = lstNetos.Where(d => d.noconcepto == 16).Sum(d => d.cantidad);
                    decimal netoPagar = 0;
                    sumaPercepciones = sumaPercepciones + subsidio;
                    sumaDeducciones = sumaDeducciones - subsidio;
                    netoPagar = sumaPercepciones - sumaDeducciones;

                    string linea1 = "";
                    string noEmpleado = "", nombreCompleto = "";
                    noEmpleado = fila.Cells["noempleado"].Value.ToString();
                    nombreCompleto = fila.Cells["nombres"].Value.ToString() + " " + fila.Cells["paterno"].Value.ToString() + " " + fila.Cells["materno"].Value.ToString();
                    if (netoPagar < 0)
                    {
                        contadorNetosNegativos++;
                        linea1 = noEmpleado + ", " + nombreCompleto + ", Cantidad Neta Negativa: " + netoPagar.ToString();
                        sw.WriteLine(linea1);
                    }
                }
                catch (Exception error)
                {
                    MessageBox.Show("Error: Lista de Netos. \r\n \r\n" + error.Message, "Error");
                    cnx.Dispose();
                }
            }

            sw.WriteLine("TOTAL CANTIDADES NEGATIVAS: " + contadorNetosNegativos.ToString());
            sw.Close();
            if (contadorNetosNegativos != 0)
            {
                MessageBox.Show("CANTIDADES NEGATIVAS. VERIFIQUE ARCHIVO EN C:\\Temp\\NetosNegativos" +
                   periodoInicio.Year.ToString() + "_" +
                   periodoInicio.Month.ToString() + "_" +
                   periodoInicio.Day.ToString() + ".txt", "Información");
            }

            #endregion
        }
        private void workMovimientos_DoWork(object sender, DoWorkEventArgs e)
        {
            string formulaexento = "";
            int idConcepto = 0, idEmpleado = 0;
            int existeConcepto = 0;
            int idPeriodo = 0, diasPeriodo = 0;
            cnx = new SqlConnection(cdn);
            cmd = new SqlCommand();
            cmd.Connection = cnx;

            List<CalculoNomina.Core.tmpPagoNomina> lstMovimientos = new List<CalculoNomina.Core.tmpPagoNomina>();
            List<Movimientos.Core.Movimientos> lstOtrasDeducciones = new List<Movimientos.Core.Movimientos>();

            CalculoNomina.Core.NominaHelper nh = new CalculoNomina.Core.NominaHelper();
            nh.Command = cmd;

            Movimientos.Core.MovimientosHelper mh = new Movimientos.Core.MovimientosHelper();
            mh.Command = cmd;

            ch = new Conceptos.Core.ConceptosHelper();
            ch.Command = cmd;

            emph = new Empleados.Core.EmpleadosHelper();
            emph.Command = cmd;

            foreach (DataGridViewRow fila in dgvMovimientos.Rows)
            {
                Empleados.Core.EmpleadosHelper empleadosHelper = new Empleados.Core.EmpleadosHelper();
                empleadosHelper.Command = cmd;

                cnx.Open();
                idEmpleado = (int)emph.obtenerIdTrabajador(fila.Cells["noempleado"].Value.ToString(), idEmpresa);
                idPeriodo = int.Parse(empleadosHelper.obtenerIdPeriodo(idEmpleado).ToString());
                cnx.Close();

                Periodos.Core.PeriodosHelper periodoHelper = new Periodos.Core.PeriodosHelper();
                periodoHelper.Command = cmd;

                Periodos.Core.Periodos periodos = new Periodos.Core.Periodos();
                periodos.idperiodo = idPeriodo;

                cnx.Open();
                diasPeriodo = int.Parse(periodoHelper.DiasDePago(periodos).ToString());
                cnx.Close();

                try
                {
                    cnx.Open();
                    idConcepto = (int)ch.obtenerIdConcepto(fila.Cells["concepto"].Value.ToString().TrimStart().TrimEnd(), idEmpresa, diasPeriodo);
                    cnx.Close();

                }
                catch (Exception error)
                {
                    MessageBox.Show("Error: Obtener ID del concepto. \r\n " +
                        fila.Cells["concepto"].Value.ToString() + "\r\n" +
                        "No. Empleado: " + fila.Cells["noempleado"].Value.ToString() + "\r\n" +
                        error.Message, "Error");
                    return;
                }

                Conceptos.Core.Conceptos concepto = new Conceptos.Core.Conceptos();
                concepto.id = idConcepto;

                List<Conceptos.Core.Conceptos> lstConcepto = new List<Conceptos.Core.Conceptos>();

                try
                {
                    cnx.Open();
                    lstConcepto = ch.obtenerConcepto(concepto);
                    cnx.Close();
                }
                catch {
                    MessageBox.Show("Error al obtener el concepto. \r\n \r\n Esta ventana se cerrará.", "Error");
                    cnx.Dispose();
                    this.Dispose();
                }

                CalculoNomina.Core.tmpPagoNomina pn = new CalculoNomina.Core.tmpPagoNomina();
                pn.idempresa = GLOBALES.IDEMPRESA;
                pn.idtrabajador = idEmpleado;
                pn.idconcepto = idConcepto;
                pn.noconcepto = lstConcepto[0].noconcepto;
                pn.tipoconcepto = lstConcepto[0].tipoconcepto;
                pn.fechainicio = DateTime.Parse(dgvMovimientos.Rows[0].Cells["inicio"].Value.ToString());
                pn.fechafin = DateTime.Parse(dgvMovimientos.Rows[0].Cells["fin"].Value.ToString());
                pn.modificado = true;
                pn.guardada = false;
                pn.tiponomina = _tipoNomina;

                CalculoNomina.Core.tmpPagoNomina pne;

                switch (lstConcepto[0].tipoconcepto)
                {
                    #region PERCEPCIONES
                    case "P":
                        Conceptos.Core.Conceptos _concepto = new Conceptos.Core.Conceptos();
                        concepto.noconcepto = lstConcepto[0].noconcepto;
                        concepto.idempresa = GLOBALES.IDEMPRESA;

                        try
                        {
                            cnx.Open();
                            formulaexento = ch.obtenerFormulaExento(concepto).ToString();
                            cnx.Close();
                        }
                        catch
                        {
                            MessageBox.Show("Error al obtener la formula de exento.\r\n \r\n Esta ventana se cerrará.", "Error");
                            cnx.Dispose();
                            workMovimientos.CancelAsync();
                            this.Dispose();
                        }

                        if (formulaexento == "0")
                        {
                            pn.cantidad = decimal.Parse(fila.Cells["cantidad"].Value.ToString());
                            pn.exento = 0;
                            pn.gravado = decimal.Parse(fila.Cells["cantidad"].Value.ToString());
                        }
                        else {
                            CalculoFormula cf = new CalculoFormula(idEmpleado,
                                DateTime.Parse(dgvMovimientos.Rows[0].Cells["inicio"].Value.ToString()),
                                DateTime.Parse(dgvMovimientos.Rows[0].Cells["fin"].Value.ToString()),
                                formulaexento);

                            decimal exento = decimal.Parse(cf.calcularFormula().ToString());
                            decimal cantidad = decimal.Parse(fila.Cells["cantidad"].Value.ToString());
                            decimal gravado = 0;

                            if (cantidad <= exento)
                            {
                                exento = cantidad;
                                gravado = 0;
                            }
                            else
                            {
                                gravado = cantidad - exento;
                            }

                            pn.cantidad = cantidad;
                            pn.exento = exento;
                            pn.gravado = gravado;
                        }

                        pne = new CalculoNomina.Core.tmpPagoNomina();
                        pne.idempresa = GLOBALES.IDEMPRESA;
                        pne.idtrabajador = idEmpleado;
                        pne.fechainicio = DateTime.Parse(dgvMovimientos.Rows[0].Cells["inicio"].Value.ToString());
                        pne.fechafin = DateTime.Parse(dgvMovimientos.Rows[0].Cells["fin"].Value.ToString());
                        pne.noconcepto = lstConcepto[0].noconcepto;

                        try
                        {
                            cnx.Open();
                            existeConcepto = (int)nh.existeConcepto(pne);
                            cnx.Close();
                        }
                        catch
                        {
                            MessageBox.Show("Error al obtener la existencia del concepto.\r\n \r\n Esta ventana se cerrará.", "Error");
                            cnx.Dispose();
                            workMovimientos.CancelAsync();
                            this.Dispose();
                        }

                        if (existeConcepto == 0)
                        {
                            lstMovimientos.Add(pn);
                        }
                        else
                        {
                            try
                            {
                                cnx.Open();
                                nh.actualizaConceptoModificado(pn);
                                cnx.Close();
                            }
                            catch (Exception error)
                            {
                                MessageBox.Show("Error al obtener la actualizar el concepto.\r\n \r\n Esta ventana se cerrará.\r\n" + error.Message, "Error");
                                cnx.Dispose();
                                workMovimientos.CancelAsync();
                                this.Dispose();
                            }
                        }

                        break;
                    #endregion

                    #region DEDUCCIONES
                    case "D":

                        //*****SE OBTIENE LA FORMULA DEL CONCEPTO DE DEDUCCION
                        string formula = "";
                        Conceptos.Core.ConceptosHelper conceptoh = new Conceptos.Core.ConceptosHelper();
                        conceptoh.Command = cmd;
                        Conceptos.Core.Conceptos conceptoDeduccion = new Conceptos.Core.Conceptos();
                        conceptoDeduccion.idempresa = GLOBALES.IDEMPRESA;
                        conceptoDeduccion.noconcepto = lstConcepto[0].noconcepto;
                        conceptoDeduccion.periodo = diasPeriodo;

                        try
                        {
                            cnx.Open();
                            formula = conceptoh.obtenerFormula(conceptoDeduccion).ToString();
                            cnx.Close();
                        }
                        catch
                        {
                            MessageBox.Show("Error al obtener la formula del concepto.\r\n \r\n Esta ventana se cerrará.", "Error");
                            cnx.Dispose();
                            workMovimientos.CancelAsync();
                            return;
                        }
                        //*****FIN

                        if (formula != "[Deduccion]")
                        {
                            pn.cantidad = decimal.Parse(fila.Cells["cantidad"].Value.ToString());
                            pn.exento = 0;
                            pn.gravado = 0;

                            pne = new CalculoNomina.Core.tmpPagoNomina();
                            pne.idempresa = GLOBALES.IDEMPRESA;
                            pne.idtrabajador = idEmpleado;
                            pne.fechainicio = DateTime.Parse(dgvMovimientos.Rows[0].Cells["inicio"].Value.ToString());
                            pne.fechafin = DateTime.Parse(dgvMovimientos.Rows[0].Cells["fin"].Value.ToString());
                            pne.noconcepto = lstConcepto[0].noconcepto;

                            try
                            {
                                cnx.Open();
                                existeConcepto = (int)nh.existeConcepto(pne);
                                cnx.Close();
                            }
                            catch
                            {
                                MessageBox.Show("Error al obtener la existencia del concepto.\r\n \r\n Esta ventana se cerrará.", "Error");
                                cnx.Dispose();
                                workMovimientos.CancelAsync();
                                this.Dispose();
                            }

                            if (existeConcepto == 0)
                            {
                                lstMovimientos.Add(pn);
                            }
                            else
                            {
                                try
                                {
                                    cnx.Open();
                                    nh.actualizaConceptoModificado(pn);
                                    cnx.Close();
                                }
                                catch
                                {
                                    MessageBox.Show("Error al obtener la existencia del concepto.\r\n \r\n Esta ventana se cerrará.", "Error");
                                    cnx.Dispose();
                                    workMovimientos.CancelAsync();
                                    this.Dispose();
                                }
                            }
                        }
                        else
                        {
                            Movimientos.Core.Movimientos mov = new Movimientos.Core.Movimientos();
                            mov.idtrabajador = idEmpleado;
                            mov.idempresa = GLOBALES.IDEMPRESA;
                            mov.idconcepto = lstConcepto[0].id;
                            mov.cantidad = decimal.Parse(fila.Cells["cantidad"].Value.ToString());
                            mov.fechainicio = DateTime.Parse(fila.Cells["inicio"].Value.ToString());
                            mov.fechafin = DateTime.Parse(fila.Cells["fin"].Value.ToString());

                            try
                            {
                                cnx.Open();
                                existeConcepto = (int)mh.existeMovimientoConcepto(mov);
                                cnx.Close();
                            }
                            catch
                            {
                                MessageBox.Show("Error al obtener la existencia del concepto.\r\n \r\n Esta ventana se cerrará.", "Error");
                                cnx.Dispose();
                                workMovimientos.CancelAsync();
                                this.Dispose();
                            }

                            if (existeConcepto == 0)
                            {
                                lstOtrasDeducciones.Add(mov);
                            }
                            else
                            {
                                try
                                {
                                    cnx.Open();
                                    mh.actualizaMovimiento(mov);
                                    cnx.Close();
                                }
                                catch
                                {
                                    MessageBox.Show("Error al obtener la existencia del concepto.\r\n \r\n Esta ventana se cerrará.", "Error");
                                    cnx.Dispose();
                                    workMovimientos.CancelAsync();
                                    this.Dispose();
                                }
                            }
                        }
                        break;
                    #endregion
                }

            }

            if (lstMovimientos.Count != 0)
            {
                bulk = new SqlBulkCopy(cnx);
                nh.bulkCommand = bulk;

                DataTable dt = new DataTable();
                DataRow dtFila;
                dt.Columns.Add("id", typeof(Int32));
                dt.Columns.Add("idtrabajador", typeof(Int32));
                dt.Columns.Add("idempresa", typeof(Int32));
                dt.Columns.Add("idconcepto", typeof(Int32));
                dt.Columns.Add("noconcepto", typeof(Int32));
                dt.Columns.Add("tipoconcepto", typeof(String));
                dt.Columns.Add("exento", typeof(Decimal));
                dt.Columns.Add("gravado", typeof(Decimal));
                dt.Columns.Add("cantidad", typeof(Decimal));
                dt.Columns.Add("fechainicio", typeof(DateTime));
                dt.Columns.Add("fechafin", typeof(DateTime));
                dt.Columns.Add("noperiodo", typeof(Int32));
                dt.Columns.Add("diaslaborados", typeof(Int32));
                dt.Columns.Add("guardada", typeof(Boolean));
                dt.Columns.Add("tiponomina", typeof(Int32));
                dt.Columns.Add("modificado", typeof(Boolean));
                dt.Columns.Add("fechapago", typeof(DateTime));
                dt.Columns.Add("obracivil", typeof(Boolean));
                dt.Columns.Add("periodo", typeof(Int32));

                int index = 1;
                for (int i = 0; i < lstMovimientos.Count; i++)
                {
                    dtFila = dt.NewRow();
                    dtFila["id"] = i + 1;
                    dtFila["idtrabajador"] = lstMovimientos[i].idtrabajador;
                    dtFila["idempresa"] = lstMovimientos[i].idempresa;
                    dtFila["idconcepto"] = lstMovimientos[i].idconcepto;
                    dtFila["noconcepto"] = lstMovimientos[i].noconcepto;
                    dtFila["tipoconcepto"] = lstMovimientos[i].tipoconcepto;
                    dtFila["exento"] = lstMovimientos[i].exento;
                    dtFila["gravado"] = lstMovimientos[i].gravado;
                    dtFila["cantidad"] = lstMovimientos[i].cantidad;
                    dtFila["fechainicio"] = lstMovimientos[i].fechainicio;
                    dtFila["fechafin"] = lstMovimientos[i].fechafin;
                    dtFila["noperiodo"] = 0;
                    dtFila["diaslaborados"] = 0;
                    dtFila["guardada"] = lstMovimientos[i].guardada;
                    dtFila["tiponomina"] = lstMovimientos[i].tiponomina;
                    dtFila["modificado"] = lstMovimientos[i].modificado;
                    dtFila["fechapago"] = new DateTime(1900,1,1);
                    dtFila["obracivil"] = false;
                    dtFila["periodo"] = _periodo;
                    dt.Rows.Add(dtFila);
                    index++;
                }

                try
                {
                    cnx.Open();
                    nh.bulkNomina(dt, "tmpPagoNomina");
                    cnx.Close();
                }
                catch (Exception error)
                {
                    MessageBox.Show("Error (DataTable): \r\n \r\n" + error.Message, "Error");
                }
            }

            if (lstOtrasDeducciones.Count != 0)
            {
                bulk = new SqlBulkCopy(cnx);
                mh.bulkCommand = bulk;

                DataTable dt = new DataTable();
                DataRow dtFila;
                dt.Columns.Add("id", typeof(Int32));
                dt.Columns.Add("idtrabajador", typeof(Int32));
                dt.Columns.Add("idempresa", typeof(Int32));
                dt.Columns.Add("idconcepto", typeof(Int32));
                dt.Columns.Add("cantidad", typeof(Decimal));
                dt.Columns.Add("fechainicio", typeof(DateTime));
                dt.Columns.Add("fechafin", typeof(DateTime));

                int index = 1;
                for (int i = 0; i < lstOtrasDeducciones.Count; i++)
                {
                    dtFila = dt.NewRow();
                    dtFila["id"] = i + 1;
                    dtFila["idtrabajador"] = lstOtrasDeducciones[i].idtrabajador;
                    dtFila["idempresa"] = lstOtrasDeducciones[i].idempresa;
                    dtFila["idconcepto"] = lstOtrasDeducciones[i].idconcepto;
                    dtFila["cantidad"] = lstOtrasDeducciones[i].cantidad;
                    dtFila["fechainicio"] = lstOtrasDeducciones[i].fechainicio;
                    dtFila["fechafin"] = lstOtrasDeducciones[i].fechafin;
                    dt.Rows.Add(dtFila);
                    index++;
                }

                try
                {
                    cnx.Open();
                    mh.bulkMovimientos(dt, "tmpMovimientos");
                    mh.stpMovimientos();
                    cnx.Close();
                    cnx.Dispose();
                }
                catch (Exception error)
                {
                    MessageBox.Show("Error (DataTable): \r\n \r\n" + error.Message, "Error");
                }
            }
        }
示例#15
0
        private void txtNoConcepto_Leave(object sender, EventArgs e)
        {
            cnx = new SqlConnection(cdn);
            cmd = new SqlCommand();
            cmd.Connection = cnx;

            ch = new Conceptos.Core.ConceptosHelper();
            ch.Command = cmd;

            Conceptos.Core.Conceptos c = new Conceptos.Core.Conceptos();
            c.idempresa = GLOBALES.IDEMPRESA;

            int existe = 0;
            try
            {
                int.Parse(txtNoConcepto.Text);
                c.noconcepto = int.Parse(txtNoConcepto.Text);
                cnx.Open();
                existe = (int)ch.existeNoConcepto(c);
                cnx.Close();
                cnx.Dispose();
            }
            catch
            {
                MessageBox.Show("Solo se admiten números.", "Error");
                txtNoConcepto.Text = "0";
                toolGuardarCerrar.Enabled = false;
                toolGuardarNuevo.Enabled = false;
                return;
            }

            if (existe != 0)
            {
                MessageBox.Show("El número de concepto elegido ya se encuentra asignado.", "Error");
                txtNoConcepto.Text = "0";
                toolGuardarCerrar.Enabled = false;
                toolGuardarNuevo.Enabled = false;
                return;
            }
            else
            {
                toolGuardarCerrar.Enabled = true;
                toolGuardarNuevo.Enabled = true;
            }
        }
示例#16
0
        void da_OnCantidad(decimal cantidad)
        {
            cnx = new SqlConnection(cdn);
            cmd = new SqlCommand();
            cmd.Connection = cnx;

            CalculoNomina.Core.NominaHelper nh = new CalculoNomina.Core.NominaHelper();
            nh.Command = cmd;

            Conceptos.Core.ConceptosHelper ch = new Conceptos.Core.ConceptosHelper();
            ch.Command = cmd;

            Conceptos.Core.Conceptos concepto = new Conceptos.Core.Conceptos();
            concepto.noconcepto = 2; //HORAS EXTRAS DOBLES
            concepto.idempresa = GLOBALES.IDEMPRESA;

            cnx.Open();
            string formulaexento = ch.obtenerFormulaExento(concepto).ToString();
            cnx.Close();

            CalculoFormula cf = new CalculoFormula(idTrabajador, _inicioPeriodo, _finPeriodo, formulaexento);
            decimal exento = decimal.Parse(cf.calcularFormula().ToString());

            decimal gravado = 0;
            if (cantidad <= exento)
            {
                exento = cantidad;
                gravado = 0;
            }
            else
            {
                gravado = cantidad - exento;
            }

            CalculoNomina.Core.tmpPagoNomina hora = new CalculoNomina.Core.tmpPagoNomina();
            hora.idempresa = GLOBALES.IDEMPRESA;
            hora.idtrabajador = idTrabajador;
            hora.noconcepto = 2; //CONCEPTO HORAS EXTRAS DOBLES
            hora.fechainicio = _inicioPeriodo.Date;
            hora.fechafin = _finPeriodo.Date;
            hora.cantidad = cantidad;
            hora.exento = exento;
            hora.gravado = gravado;
            hora.modificado = true;
            try
            {
                cnx.Open();
                nh.actualizaHorasExtrasDespensa(hora);
                cnx.Close();
                cnx.Dispose();

                muestraDatos();
            }
            catch (Exception error)
            {
                MessageBox.Show("Error: \r\n \r\n" + error.Message, "Error");
            }
        }
示例#17
0
        private void toolBaja_Click(object sender, EventArgs e)
        {
            DialogResult respuesta = MessageBox.Show("¿Quiere eliminar el concepto?", "Confirmación", MessageBoxButtons.YesNo);
            if (respuesta == DialogResult.Yes)
            {
                string cdn = ConfigurationManager.ConnectionStrings["cdnNomina"].ConnectionString;
                int fila = dgvConceptos.CurrentCell.RowIndex;
                int id = int.Parse(dgvConceptos.Rows[fila].Cells[0].Value.ToString());
                cnx = new SqlConnection(cdn);
                cmd = new SqlCommand();
                cmd.Connection = cnx;
                ch = new Conceptos.Core.ConceptosHelper();
                ch.Command = cmd;
                Conceptos.Core.Conceptos concepto = new Conceptos.Core.Conceptos();
                concepto.id = id;

                try
                {
                    cnx.Open();
                    ch.eliminarConcepto(concepto);
                    cnx.Close();
                    cnx.Dispose();
                    ListaConceptos();
                }
                catch (Exception error)
                {
                    MessageBox.Show("Error: \r\n \r\n " + error.Message, "Error");
                }
            }
        }
示例#18
0
        private void frmConceptos_Load(object sender, EventArgs e)
        {
            txtFormula.Text = "0";
            txtExento.Text = "0";

            cnx = new SqlConnection();
            cnx.ConnectionString = cdn;
            cmd = new SqlCommand();
            cmd.Connection = cnx;
            ch = new Conceptos.Core.ConceptosHelper();
            ch.Command = cmd;

            Periodos.Core.PeriodosHelper ph = new Periodos.Core.PeriodosHelper();
            ph.Command = cmd;

            Periodos.Core.Periodos periodo = new Periodos.Core.Periodos();
            periodo.idempresa = GLOBALES.IDEMPRESA;

            List<Periodos.Core.Periodos> lstPeriodos = new List<Periodos.Core.Periodos>();

            try
            {
                cnx.Open();
                lstPeriodos = ph.obtenerPeriodos(periodo);
                cnx.Close();
            }
            catch (Exception)
            {
                MessageBox.Show("Error: Al obtener los periodos de la empresa.", "Error");
                cnx.Close();
                return;
            }

            cmbPeriodo.DataSource = lstPeriodos.ToList();
            cmbPeriodo.DisplayMember = "pago";
            cmbPeriodo.ValueMember = "dias";

            if (_tipoOperacion == GLOBALES.CONSULTAR || _tipoOperacion == GLOBALES.MODIFICAR)
            {

                Conceptos.Core.Conceptos concepto = new Conceptos.Core.Conceptos();
                concepto.id = _idConcepto;

                List<Conceptos.Core.Conceptos> lstConcepto;

                try
                {
                    cnx.Open();
                    lstConcepto = ch.obtenerConcepto(concepto);
                    cnx.Close();
                    cnx.Dispose();

                    for (int i = 0; i < lstConcepto.Count; i++)
                    {
                        txtConcepto.Text = lstConcepto[i].concepto.ToString();
                        txtNoConcepto.Text = lstConcepto[i].noconcepto.ToString();
                        cmbTipo.SelectedIndex = (lstConcepto[i].tipoconcepto == "P") ? 0 : 1;
                        txtFormula.Text = lstConcepto[i].formula;
                        txtExento.Text = lstConcepto[i].formulaexento;
                        chkVisible.Checked = lstConcepto[i].visible;
                        txtGrupoSat.Text = lstConcepto[i].gruposat;
                        chkGrava.Checked = lstConcepto[i].gravado;
                        chkExenta.Checked = lstConcepto[i].exento;
                    }
                }
                catch (Exception error)
                {
                    MessageBox.Show("Error: \r\n \r\n " + error.Message, "Error");
                }

                if (_tipoOperacion == GLOBALES.CONSULTAR)
                {
                    toolTitulo.Text = "Consulta concepto";
                    GLOBALES.INHABILITAR(this, typeof(TextBox));
                    GLOBALES.INHABILITAR(this, typeof(ComboBox));
                    GLOBALES.INHABILITAR(this, typeof(CheckBox));
                }
                else
                    toolTitulo.Text = "Edición concepto";
            }
        }