Ejemplo n.º 1
0
        /// <summary>
        /// Obtener todos los valores que pertenecen a una inconsistencia en un deposito.
        /// </summary>
        /// <param name="i">Inconsistencia en un deposito para la cual se obtiene la lista de valores</param>
        public void obtenerValoresInconsistencia(ref InconsistenciaDeposito i)
        {
            SqlCommand    comando    = _manejador.obtenerProcedimiento("SelectInconsistenciaDepositoValores");
            SqlDataReader datareader = null;

            _manejador.agregarParametro(comando, "@inconsistencia", i.Id, SqlDbType.Int);

            try
            {
                datareader = _manejador.ejecutarConsultaDatos(comando);

                while (datareader.Read())
                {
                    int       id            = (int)datareader["pk_ID"];
                    string    identificador = (string)datareader["Identificador"];
                    TipoValor tipo          = (TipoValor)datareader["Tipo"];
                    string    comentario    = (string)datareader["Comentario"];

                    Valor valor = new Valor(id, tipo, identificador, comentario);

                    i.agregarValor(valor);
                }

                comando.Connection.Close();
            }
            catch (Exception)
            {
                comando.Connection.Close();
                throw new Excepcion("ErrorDatosConexion");
            }
        }
Ejemplo n.º 2
0
        /// <summary>
        /// Obtener todos los sobres que pertenecen a una inconsistencia en un deposito.
        /// </summary>
        /// <param name="i">Inconsistencia en un deposito para la cual se obtiene la lista de sobre</param>
        public void obtenerSobresInconsistencia(ref InconsistenciaDeposito i)
        {
            SqlCommand    comando    = _manejador.obtenerProcedimiento("SelectInconsistenciaDepositoSobres");
            SqlDataReader datareader = null;

            _manejador.agregarParametro(comando, "@inconsistencia", i.Id, SqlDbType.Int);

            try
            {
                datareader = _manejador.ejecutarConsultaDatos(comando);

                while (datareader.Read())
                {
                    int     id              = (int)datareader["pk_ID"];
                    int     numero          = (int)datareader["Numero"];
                    decimal monto_reportado = (decimal)datareader["Monto_Reportado"];
                    decimal monto_real      = (decimal)datareader["Monto_Real"];
                    Monedas moneda          = (Monedas)datareader["Moneda"];

                    Sobre sobre = new Sobre(id, numero, monto_reportado, monto_real, moneda);
                    i.agregarSobre(sobre);
                }

                comando.Connection.Close();
            }
            catch (Exception)
            {
                comando.Connection.Close();
                throw new Excepcion("ErrorDatosConexion");
            }
        }
Ejemplo n.º 3
0
        /// <summary>
        /// Verificar si existe una inconsistencia para un deposito dado.
        /// </summary>
        /// <param name="i">Objeto InconsistenciaDeposito con los datos de la inconsistencia</param>
        /// <returns>Valor que indica si la inconsistencia existe</returns>
        public bool verificarInconsistenciaClienteDeposito(InconsistenciaDeposito i)
        {
            bool existe = false;

            SqlCommand    comando    = _manejador.obtenerProcedimiento("SelectExisteInconsistenciaDeposito");
            SqlDataReader datareader = null;

            _manejador.agregarParametro(comando, "@deposito", i.Deposito, SqlDbType.Int);

            try
            {
                datareader = _manejador.ejecutarConsultaDatos(comando);

                if (datareader.Read())
                {
                    int id_encontrado = (int)datareader["pk_ID"];

                    existe = id_encontrado != i.Id;
                }

                comando.Connection.Close();
            }
            catch (Exception)
            {
                comando.Connection.Close();
                throw new Excepcion("ErrorVerificarInconsistenciaDepositoDuplicado");
            }

            return(existe);
        }
Ejemplo n.º 4
0
        /// <summary>
        /// Registrar una inconsistencia en un deposito.
        /// </summary>
        /// <param name="i">Objeto InconsistenciaDeposito con los datos de la inconsistencia</param>
        public void agregarInconsistencia(ref InconsistenciaDeposito i)
        {
            SqlCommand comando = _manejador.obtenerProcedimiento("InsertInconsistenciaDeposito");

            _manejador.agregarParametro(comando, "@manifiesto", i.Manifiesto, SqlDbType.Int);
            _manejador.agregarParametro(comando, "@tula", i.Tula, SqlDbType.Int);
            _manejador.agregarParametro(comando, "@deposito", i.Deposito, SqlDbType.Int);
            _manejador.agregarParametro(comando, "@camara", i.Camara, SqlDbType.TinyInt);
            _manejador.agregarParametro(comando, "@fecha", i.Fecha, SqlDbType.DateTime);
            _manejador.agregarParametro(comando, "@diferencia_colones", i.Diferencia_colones, SqlDbType.Money);
            _manejador.agregarParametro(comando, "@diferencia_dolares", i.Diferencia_dolares, SqlDbType.Money);
            _manejador.agregarParametro(comando, "@diferencia_euros", i.Diferencia_euros, SqlDbType.Money);
            _manejador.agregarParametro(comando, "@comentario", i.Comentario, SqlDbType.VarChar);

            try
            {
                i.Id = (int)_manejador.ejecutarEscalar(comando);
                comando.Connection.Close();
            }
            catch (Exception)
            {
                comando.Connection.Close();
                throw new Excepcion("ErrorInconsistenciaDepositoRegistro");
            }
        }
        /// <summary>
        /// Se selecciona otra inconsistencia en un deposito por causa de un cliente.
        /// </summary>
        private void dgvInconsistenciasDepositos_SelectionChanged(object sender, EventArgs e)
        {
            if (dgvInconsistenciasDepositos.SelectedRows.Count == 0)
            {
                btnEliminarInconsistenciaDeposito.Enabled  = false;
                btnModificarInconsistenciaDeposito.Enabled = false;
            }
            else
            {
                InconsistenciaDeposito inconsistencia =
                    (InconsistenciaDeposito)dgvInconsistenciasDepositos.SelectedRows[0].DataBoundItem;

                PlanillaCEF planilla = null;

                if (inconsistencia.Segregado != null)
                {
                    planilla = inconsistencia.Segregado;
                }
                else
                {
                    planilla = inconsistencia.Manifiesto;
                }

                bool estado = true;

                if (planilla.Coordinador != null)
                {
                    estado = planilla.Coordinador.Equals(_coordinador);
                }

                btnEliminarInconsistenciaDeposito.Enabled  = true;
                btnModificarInconsistenciaDeposito.Enabled = true;
            }
        }
        public frmMantenimientoInconsistenciasDepositos(InconsistenciaDeposito inconsistencia, Colaborador coordinador)
        {
            InitializeComponent();

            _inconsistencia = inconsistencia;
            _coordinador    = coordinador;

            try
            {
                this.cargarDatos();

                // Mostrar los datos de la inconsistencia

                cboCamara.Text = _inconsistencia.Camara.Identificador;
                dtpFecha.Value = _inconsistencia.Fecha;

                nudDiferenciaColones.Value = _inconsistencia.Diferencia_colones;
                nudDiferenciaDolares.Value = _inconsistencia.Diferencia_dolares;
                nudDiferenciaEuros.Value   = _inconsistencia.Diferencia_euros;

                dgvValores.DataSource = _inconsistencia.Valores;
                dgvSobres.DataSource  = _inconsistencia.Sobres;

                BindingList <Deposito>   depositos   = (BindingList <Deposito>)dgvDepositos.DataSource;
                BindingList <Tula>       tulas       = (BindingList <Tula>)dgvTulas.DataSource;
                BindingList <Manifiesto> manifiestos = (BindingList <Manifiesto>)dgvManifiestos.DataSource;

                manifiestos.Add(_inconsistencia.Manifiesto);
                depositos.Add(_inconsistencia.Deposito);
                tulas.Add(_inconsistencia.Tula);

                if (_inconsistencia.Segregado == null)
                {
                    this.mostrarDatos(_inconsistencia.Manifiesto);
                }
                else
                {
                    this.mostrarDatos(_inconsistencia.Segregado);

                    nudBolso.Value = (short)_inconsistencia.Bolso;
                }

                // Validar si se pueden modificar los datos de la inconsistencia

                bool estado = _supervisor || (_coordinador_valido && _dia_valido);

                gbDetalle.Enabled     = estado;
                gbManifiestos.Enabled = estado;
                gbTulas.Enabled       = estado;
                gbDeposito.Enabled    = estado;
                gbValores.Enabled     = estado;
                gbSobres.Enabled      = estado;
                btnGuardar.Enabled    = estado;
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
Ejemplo n.º 7
0
        /// <summary>
        /// Listar las inconsistencias en depositos registradas durante un periodo de tiempo.
        /// </summary>
        /// <param name="i">Fecha inicial del periodo de tiempo</param>
        /// <param name="f">Fecha final del periodo de tiempo</param>
        /// <returns>Lista de las inconsistencias registradas en el periodo de tiempo indicado</returns>
        public BindingList <InconsistenciaDeposito> listarInconsistencias(DateTime i, DateTime f)
        {
            BindingList <InconsistenciaDeposito> inconsistencias = new BindingList <InconsistenciaDeposito>();

            SqlCommand    comando    = _manejador.obtenerProcedimiento("SelectInconsistenciasDepositos");
            SqlDataReader datareader = null;

            _manejador.agregarParametro(comando, "@fecha_inicio", i, SqlDbType.DateTime);
            _manejador.agregarParametro(comando, "@fecha_fin", f, SqlDbType.DateTime);

            try
            {
                datareader = _manejador.ejecutarConsultaDatos(comando);

                while (datareader.Read())
                {
                    int      id_inconsistenca   = (int)datareader["ID_Incosistencia"];
                    DateTime fecha              = (DateTime)datareader["Fecha"];
                    decimal  diferencia_colones = (decimal)datareader["Diferencia_Colones"];
                    decimal  diferencia_dolares = (decimal)datareader["Diferencia_Dolares"];
                    string   comentario         = (string)datareader["Comentario"];

                    int    id_manifiesto     = (int)datareader["ID_Manifiesto"];
                    string codigo_manifiesto = (string)datareader["Codigo_Manifiesto"];

                    int    id_tula     = (int)datareader["ID_Tula"];
                    string codigo_tula = (string)datareader["Codigo_Tula"];

                    byte   id_camara     = (byte)datareader["ID_Camara"];
                    string identificador = (string)datareader["Identificador"];

                    int     id_deposito         = (int)datareader["ID_Deposito"];
                    long    referencia_deposito = (long)datareader["Referencia"];
                    decimal monto_deposito      = (decimal)datareader["Monto"];
                    Monedas moneda_deposito     = (Monedas)datareader["Moneda"];
                    long    cuenta_deposito     = (long)datareader["Cuenta"];

                    ManifiestoCEF manifiesto = new ManifiestoCEF(codigo_manifiesto, id: id_manifiesto);
                    Tula          tula       = new Tula(codigo_tula, id: id_tula);
                    Deposito      deposito   = new Deposito(referencia_deposito, id: id_deposito, monto: monto_deposito, moneda: moneda_deposito,
                                                            cuenta: cuenta_deposito);
                    Camara camara = new Camara(identificador, id: id_camara);

                    InconsistenciaDeposito inconsistencia =
                        new InconsistenciaDeposito(id_inconsistenca, manifiesto, tula, deposito, camara, fecha,
                                                   diferencia_colones, diferencia_dolares, comentario);
                    inconsistencias.Add(inconsistencia);
                }

                comando.Connection.Close();
            }
            catch (Exception)
            {
                comando.Connection.Close();
                throw new Excepcion("ErrorDatosConexion");
            }

            return(inconsistencias);
        }
        /// <summary>
        /// Agregar una inconsistencia a la lista de inconsistencias en depositos.
        /// </summary>
        public void agregarInconsistenciaClienteDeposito(InconsistenciaDeposito inconsistencia)
        {
            BindingList <InconsistenciaDeposito> inconsistencias =
                (BindingList <InconsistenciaDeposito>)dgvInconsistenciasDepositos.DataSource;

            inconsistencias.Add(inconsistencia);
            dgvInconsistenciasDepositos.AutoResizeColumns();
        }
Ejemplo n.º 9
0
        /// <summary>
        /// Obtener el manifiesto segregado ligado a una inconsistencia.
        /// </summary>
        /// <param name="i">Inconsistencia para la cual se obtienen los manifiesto segregados</param>
        public void obtenerSegregadoInconsistencia(ref InconsistenciaDeposito i)
        {
            SqlCommand    comando    = _manejador.obtenerProcedimiento("SelectInconsistenciaDepositoSegregado");
            SqlDataReader datareader = null;

            _manejador.agregarParametro(comando, "@inconsistencia", i.Id, SqlDbType.Int);

            try
            {
                datareader = _manejador.ejecutarConsultaDatos(comando);

                if (datareader.Read())
                {
                    short bolso = (short)datareader["Bolso"];

                    int id_manifiesto = (int)datareader["ID_Manifiesto"];

                    short  id_cliente     = (short)datareader["ID_Cliente"];
                    string nombre_cliente = (string)datareader["Nombre_Cliente"];

                    short  id_punto_venta     = (short)datareader["ID_Punto_Venta"];
                    string nombre_punto_venta = (string)datareader["Nombre_Punto_Venta"];

                    int    id_digitador               = (int)datareader["ID_Digitador"];
                    string nombre_digitador           = (string)datareader["Nombre_Digitador"];
                    string primer_apellido_digitador  = (string)datareader["Primer_Apellido_Digitador"];
                    string segundo_apellido_digitador = (string)datareader["Segundo_Apellido_Digitador"];

                    int    id_cajero               = (int)datareader["ID_Cajero"];
                    string nombre_cajero           = (string)datareader["Nombre_Cajero"];
                    string primer_apellido_cajero  = (string)datareader["Primer_Apellido_Cajero"];
                    string segundo_apellido_cajero = (string)datareader["Segundo_Apellido_Cajero"];

                    int    id_coordinador               = (int)datareader["ID_Coordinador"];
                    string nombre_coordinador           = (string)datareader["Nombre_Coordinador"];
                    string primer_apellido_coordinador  = (string)datareader["Primer_Apellido_Coordinador"];
                    string segundo_apellido_coordinador = (string)datareader["Segundo_Apellido_Coordinador"];

                    Colaborador  coordinador = new Colaborador(id_coordinador, nombre_coordinador, primer_apellido_coordinador, segundo_apellido_coordinador);
                    Colaborador  digitador   = new Colaborador(id_digitador, nombre_digitador, primer_apellido_digitador, segundo_apellido_digitador);
                    Colaborador  cajero      = new Colaborador(id_cajero, nombre_cajero, primer_apellido_cajero, segundo_apellido_cajero);
                    Cliente      cliente     = new Cliente(id_cliente, nombre_cliente);
                    PuntoVenta   punto_venta = new PuntoVenta(id_punto_venta, nombre_punto_venta, cliente);
                    SegregadoCEF segregado   = new SegregadoCEF(id_manifiesto, cajero, digitador, coordinador, punto_venta);

                    i.Segregado = segregado;
                    i.Bolso     = bolso;
                }

                comando.Connection.Close();
            }
            catch (Exception)
            {
                comando.Connection.Close();
                throw new Excepcion("ErrorDatosConexion");
            }
        }
        /// <summary>
        /// Formato de la lista de inconsistencias en los depositos por causa del cliente.
        /// </summary>
        private void dgvInconsistenciasDepositos_CellFormatting(object sender, DataGridViewCellFormattingEventArgs e)
        {
            if (e.ColumnIndex == DepositoDeposito.Index)
            {
                InconsistenciaDeposito inconsistencia =
                    (InconsistenciaDeposito)dgvInconsistenciasDepositos.Rows[e.RowIndex].DataBoundItem;
                Deposito deposito = inconsistencia.Deposito;

                dgvInconsistenciasDepositos[MontoDeposito.Index, e.RowIndex].Value = deposito.Monto;
            }
            else if (e.ColumnIndex == ManifiestoDeposito.Index)
            {
                InconsistenciaDeposito inconsistencia =
                    (InconsistenciaDeposito)dgvInconsistenciasDepositos.Rows[e.RowIndex].DataBoundItem;

                PlanillaCEF planilla = null;

                if (inconsistencia.Segregado != null)
                {
                    planilla = inconsistencia.Segregado;
                }
                else
                {
                    planilla = inconsistencia.Manifiesto;
                }

                dgvInconsistenciasDepositos[CajeroDeposito.Index, e.RowIndex].Value      = planilla.Cajero;
                dgvInconsistenciasDepositos[DigitadorDeposito.Index, e.RowIndex].Value   = planilla.Digitador;
                dgvInconsistenciasDepositos[CoordinadorDeposito.Index, e.RowIndex].Value = planilla.Coordinador;
            }
            else if (e.ColumnIndex == MontoDeposito.Index)
            {
                InconsistenciaDeposito inconsistencia =
                    (InconsistenciaDeposito)dgvInconsistenciasDepositos.Rows[e.RowIndex].DataBoundItem;

                decimal diferencia_colones = inconsistencia.Diferencia_colones;
                decimal diferencia_dolares = inconsistencia.Diferencia_dolares;

                foreach (Sobre sobre in inconsistencia.Sobres)
                {
                    switch (sobre.Moneda)
                    {
                    case Monedas.Colones:
                        diferencia_colones += sobre.Monto_real - sobre.Monto_reportado;
                        break;

                    case Monedas.Dolares:
                        diferencia_dolares += sobre.Monto_real - sobre.Monto_reportado;
                        break;
                    }
                }

                dgvInconsistenciasDepositos[DiferenciaColones.Index, e.RowIndex].Value = diferencia_colones;
                dgvInconsistenciasDepositos[DiferenciaDolares.Index, e.RowIndex].Value = diferencia_dolares;
            }
        }
        /// <summary>
        /// Mostrar la ventana de modificación de inconsistencias en depositos por causa de los clientes.
        /// </summary>
        public void mostarVentanaModificacionClientesDepositos()
        {
            try
            {
                InconsistenciaDeposito inconsistencia =
                    (InconsistenciaDeposito)dgvInconsistenciasDepositos.SelectedRows[0].DataBoundItem;
                frmMantenimientoInconsistenciasDepositos formulario = new frmMantenimientoInconsistenciasDepositos(inconsistencia, _coordinador);

                formulario.ShowDialog(this);
            }
            catch (Excepcion ex)
            {
                ex.mostrarMensaje();
            }
        }
Ejemplo n.º 12
0
        /// <summary>
        /// Desligar un manifiesto segregado de una inconsistencia en deposito.
        /// </summary>
        /// <param name="i">InconsistenciaDeposito con los datos de la inconsistencia</param>
        public void eliminarManifiestoSegregadoInconsistencia(InconsistenciaDeposito i)
        {
            SqlCommand comando = _manejador.obtenerProcedimiento("DeleteInconsistenciaDepositoSegregado");

            _manejador.agregarParametro(comando, "@inconsistencia", i.Id, SqlDbType.Int);

            try
            {
                _manejador.ejecutarConsultaActualizacion(comando);
                comando.Connection.Close();
            }
            catch (Exception)
            {
                comando.Connection.Close();
                throw new Excepcion("ErrorInconsistenciaDepositoActualizacion");
            }
        }
Ejemplo n.º 13
0
        /// <summary>
        /// Obtener las inconsistencias ligadas al cierre de un cajero y un digitador del CEF.
        /// </summary>
        /// <param name="c">Objeto CierreCEF con los datos del cierre para el cual se obtienen las inconsistencias</param>
        public BindingList <InconsistenciaDeposito> obtenerInconsistenciasCierre(CierreCEF c)
        {
            BindingList <InconsistenciaDeposito> inconsistencias = new BindingList <InconsistenciaDeposito>();
            SqlCommand    comando    = _manejador.obtenerProcedimiento("SelectCierreCEFInconsistencias");
            SqlDataReader datareader = null;

            _manejador.agregarParametro(comando, "@cajero", c.Cajero, SqlDbType.Int);
            _manejador.agregarParametro(comando, "@digitador", c.Digitador, SqlDbType.Int);
            _manejador.agregarParametro(comando, "@fecha", c.Fecha, SqlDbType.Date);

            try
            {
                datareader = _manejador.ejecutarConsultaDatos(comando);

                while (datareader.Read())
                {
                    int     id = (int)datareader["pk_ID"];
                    decimal diferencia_colones = (decimal)datareader["Diferencia_Colones"];
                    decimal diferencia_dolares = (decimal)datareader["Diferencia_Dolares"];

                    decimal diferencia_euros = 0;

                    if (datareader["Diferencia_Euros"] != DBNull.Value)
                    {
                        diferencia_euros = (decimal)datareader["Diferencia_Euros"];
                    }

                    InconsistenciaDeposito inconsistencia =
                        new InconsistenciaDeposito(id, diferencia_colones, diferencia_dolares, diferencia_euros);

                    inconsistencias.Add(inconsistencia);
                }

                comando.Connection.Close();
            }
            catch (Exception)
            {
                comando.Connection.Close();
                throw new Excepcion("ErrorDatosConexion");
            }

            return(inconsistencias);
        }
Ejemplo n.º 14
0
        /// <summary>
        /// Registrar un valor y ligarlo con una inconsistencia.
        /// </summary>
        /// <param name="s">Objeto Valor con los datos del valor</param>
        /// <param name="i">Inconsistencia en un deposito a la cual se ligará el valor</param>
        public void agregarValor(ref Valor v, InconsistenciaDeposito i)
        {
            SqlCommand comando = _manejador.obtenerProcedimiento("InsertValor");

            _manejador.agregarParametro(comando, "@identificador", v.Identificador, SqlDbType.VarChar);
            _manejador.agregarParametro(comando, "@tipo", v.Tipo, SqlDbType.TinyInt);
            _manejador.agregarParametro(comando, "@comentario", v.Comentario, SqlDbType.VarChar);
            _manejador.agregarParametro(comando, "@inconsistencia", i.Id, SqlDbType.Int);

            try
            {
                v.Id = (int)_manejador.ejecutarEscalar(comando);
                comando.Connection.Close();
            }
            catch (Exception)
            {
                comando.Connection.Close();
                throw new Excepcion("ErrorValorRegistro");
            }
        }
        /// <summary>
        /// Clic en el botón de eliminar una inconsistencia en un deposito.
        /// </summary>
        private void btnEliminarInconsistenciaDeposito_Click(object sender, EventArgs e)
        {
            try
            {
                if (Mensaje.mostrarMensajeConfirmacion("MensajeInconsistenciaEliminacion") == DialogResult.Yes)
                {
                    InconsistenciaDeposito inconsistencia =
                        (InconsistenciaDeposito)dgvInconsistenciasDepositos.SelectedRows[0].DataBoundItem;

                    _coordinacion.eliminarInconsistenciaDeposito(inconsistencia);

                    dgvInconsistenciasDepositos.Rows.Remove(dgvInconsistenciasDepositos.SelectedRows[0]);
                    Mensaje.mostrarMensaje("MensajeInconsistenciaConfirmacionEliminacion");
                }
            }
            catch (Excepcion ex)
            {
                ex.mostrarMensaje();
            }
        }
Ejemplo n.º 16
0
        /// <summary>
        /// Registrar un sobre y ligarlo con una inconsistencia.
        /// </summary>
        /// <param name="s">Objeto Sobre con los datos del sobre</param>
        /// <param name="i">Inconsistencia en un deposito a la cual se ligará el sobre</param>
        public void agregarSobre(ref Sobre s, InconsistenciaDeposito i)
        {
            SqlCommand comando = _manejador.obtenerProcedimiento("InsertSobre");

            _manejador.agregarParametro(comando, "@numero", s.Numero, SqlDbType.Int);
            _manejador.agregarParametro(comando, "@monto_reportado", s.Monto_reportado, SqlDbType.Money);
            _manejador.agregarParametro(comando, "@monto_real", s.Monto_real, SqlDbType.Money);
            _manejador.agregarParametro(comando, "@moneda", s.Moneda, SqlDbType.TinyInt);
            _manejador.agregarParametro(comando, "@inconsistencia", i.Id, SqlDbType.Int);

            try
            {
                s.Id = (int)_manejador.ejecutarEscalar(comando);
                comando.Connection.Close();
            }
            catch (Exception)
            {
                comando.Connection.Close();
                throw new Excepcion("ErrorSobreRegistro");
            }
        }
        /// <summary>
        /// Clic en el botón de guardar.
        /// </summary>
        private void btnGuardar_Click(object sender, EventArgs e)
        {
            if (dgvManifiestos.SelectedRows.Count == 0 || dgvTulas.SelectedRows.Count == 0 ||
                dgvDepositos.SelectedRows.Count == 0 || cboCajero.SelectedItem == null ||
                cboDigitador.SelectedItem == null || cboPuntoVenta.SelectedItem == null ||
                cboCamara.SelectedItem == null)
            {
                Excepcion.mostrarMensaje("ErrorInconsistenciaDatosRegistro");
                return;
            }

            try
            {
                frmAdministracionInconsistenciasCEF padre = (frmAdministracionInconsistenciasCEF)this.Owner;

                PuntoVenta punto_venta = (PuntoVenta)cboPuntoVenta.SelectedItem;

                SegregadoCEF  segregado      = null;
                ManifiestoCEF manifiesto_cef = null;

                DateTime fecha    = dtpFecha.Value;
                Camara   camara   = (Camara)cboCamara.SelectedItem;
                Deposito deposito = (Deposito)dgvDepositos.SelectedRows[0].DataBoundItem;
                Tula     tula     = (Tula)dgvTulas.SelectedRows[0].DataBoundItem;

                decimal diferencia_colones = nudDiferenciaColones.Value;
                decimal diferencia_dolares = nudDiferenciaDolares.Value;
                decimal diferencia_euros   = nudDiferenciaEuros.Value;
                short   bolso      = (short)nudBolso.Value;
                string  comentario = txtComentario.Text;

                Colaborador cajero         = (Colaborador)cboCajero.SelectedItem;
                Colaborador digitador      = (Colaborador)cboDigitador.SelectedItem;
                Colaborador coordinador    = (Colaborador)cboCoordinador.SelectedItem;
                DateTime    fecha_planilla = dtpFechaManifiesto.Value;

                if (_planilla is SegregadoCEF)
                {
                    segregado      = (SegregadoCEF)_planilla;
                    manifiesto_cef = (ManifiestoCEF)dgvManifiestos.SelectedRows[0].DataBoundItem;

                    segregado.Cajero      = cajero;
                    segregado.Digitador   = digitador;
                    segregado.Coordinador = coordinador;
                    segregado.Punto_venta = punto_venta;

                    manifiesto_cef.Fecha_procesamiento = fecha_planilla;
                }
                else
                {
                    manifiesto_cef = (ManifiestoCEF)_planilla;

                    manifiesto_cef.Cajero              = cajero;
                    manifiesto_cef.Digitador           = digitador;
                    manifiesto_cef.Coordinador         = coordinador;
                    manifiesto_cef.Punto_venta         = punto_venta;
                    manifiesto_cef.Fecha_procesamiento = fecha_planilla;
                }

                BindingList <Valor> valores = (BindingList <Valor>)dgvValores.DataSource;
                BindingList <Sobre> sobres  = (BindingList <Sobre>)dgvSobres.DataSource;

                // Verificar si la inconsistencia es nueva

                if (_inconsistencia == null)
                {
                    // Agregar la inconsistencia

                    if (Mensaje.mostrarMensajeConfirmacion("MensajeInconsistenciaRegistro") == DialogResult.Yes)
                    {
                        InconsistenciaDeposito nueva =
                            new InconsistenciaDeposito(manifiesto_cef, segregado, bolso, tula, deposito, camara,
                                                       fecha, diferencia_colones, diferencia_dolares, comentario, diferencia_euros);

                        foreach (Valor valor in valores)
                        {
                            nueva.agregarValor(valor);
                        }

                        foreach (Sobre sobre in sobres)
                        {
                            nueva.agregarSobre(sobre);
                        }

                        _coordinacion.agregarInconsistenciaDeposito(ref nueva);

                        padre.agregarInconsistenciaClienteDeposito(nueva);
                        Mensaje.mostrarMensaje("MensajeInconsistenciaConfirmacionRegistro");
                        this.Close();
                    }
                }
                else
                {
                    InconsistenciaDeposito copia =
                        new InconsistenciaDeposito(_inconsistencia.Id, manifiesto_cef, segregado, bolso, tula, deposito, camara,
                                                   fecha, diferencia_colones, diferencia_dolares, comentario, diferencia_euros);

                    foreach (Valor sobre in valores)
                    {
                        copia.agregarValor(sobre);
                    }

                    foreach (Sobre sobre in sobres)
                    {
                        copia.agregarSobre(sobre);
                    }

                    _coordinacion.actualizarInconsistenciaDeposito(copia);

                    //Actualizar la inconsistencia

                    _inconsistencia.Manifiesto = manifiesto_cef;
                    _inconsistencia.Segregado  = segregado;
                    _inconsistencia.Camara     = camara;
                    _inconsistencia.Fecha      = fecha;
                    _inconsistencia.Comentario = comentario;
                    _inconsistencia.Deposito   = deposito;
                    _inconsistencia.Tula       = tula;

                    _inconsistencia.Diferencia_colones = diferencia_colones;
                    _inconsistencia.Diferencia_dolares = diferencia_dolares;

                    _inconsistencia.Valores = copia.Valores;
                    _inconsistencia.Sobres  = copia.Sobres;

                    padre.actualizarListaClientesDepositos();
                    Mensaje.mostrarMensaje("MensajeInconsistenciaConfirmacionActualizacion");
                    this.Close();
                }
            }
            catch (Excepcion ex)
            {
                ex.mostrarMensaje();
            }
        }