private bool AccionAceptar()
        {
            if (this.dgvFacturas.CurrentRow == null)
            {
                UtilLocal.MensajeAdvertencia("No hay ninguna factura seleccionada.");
                return false;
            }

            // Se llena el dato de Id, para garantías
            int iId = Util.Entero(this.dgvPartes.CurrentRow.Cells["parId"].Value);
            if (this.bGarantias)
                this.iGarantiaID = iId;
            // Se llena el movimiento detalle
            int iIdDet = Util.Entero(this.dgvFacturas.CurrentRow.Cells["facMovimientoInventarioDetalleID"].Value);
            this.oMovimientoDetalle = Datos.GetEntity<MovimientoInventarioDetalle>(c => c.MovimientoInventarioDetalleID == iIdDet && c.Estatus);

            return true;
        }
Example #2
0
        private bool AccionAceptar()
        {
            if (this.dgvFacturas.CurrentRow == null)
            {
                UtilLocal.MensajeAdvertencia("No hay ninguna factura seleccionada.");
                return(false);
            }

            // Se llena el dato de Id, para garantías
            int iId = Util.Entero(this.dgvPartes.CurrentRow.Cells["parId"].Value);

            if (this.bGarantias)
            {
                this.iGarantiaID = iId;
            }
            // Se llena el movimiento detalle
            int iIdDet = Util.Entero(this.dgvFacturas.CurrentRow.Cells["facMovimientoInventarioDetalleID"].Value);

            this.oMovimientoDetalle = Datos.GetEntity <MovimientoInventarioDetalle>(c => c.MovimientoInventarioDetalleID == iIdDet && c.Estatus);

            return(true);
        }
Example #3
0
        protected override void btnGuardar_Click(object sender, EventArgs e)
        {
            try
            {
                if (!Validaciones())
                {
                    return;
                }

                if (EsNuevo)
                {
                }
                else
                {
                    int iAutorizoID = 0;
                    var ResU        = UtilLocal.ValidarObtenerUsuario(null, "Autorización");
                    if (ResU.Exito)
                    {
                        iAutorizoID = ResU.Respuesta.UsuarioID;
                    }
                    else
                    {
                        Util.MensajeError("Error al validar el usuario.", GlobalClass.NombreApp);
                        return;
                    }

                    SplashScreen.Show(new Splash());
                    this.btnGuardar.Enabled = false;

                    var ContingenciaCompleta = Datos.GetEntity <MovimientoInventarioContingenciasView>(c => c.MovimientoInventarioTraspasoContingenciaID == Contingencia.MovimientoInventarioTraspasoContingenciaID);
                    if (null == ContingenciaCompleta)
                    {
                        return;
                    }

                    //Actualiza la contingencia
                    Contingencia.FechaModificacion = DateTime.Now;
                    Contingencia.MovimientoInventarioEstatusContingenciaID = 1;
                    Contingencia.UsuarioID               = GlobalClass.UsuarioGlobal.UsuarioID;
                    Contingencia.UsuarioSolucionoID      = GlobalClass.UsuarioGlobal.UsuarioID;
                    Contingencia.FechaSoluciono          = DateTime.Now;
                    Contingencia.TipoOperacionID         = Util.Entero(this.cboTipoOperacion.SelectedValue);
                    Contingencia.TipoConceptoOperacionID = Util.Entero(this.cboConceptoOperacion.SelectedValue);
                    Contingencia.ObservacionSolucion     = this.txtObservacion.Text;
                    if (Util.Entero(this.cboTipoOperacion.SelectedValue) == Cat.TiposDeOperacionMovimientos.SalidaInventario)
                    {
                        Contingencia.ObservacionSolucion += (" - SE CREA UNA ENTRADA PARA DEVOLVER EL TRASPASO A LA TIENDA ORIGEN Y EN EL SEGUNDO MOVIMIENTO UNA SALIDA PARA PODER HACER LA SALIDA DEL INVENTARIO");
                    }
                    Contingencia.FechaModificacion = DateTime.Now;
                    Datos.SaveOrUpdate <MovimientoInventarioTraspasoContingencia>(Contingencia);

                    int    iSucursalID = ContingenciaCompleta.SucursalOrigenID.Valor();
                    string sOrigen     = UtilDatos.NombreDeSucursal(ContingenciaCompleta.SucursalOrigenID.Valor());
                    string sDestino    = UtilDatos.NombreDeSucursal(ContingenciaCompleta.SucursalDestinoID.Valor());
                    var    oPrecio     = Datos.GetEntity <PartePrecio>(c => c.ParteID == ContingenciaCompleta.ParteID && c.Estatus);

                    switch (Util.Entero(cboTipoOperacion.SelectedValue))
                    {
                    case 2:

                        #region [ Entrada Inventario ]

                        //Insertar Movimiento
                        var movimientoEntradaI = new MovimientoInventario()
                        {
                            TipoOperacionID   = Util.Entero(this.cboTipoOperacion.SelectedValue),
                            TipoPagoID        = 1,
                            ProveedorID       = 1,
                            SucursalOrigenID  = ContingenciaCompleta.SucursalOrigenID,
                            SucursalDestinoID = ContingenciaCompleta.SucursalDestinoID,
                            FechaFactura      = DateTime.Now,
                            FechaRecepcion    = DateTime.Now,
                            FolioFactura      = null,
                            Subtotal          = null,
                            IVA                      = null,
                            ImporteTotal             = 0,
                            FueLiquidado             = false,
                            TipoConceptoOperacionID  = ContingenciaCompleta.TipoConceptoOperacionID,
                            Observacion              = string.Format("{0}: {1}", "Traspaso por resolucion de un Conflicto. Movimiento: ", Contingencia.MovimientoInventarioID),
                            Articulos                = null,
                            Unidades                 = null,
                            Seguro                   = null,
                            ImporteTotalSinDescuento = null
                        };
                        Datos.Guardar <MovimientoInventario>(movimientoEntradaI);

                        if (movimientoEntradaI.MovimientoInventarioID < 1)
                        {
                            new EntityNotFoundException("MovimientoInventarioID", "MovimientoInventario");
                            return;
                        }

                        //Insertar MovimientoDetalle
                        var detalleMovimiento = new MovimientoInventarioDetalle()
                        {
                            MovimientoInventarioID = movimientoEntradaI.MovimientoInventarioID,
                            ParteID        = ContingenciaCompleta.ParteID,
                            Cantidad       = Util.Decimal(ContingenciaCompleta.Diferencia),
                            PrecioUnitario = 0,
                            Importe        = 0,
                            FueDevolucion  = false,
                            FechaRegistro  = DateTime.Now,
                            Estatus        = true
                        };
                        Datos.SaveOrUpdate <MovimientoInventarioDetalle>(detalleMovimiento);

                        //Actualizar ParteExistencia

                        /* var sucursalId = ContingenciaCompleta.SucursalOrigenID;
                         * var existencia = General.GetEntity<ParteExistencia>(p => p.ParteID == ContingenciaCompleta.ParteID && p.SucursalID == sucursalId);
                         * if (existencia != null)
                         * {
                         *  existencia.Existencia += Util.ConvertirDecimal(ContingenciaCompleta.Diferencia);
                         *  Datos.Guardar<ParteExistencia>(existencia);//dmod
                         * }
                         */
                        // AdmonProc.AgregarExistencia(ContingenciaCompleta.ParteID, sucursalId.Valor(), ContingenciaCompleta.Diferencia.Valor()
                        //     , Cat.Tablas.MovimientoInventario, movimientoEntradaI.MovimientoInventarioID);

                        // Se modifica la existencia y el kardex
                        AdmonProc.AfectarExistenciaYKardex(ContingenciaCompleta.ParteID, iSucursalID, Cat.OperacionesKardex.EntradaTraspaso
                                                           , Contingencia.MovimientoInventarioID.ToString(), Contingencia.UsuarioSolucionoID.Valor(), "Conflicto Resuelto Entrada"
                                                           , sOrigen, sDestino, ContingenciaCompleta.Diferencia.Valor()
                                                           , oPrecio.Costo.Valor(), Cat.Tablas.MovimientoInventario, movimientoEntradaI.MovimientoInventarioID);

                        #endregion

                        break;

                    case 3:

                        #region [ Salida Inventario ]

                        //Insertar Movimiento
                        var movimientoSalida = new MovimientoInventario()
                        {
                            TipoOperacionID   = Util.Entero(this.cboTipoOperacion.SelectedValue),
                            TipoPagoID        = 1,
                            ProveedorID       = 1,
                            SucursalOrigenID  = ContingenciaCompleta.SucursalOrigenID,
                            SucursalDestinoID = ContingenciaCompleta.SucursalDestinoID,
                            FechaFactura      = DateTime.Now,
                            FechaRecepcion    = DateTime.Now,
                            FolioFactura      = null,
                            Subtotal          = null,
                            IVA                      = null,
                            ImporteTotal             = 0,
                            FueLiquidado             = false,
                            TipoConceptoOperacionID  = Util.Entero(this.cboConceptoOperacion.SelectedValue),
                            Observacion              = string.Format("{0}: {1}", "Traspaso por resolucion de un Conflicto. Movimiento: ", Contingencia.MovimientoInventarioID),
                            Articulos                = null,
                            Unidades                 = null,
                            Seguro                   = null,
                            ImporteTotalSinDescuento = null
                        };
                        Datos.Guardar <MovimientoInventario>(movimientoSalida);

                        if (movimientoSalida.MovimientoInventarioID < 1)
                        {
                            new EntityNotFoundException("MovimientoInventarioID", "MovimientoInventario");
                            return;
                        }

                        //Insertar MovimientoDetalle
                        var detalleMovimientoS = new MovimientoInventarioDetalle()
                        {
                            MovimientoInventarioID = movimientoSalida.MovimientoInventarioID,
                            ParteID        = ContingenciaCompleta.ParteID,
                            Cantidad       = Util.Decimal(ContingenciaCompleta.Diferencia),
                            PrecioUnitario = 0,
                            Importe        = 0,
                            FueDevolucion  = false,
                            FechaRegistro  = DateTime.Now,
                            Estatus        = true
                        };
                        Datos.SaveOrUpdate <MovimientoInventarioDetalle>(detalleMovimientoS);

                        //No se descuenta por que ya se habia descontado en el traspaso anterior
                        // Ahora sí se generan dos registros en kardex, uno de entrada y luego uno de salida, para que al final quede igual
                        // Se hace así para mantener un registro de la operación
                        // Se hace primero la entrada
                        AdmonProc.AfectarExistenciaYKardex(ContingenciaCompleta.ParteID, iSucursalID, Cat.OperacionesKardex.EntradaTraspaso
                                                           , Contingencia.MovimientoInventarioID.ToString(), Contingencia.UsuarioSolucionoID.Valor(), "Conflicto Resuelto Salida"
                                                           , sOrigen, sDestino, ContingenciaCompleta.Diferencia.Valor()
                                                           , oPrecio.Costo.Valor(), Cat.Tablas.MovimientoInventario, movimientoSalida.MovimientoInventarioID);
                        // Luego la salida
                        AdmonProc.AfectarExistenciaYKardex(ContingenciaCompleta.ParteID, iSucursalID, Cat.OperacionesKardex.SalidaTraspaso
                                                           , Contingencia.MovimientoInventarioID.ToString(), Contingencia.UsuarioSolucionoID.Valor(), "Conflicto Resuelto Salida"
                                                           , sOrigen, sDestino, (ContingenciaCompleta.Diferencia.Valor() * -1)
                                                           , oPrecio.Costo.Valor(), Cat.Tablas.MovimientoInventario, movimientoSalida.MovimientoInventarioID);

                        #endregion

                        break;

                    case 5:

                        #region [ Traspaso ]

                        //Almacenar traspaso
                        var traspaso = new MovimientoInventario()
                        {
                            TipoOperacionID           = Util.Entero(this.cboTipoOperacion.SelectedValue),
                            SucursalOrigenID          = ContingenciaCompleta.SucursalOrigenID,
                            SucursalDestinoID         = ContingenciaCompleta.SucursalDestinoID,
                            ImporteTotal              = 0,
                            FueLiquidado              = false,
                            UsuarioSolicitoTraspasoID = Contingencia.UsuarioSolucionoID,
                            ExisteContingencia        = false,
                            Observacion = string.Format("{0}: {1}", "Traspaso por resolucion de un Conflicto. Movimiento: ", Contingencia.MovimientoInventarioID)
                        };
                        Datos.Guardar <MovimientoInventario>(traspaso);

                        //Almacenar el detalle del traspaso
                        if (traspaso.MovimientoInventarioID > 0)
                        {
                            var detalleTraspaso = new MovimientoInventarioDetalle()
                            {
                                MovimientoInventarioID = traspaso.MovimientoInventarioID,
                                ParteID        = ContingenciaCompleta.ParteID,
                                Cantidad       = Util.Decimal(ContingenciaCompleta.Diferencia),
                                PrecioUnitario = 0,
                                Importe        = 0,
                                FueDevolucion  = false,
                                FechaRegistro  = DateTime.Now,
                                Estatus        = true
                            };
                            Datos.SaveOrUpdate <MovimientoInventarioDetalle>(detalleTraspaso);

                            //No se descuenta por que ya se habia descontado en el primer traspaso
                        }

                        #endregion

                        break;

                    default:
                        break;
                    }
                }
                SplashScreen.Close();
                this.btnGuardar.Enabled = true;
                new Notificacion("Conflicto Resuelto exitosamente", 2 * 1000).Mostrar(Principal.Instance);
                catalogosTraspasos.Instance.CustomInvoke <catalogosTraspasos>(m => m.ActualizarListadoConflictos());
            }
            catch (Exception ex)
            {
                SplashScreen.Close();
                this.btnGuardar.Enabled = true;
                Util.MensajeError(ex.Message, GlobalClass.NombreApp);
            }
            this.Close();
        }
Example #4
0
        private void btnFinish_Click(object sender, EventArgs e)
        {
            try
            {
                if (!this.ValidarFinal())
                    return;

                int iAutorizoID = 0;
                var ResU = UtilLocal.ValidarObtenerUsuario(null, "Autorización");
                if (ResU.Exito)
                    iAutorizoID = ResU.Respuesta.UsuarioID;
                else
                {
                    Util.MensajeError("Error al validar el usuario.", GlobalClass.NombreApp);
                    return;
                }

                var res = Util.MensajePregunta("¿Está seguro de que la información es correcta?", GlobalClass.NombreApp);
                if (res == DialogResult.No)
                    return;

                SplashScreen.Show(new Splash());
                this.btnFinish.Enabled = false;

                var proveedorId = Util.Entero(this.cboProveedor.SelectedValue);
                var sucursalId = Util.Entero(this.cboUbicacionDestino.SelectedValue);
                var iva = 1 + (GlobalClass.ConfiguracionGlobal.IVA / 100);

                switch (Util.Entero(cboTipoOperacion.SelectedValue))
                {
                    case 1:

                        #region [ Entrada Compra ]

                        // Se valida que no se haya utilizado ese folio de factura
                        var folio = Datos.GetEntity<MovimientoInventario>(m => m.ProveedorID == proveedorId
                            && m.FolioFactura == this.txtFolioFactura.Text && m.Estatus.Equals(true));
                        if (folio != null)
                        {
                            this.Cursor = Cursors.Default;
                            SplashScreen.Close();
                            var msj = string.Format("{0} {1} {2}", "El Folio Factura", this.txtFolioFactura.Text, "Ya fue utilizado con el proveedor seleccionado.");
                            Util.MensajeError(msj, GlobalClass.NombreApp);
                            return;
                        }

                        //Insertar Movimiento
                        var subtotal = Util.Decimal(this.txtSubtotal.Text);
                        var importeTotal = Util.Decimal(this.lblTotal.Text);
                        var movimientoEntrada = new MovimientoInventario()
                        {
                            TipoOperacionID = Util.Entero(this.cboTipoOperacion.SelectedValue),
                            TipoPagoID = Util.Entero(this.cboTipoPago.SelectedValue),
                            ProveedorID = proveedorId,
                            SucursalOrigenID = Util.Entero(this.cboUbicacionOrigen.SelectedValue),
                            SucursalDestinoID = Util.Entero(this.cboUbicacionDestino.SelectedValue),
                            FechaFactura = this.dtpFechaFacturacion.Value,
                            FechaRecepcion = this.dtpFechaRecepcion.Value,
                            FolioFactura = this.txtFolioFactura.Text,
                            Subtotal = subtotal,
                            IVA = importeTotal - subtotal,
                            ImporteTotal = importeTotal,
                            FueLiquidado = false,
                            TipoConceptoOperacionID = null,
                            Observacion = this.txtObservaciones.Text,
                            Articulos = Util.Decimal(this.txtArticulos.Text),
                            Unidades = Util.Decimal(this.txtUnidades.Text),
                            Seguro = Util.Decimal(this.txtSeguro.Text),
                            ImporteTotalSinDescuento = Util.Decimal(this.lblTotalSinDescuento.Text),
                            ImporteFactura = Util.Decimal(this.lblImporteFactura.Text)
                        };
                        Datos.Guardar<MovimientoInventario>(movimientoEntrada);

                        if (movimientoEntrada.MovimientoInventarioID < 1)
                        {
                            this.Cursor = Cursors.Default;
                            SplashScreen.Close();
                            new EntityNotFoundException("MovimientoInventarioID", "MovimientoInventario");
                            return;
                        }

                        //Insertar MovimientoDetalle
                        foreach (DataGridViewRow row in this.dgvDetalleDescuentos.Rows)
                        {
                            var parteId = Util.Entero(row.Cells["ParteID"].Value);
                            var cantidad = Util.Decimal(row.Cells["UNS"].Value);
                            var detalleMovimiento = new MovimientoInventarioDetalle()
                            {
                                MovimientoInventarioID = movimientoEntrada.MovimientoInventarioID,
                                ParteID = parteId,
                                Cantidad = cantidad,
                                PrecioUnitario = Util.Decimal(row.Cells["Unitario"].Value),
                                Importe = Util.Decimal(row.Cells["Importe"].Value),
                                FueDevolucion = false,
                                FechaRegistro = DateTime.Now,
                                Estatus = true
                            };
                            Datos.SaveOrUpdate<MovimientoInventarioDetalle>(detalleMovimiento);

                            // Se actualiza la existencia y el kardex
                            int iFilaDif = this.dgvDiferencia.EncontrarIndiceDeValor("ParteID", parteId);
                            AdmonProc.AfectarExistenciaYKardex(parteId, sucursalId, Cat.OperacionesKardex.EntradaCompra, movimientoEntrada.FolioFactura, iAutorizoID
                                , this.cboProveedor.Text, proveedorId.ToString(), this.cboUbicacionDestino.Text, cantidad
                                , Util.Decimal(this.dgvDiferencia["Costo Nuevo", iFilaDif].Value)
                                , Cat.Tablas.MovimientoInventario, movimientoEntrada.MovimientoInventarioID);

                            var oExistencia = Datos.GetEntity<ParteExistencia>(c => c.ParteID == parteId && c.SucursalID == sucursalId && c.Estatus);
                            var historial = new MovimientoInventarioHistorial()
                            {
                                MovmientoInventarioID = movimientoEntrada.MovimientoInventarioID,
                                ParteID = parteId,
                                ExistenciaInicial = Util.Decimal(oExistencia.Existencia - cantidad),
                                ExistenciaFinal = Util.Decimal(oExistencia.Existencia),
                                SucursalID = Util.Entero(this.cboUbicacionDestino.SelectedValue)
                            };
                            Datos.Guardar<MovimientoInventarioHistorial>(historial);

                            /*
                            var oParte = General.GetEntity<Parte>(c => c.ParteID == parteId && c.Estatus);
                            if (!oParte.EsServicio.Valor())
                            {
                                var existencia = General.GetEntity<ParteExistencia>(p => p.ParteID == parteId && p.SucursalID == sucursalId);
                                if (existencia != null)
                                {
                                    var inicial = existencia.Existencia;
                                    existencia.Existencia += cantidad;
                                    // Datos.Guardar<ParteExistencia>(existencia);
                                    AdmonProc.AgregarExistencia(parteId, sucursalId, cantidad, Cat.Tablas.MovimientoInventario, movimientoEntrada.MovimientoInventarioID);

                                    var historial = new MovimientoInventarioHistorial()
                                    {
                                        MovmientoInventarioID = movimientoEntrada.MovimientoInventarioID,
                                        ParteID = parteId,
                                        ExistenciaInicial = Util.ConvertirDecimal(inicial),
                                        ExistenciaFinal = Util.ConvertirDecimal(existencia.Existencia),
                                        SucursalID = Util.ConvertirEntero(this.cboUbicacionDestino.SelectedValue)
                                    };
                                    Datos.Guardar<MovimientoInventarioHistorial>(historial);
                                }
                            }
                            // Se agrega al Kardex
                            int iFilaDif = this.dgvDiferencia.EncontrarIndiceDeValor("ParteID", parteId);
                            AdmonProc.RegistrarKardex(new ParteKardex()
                            {
                                ParteID = parteId,
                                OperacionID = Cat.OperacionesKardex.EntradaCompra,
                                SucursalID = sucursalId,
                                Folio = movimientoEntrada.FolioFactura,
                                Fecha = DateTime.Now,
                                RealizoUsuarioID = iAutorizoID,
                                Entidad = this.cboProveedor.Text,
                                Origen = proveedorId.ToString(),
                                Destino = this.cboUbicacionDestino.Text,
                                Cantidad = cantidad,
                                Importe = Util.ConvertirDecimal(this.dgvDiferencia["Costo Nuevo", iFilaDif].Value),
                                RelacionTabla = Cat.Tablas.MovimientoInventario,
                                RelacionID = movimientoEntrada.MovimientoInventarioID
                            });
                            */

                            // Se afectan los datos del pedido, si aplica
                            // if (this.dgvDetalleCaptura.Tag != null)
                            if (this.iCompraDePedidoID > 0)
                            {
                                int iPedidoID = this.iCompraDePedidoID; // Util.ConvertirEntero(this.dgvDetalleCaptura.Tag);
                                var oPartesPed = Datos.GetListOf<PedidoDetalle>(c => c.PedidoID == iPedidoID && c.PedidoEstatusID == Cat.PedidosEstatus.NoSurtido
                                    && c.Estatus);
                                var oPartePed = oPartesPed.FirstOrDefault(c => c.ParteID == parteId);
                                if (oPartePed != null)
                                {
                                    oPartePed.PedidoEstatusID = Cat.PedidosEstatus.Surtido;
                                    Datos.Guardar<PedidoDetalle>(oPartePed);
                                    // Se verifica si ya no quedan pedidos pendientes, para marcar como Surtido
                                    if (oPartesPed.Count == 1)
                                    {
                                        var oPedido = Datos.GetEntity<Pedido>(c => c.PedidoID == oPartePed.PedidoID && c.Estatus);
                                        oPedido.PedidoEstatusID = Cat.PedidosEstatus.Surtido;
                                        Datos.Guardar<Pedido>(oPedido);
                                    }

                                }
                            }

                        }

                        // Para limpiar el estatus de relación con un pedido
                        // this.dgvDetalleCaptura.Tag = null;
                        this.iCompraDePedidoID = 0;

                        //Insertar MovimientoDescuentos
                        foreach (DataGridViewRow row in this.dgvHistorialDescuentos.Rows)
                        {
                            int tipoDescuento = Util.Entero(row.Cells["TipoDescuento"].Value);
                            int tipoDescuentoId = 1;
                            switch (tipoDescuento)
                            {
                                case -1: tipoDescuentoId = 2; break;
                                case 2: tipoDescuentoId = 3; break;
                                case 3: tipoDescuentoId = 4; break;
                                case -2: tipoDescuentoId = 5; break;
                                case -3: tipoDescuentoId = Cat.TiposDeDescuentoCompras.IndividualAFactura; break;
                            }

                            var parteId = Util.Entero(row.Cells["ParteID"].Value);
                            var hisDesc = new MovimientoInventarioDescuento()
                            {
                                MovimientoInventarioID = movimientoEntrada.MovimientoInventarioID,
                                ParteID = parteId,
                                TipoDescuentoID = tipoDescuentoId,
                                DescuentoUno = Util.Decimal(row.Cells["DescuentoUno"].Value),
                                DescuentoDos = Util.Decimal(row.Cells["DescuentoDos"].Value),
                                DescuentoTres = Util.Decimal(row.Cells["DescuentoTres"].Value),
                                DescuentoCuatro = Util.Decimal(row.Cells["DescuentoCuatro"].Value),
                                DescuentoCinco = Util.Decimal(row.Cells["DescuentoCinco"].Value)
                            };
                            Datos.Guardar<MovimientoInventarioDescuento>(hisDesc);
                        }

                        //Actualizar PartePrecio
                        foreach (DataGridViewRow row in this.dgvDiferencia.Rows)
                        {
                            var parteId = Util.Entero(row.Cells["ParteID"].Value);
                            var partePrecio = Datos.GetEntity<PartePrecio>(p => p.ParteID.Equals(parteId));
                            var oPartePrecioAnt = Datos.GetEntity<PartePrecio>(c => c.ParteID == parteId && c.Estatus);
                            var costoNuevo = Util.Decimal(row.Cells["Costo Nuevo"].Value);
                            var costoActual = Util.Decimal(row.Cells["Costo Actual"].Value);
                            decimal costoConDescuento = 0;
                            if (partePrecio != null)
                            {
                                if (Convert.ToBoolean(row.Cells["X"].Value).Equals(true))
                                    partePrecio.Costo = costoNuevo;
                                else
                                    partePrecio.Costo = costoActual;

                                partePrecio.PorcentajeUtilidadUno = Util.Decimal(row.Cells["%1"].Value);
                                partePrecio.PorcentajeUtilidadDos = Util.Decimal(row.Cells["%2"].Value);
                                partePrecio.PorcentajeUtilidadTres = Util.Decimal(row.Cells["%3"].Value);
                                partePrecio.PorcentajeUtilidadCuatro = Util.Decimal(row.Cells["%4"].Value);
                                partePrecio.PorcentajeUtilidadCinco = Util.Decimal(row.Cells["%5"].Value);

                                partePrecio.PrecioUno = Util.Decimal(row.Cells["Precio 1"].Value);
                                partePrecio.PrecioDos = Util.Decimal(row.Cells["Precio 2"].Value);
                                partePrecio.PrecioTres = Util.Decimal(row.Cells["Precio 3"].Value);
                                partePrecio.PrecioCuatro = Util.Decimal(row.Cells["Precio 4"].Value);
                                partePrecio.PrecioCinco = Util.Decimal(row.Cells["Precio 5"].Value);

                                //CostoConDescuento, calcular el descuento por fila, si existen descuentos a Factura y a Marca Factura
                                var rowIndex = UtilLocal.findRowIndex(this.dgvDetalleDescuentos, "ParteID", parteId.ToString());
                                if (rowIndex != -1)
                                {
                                    costoConDescuento = Util.Decimal(this.dgvDetalleDescuentos.Rows[rowIndex].Cells["CostoConDescuentoNuevo"].Value);
                                    partePrecio.CostoConDescuento = costoConDescuento;

                                    /*
                                    var rowIndexHisAFactura = Util.findRowIndex(this.dgvHistorialDescuentos, "ParteID", "-1");
                                    if (rowIndexHisAFactura != -1)
                                    {
                                        var desUno = Util.ConvertirDecimal(this.dgvHistorialDescuentos.Rows[rowIndexHisAFactura].Cells["DescuentoUno"].Value);
                                        var desDos = Util.ConvertirDecimal(this.dgvHistorialDescuentos.Rows[rowIndexHisAFactura].Cells["DescuentoDos"].Value);
                                        var desTres = Util.ConvertirDecimal(this.dgvHistorialDescuentos.Rows[rowIndexHisAFactura].Cells["DescuentoTres"].Value);
                                        var desCuatro = Util.ConvertirDecimal(this.dgvHistorialDescuentos.Rows[rowIndexHisAFactura].Cells["DescuentoCuatro"].Value);
                                        var desCinco = Util.ConvertirDecimal(this.dgvHistorialDescuentos.Rows[rowIndexHisAFactura].Cells["DescuentoCinco"].Value);
                                        precioConDescuento = this.calcularDescuento(precioConDescuento, desUno, desDos, desTres, desCuatro, desCinco);
                                    }

                                    var rowIndexHisAMarcaF = -1;
                                    foreach (DataGridViewRow fila in this.dgvHistorialDescuentos.Rows)
                                    {
                                        if (Util.ConvertirEntero(fila.Cells["ParteID"].Value).Equals(parteId) && Util.ConvertirEntero(fila.Cells["TipoDescuento"].Value).Equals(-2))
                                        {
                                            rowIndexHisAMarcaF = fila.Index;
                                        }
                                    }
                                    if (rowIndexHisAMarcaF != -1)
                                    {
                                        var desUno = Util.ConvertirDecimal(this.dgvHistorialDescuentos.Rows[rowIndexHisAMarcaF].Cells["DescuentoUno"].Value);
                                        var desDos = Util.ConvertirDecimal(this.dgvHistorialDescuentos.Rows[rowIndexHisAMarcaF].Cells["DescuentoDos"].Value);
                                        var desTres = Util.ConvertirDecimal(this.dgvHistorialDescuentos.Rows[rowIndexHisAMarcaF].Cells["DescuentoTres"].Value);
                                        var desCuatro = Util.ConvertirDecimal(this.dgvHistorialDescuentos.Rows[rowIndexHisAMarcaF].Cells["DescuentoCuatro"].Value);
                                        var desCinco = Util.ConvertirDecimal(this.dgvHistorialDescuentos.Rows[rowIndexHisAMarcaF].Cells["DescuentoCinco"].Value);
                                        precioConDescuento = this.calcularDescuento(precioConDescuento, desUno, desDos, desTres, desCuatro, desCinco);
                                    }
                                    partePrecio.CostoConDescuento = precioConDescuento;
                                    */
                                }

                                Datos.Guardar<PartePrecio>(partePrecio);

                                //Si cambia de el valor del precio entonces
                                //Actualizar PartePrecioHistorico
                                if (partePrecio.Costo != oPartePrecioAnt.Costo || partePrecio.CostoConDescuento != oPartePrecioAnt.CostoConDescuento
                                    || partePrecio.PrecioUno != oPartePrecioAnt.PrecioUno || partePrecio.PrecioDos != oPartePrecioAnt.PrecioDos
                                    || partePrecio.PrecioDos != oPartePrecioAnt.PrecioDos || partePrecio.PrecioTres != oPartePrecioAnt.PrecioTres
                                    || partePrecio.PrecioCinco != oPartePrecioAnt.PrecioCinco)
                                {
                                    var precioHis = new PartePrecioHistorico()
                                    {
                                        ParteID = parteId,
                                        MovimientoInventarioID = movimientoEntrada.MovimientoInventarioID,
                                        CostoNuevo = costoNuevo,
                                        CostoActual = costoActual,
                                        CostoConDescuento = costoConDescuento,
                                        PorcentajeUtilidadUno = Util.Decimal(row.Cells["%1"].Value),
                                        PorcentajeUtilidadDos = Util.Decimal(row.Cells["%2"].Value),
                                        PorcentajeUtilidadTres = Util.Decimal(row.Cells["%3"].Value),
                                        PorcentajeUtilidadCuatro = Util.Decimal(row.Cells["%4"].Value),
                                        PorcentajeUtilidadCinco = Util.Decimal(row.Cells["%5"].Value),
                                        PrecioUno = Util.Decimal(row.Cells["Precio 1"].Value),
                                        PrecioDos = Util.Decimal(row.Cells["Precio 2"].Value),
                                        PrecioTres = Util.Decimal(row.Cells["Precio 3"].Value),
                                        PrecioCuatro = Util.Decimal(row.Cells["Precio 4"].Value),
                                        PrecioCinco = Util.Decimal(row.Cells["Precio 5"].Value)
                                    };
                                    Datos.Guardar<PartePrecioHistorico>(precioHis);
                                }
                            }

                            //Actualizar MovimientoInventarioEtiqueta
                            var etiqueta = new MovimientoInventarioEtiqueta()
                            {
                                MovimientoInventarioID = movimientoEntrada.MovimientoInventarioID,
                                ParteID = parteId,
                                NumeroEtiquetas = Util.Entero(row.Cells["Etiqueta"].Value),
                            };
                            Datos.Guardar<MovimientoInventarioEtiqueta>(etiqueta);
                        }

                        //Guardar Imagen en Directorio
                        //Nombre Imagen = MovimientoID_FolioFactura
                        /* De momento no se usa. Se quitó por incompatiblidad con el parámetro "pathImagenesMovimientos". Moi 07/05/2015
                        if (this.picBoxImagen.Image != null)
                        {
                            var pathProveedor = System.IO.Path.Combine(GlobalClass.ConfiguracionGlobal.pathImagenesMovimientos, "Compras", this.cboProveedor.Text, DateTime.Now.Year.ToString());
                            if (!System.IO.Directory.Exists(pathProveedor))
                                System.IO.Directory.CreateDirectory(pathProveedor);

                            //Guardar Imagen en la tabla
                            movimientoEntrada.NombreImagen = string.Format("{0}_{1}{2}", movimientoEntrada.MovimientoInventarioID, movimientoEntrada.FolioFactura, ".jpg");
                            Datos.Guardar<MovimientoInventario>(movimientoEntrada);

                            var path = System.IO.Path.Combine(pathProveedor, movimientoEntrada.NombreImagen);
                            picBoxImagen.Image.Save(path, ImageFormat.Jpeg);
                        } */

                        // Se manda a afectar contabilidad (AfeConta)
                        if (this.chkEsNota.Checked)
                            ContaProc.CrearPolizaAfectacion(Cat.ContaAfectaciones.CompraCreditoNota, movimientoEntrada.MovimientoInventarioID
                                , movimientoEntrada.FolioFactura, this.cboProveedor.Text, sucursalId);
                        else
                            ContaProc.CrearPolizaAfectacion(Cat.ContaAfectaciones.CompraCreditoFactura, movimientoEntrada.MovimientoInventarioID
                                , movimientoEntrada.FolioFactura, this.cboProveedor.Text, sucursalId);

                        SplashScreen.Close();
                        this.btnFinish.Enabled = true;
                        this.Cursor = Cursors.Default;

                        //Visor de ticket de entrada compra
                        ReporteadorMovimientos visor = ReporteadorMovimientos.Instance;
                        visor.oID = movimientoEntrada.MovimientoInventarioID;
                        visor.oTipoReporte = 3;
                        visor.Load();

                        var resEtiqueta = Util.MensajePregunta("Desea imprimir las etiquetas?", GlobalClass.NombreApp);
                        if (resEtiqueta == DialogResult.Yes)
                        {
                            //VisorDeReportes visor = VisorDeReportes.Instance;
                            ReporteadorMovimientos visorEt = ReporteadorMovimientos.Instance;
                            visorEt.oID = movimientoEntrada.MovimientoInventarioID;
                            visorEt.oTipoReporte = 2;
                            visorEt.Load();
                        }

                        #endregion

                        break;

                    case 2:

                        #region [ Entrada Inventario ]

                        //Insertar Movimiento
                        var movimientoEntradaI = new MovimientoInventario()
                        {
                            TipoOperacionID = Util.Entero(this.cboTipoOperacion.SelectedValue),
                            TipoPagoID = Util.Entero(this.cboTipoPago.SelectedValue),
                            ProveedorID = proveedorId,
                            SucursalOrigenID = Util.Entero(this.cboUbicacionOrigen.SelectedValue),
                            SucursalDestinoID = Util.Entero(this.cboUbicacionDestino.SelectedValue),
                            FechaFactura = this.dtpFechaFacturacion.Value,
                            FechaRecepcion = this.dtpFechaRecepcion.Value,
                            FolioFactura = null,
                            Subtotal = null,
                            IVA = null,
                            ImporteTotal = 0,
                            FueLiquidado = false,
                            TipoConceptoOperacionID = Util.Entero(this.cboConceptoOperacion.SelectedValue),
                            Observacion = this.txtObservaciones.Text,
                            Articulos = null,
                            Unidades = null,
                            Seguro = null,
                            ImporteTotalSinDescuento = null
                        };
                        Datos.Guardar<MovimientoInventario>(movimientoEntradaI);

                        if (movimientoEntradaI.MovimientoInventarioID < 1)
                        {
                            this.Cursor = Cursors.Default;
                            SplashScreen.Close();
                            new EntityNotFoundException("MovimientoInventarioID", "MovimientoInventario");
                            return;
                        }

                        //Insertar MovimientoDetalle
                        foreach (DataGridViewRow row in this.dgvDetalleCaptura.Rows)
                        {
                            var parteId = Util.Entero(row.Cells["ParteID"].Value);
                            var cantidad = Util.Decimal(row.Cells["UNS"].Value);
                            var detalleMovimiento = new MovimientoInventarioDetalle()
                            {
                                MovimientoInventarioID = movimientoEntradaI.MovimientoInventarioID,
                                ParteID = parteId,
                                Cantidad = cantidad,
                                PrecioUnitario = 0,
                                Importe = 0,
                                FueDevolucion = false,
                                FechaRegistro = DateTime.Now,
                                Estatus = true
                            };
                            Datos.SaveOrUpdate<MovimientoInventarioDetalle>(detalleMovimiento);

                            // Se actualiza la existencia y el kardex
                            bool bEntradaGarantia = (Util.Entero(this.cboConceptoOperacion.SelectedValue) == Cat.MovimientosConceptosDeOperacion.EntradaGarantia);
                            var oPartePrecio = Datos.GetEntity<PartePrecio>(c => c.ParteID == parteId && c.Estatus);
                            AdmonProc.AfectarExistenciaYKardex(parteId, sucursalId, Cat.OperacionesKardex.EntradaInventario, movimientoEntradaI.MovimientoInventarioID.ToString(), iAutorizoID
                                , this.cboConceptoOperacion.Text, (bEntradaGarantia ? "GARANTÍA" : "----"), this.cboUbicacionDestino.Text, cantidad
                                , oPartePrecio.Costo.Valor(), Cat.Tablas.MovimientoInventario, movimientoEntradaI.MovimientoInventarioID);

                            var oExistencia = Datos.GetEntity<ParteExistencia>(c => c.ParteID == parteId && c.SucursalID == sucursalId && c.Estatus);
                            var historial = new MovimientoInventarioHistorial()
                            {
                                MovmientoInventarioID = movimientoEntradaI.MovimientoInventarioID,
                                ParteID = parteId,
                                ExistenciaInicial = Util.Decimal(oExistencia.Existencia - cantidad),
                                ExistenciaFinal = Util.Decimal(oExistencia.Existencia),
                                SucursalID = Util.Entero(this.cboUbicacionDestino.SelectedValue)
                            };
                            Datos.Guardar<MovimientoInventarioHistorial>(historial);

                            //Actualizar ParteExistencia
                            /*
                            var oParte = General.GetEntity<Parte>(c => c.ParteID == parteId && c.Estatus);
                            if (!oParte.EsServicio.Valor())
                            {
                                var existencia = General.GetEntity<ParteExistencia>(p => p.ParteID == parteId && p.SucursalID == sucursalId);
                                if (existencia != null)
                                {
                                    var inicial = existencia.Existencia;
                                    existencia.Existencia += cantidad;
                                    // Datos.Guardar<ParteExistencia>(existencia);
                                    AdmonProc.AgregarExistencia(parteId, sucursalId, cantidad, Cat.Tablas.MovimientoInventario, movimientoEntradaI.MovimientoInventarioID);

                                    var historial = new MovimientoInventarioHistorial()
                                    {
                                        MovmientoInventarioID = movimientoEntradaI.MovimientoInventarioID,
                                        ParteID = parteId,
                                        ExistenciaInicial = Util.ConvertirDecimal(inicial),
                                        ExistenciaFinal = Util.ConvertirDecimal(existencia.Existencia),
                                        SucursalID = Util.ConvertirEntero(this.cboUbicacionDestino.SelectedValue)
                                    };
                                    Datos.Guardar<MovimientoInventarioHistorial>(historial);
                                }
                            }
                            // Se agrega al Kardex
                            var oPartePrecio = General.GetEntity<PartePrecio>(c => c.ParteID == parteId && c.Estatus);
                            AdmonProc.RegistrarKardex(new ParteKardex()
                            {
                                ParteID = parteId,
                                OperacionID = Cat.OperacionesKardex.EntradaInventario,
                                SucursalID = sucursalId,
                                Folio = movimientoEntradaI.MovimientoInventarioID.ToString(),
                                Fecha = DateTime.Now,
                                RealizoUsuarioID = iAutorizoID,
                                Entidad = "----",
                                Origen = (bEntradaGarantia ? "GARANTÍA" : "----"),
                                Destino = this.cboUbicacionDestino.Text,
                                Cantidad = cantidad,
                                Importe = oPartePrecio.Costo.Valor(),
                                RelacionTabla = Cat.Tablas.MovimientoInventario,
                                RelacionID = movimientoEntradaI.MovimientoInventarioID
                            });
                            */

                            // Se verifica si es una garantía, para cambiar el estatus correspondiente
                            if (bEntradaGarantia)
                            {
                                int iGarantiaID = Util.Entero(row.Tag);
                                var oGarantia = Datos.GetEntity<VentaGarantia>(c => c.VentaGarantiaID == iGarantiaID && c.Estatus);
                                if (oGarantia != null)
                                {
                                    oGarantia.RespuestaID = Cat.VentasGarantiasRespuestas.ArticuloNuevo;
                                    if (oGarantia.AccionID == Cat.VentasGarantiasAcciones.RevisionDeProveedor)
                                    {
                                        oGarantia.EstatusGenericoID = Cat.EstatusGenericos.Resuelto;
                                    }
                                    else
                                    {
                                        oGarantia.FechaCompletado = DateTime.Now;
                                        oGarantia.EstatusGenericoID = Cat.EstatusGenericos.Completada;
                                    }
                                    Datos.Guardar<VentaGarantia>(oGarantia);
                                }
                            }

                        }

                        // Se manda a afectar contabilidad (AfeConta)
                        ContaProc.CrearPolizaAfectacion(Cat.ContaAfectaciones.EntradaInventario, movimientoEntradaI.MovimientoInventarioID
                            , ResU.Respuesta.NombreUsuario, movimientoEntradaI.Observacion, sucursalId);

                        SplashScreen.Close();
                        this.btnFinish.Enabled = true;
                        this.Cursor = Cursors.Default;

                        //Visor de ticket de entrada compra
                        ReporteadorMovimientos visorE = ReporteadorMovimientos.Instance;
                        visorE.oID = movimientoEntradaI.MovimientoInventarioID;
                        visorE.oTipoReporte = 4;
                        visorE.Load();

                        #endregion

                        break;

                    case 3:

                        #region [ Salida Inventario ]

                        //Valida la existencia antes  de dar de baja del inventario
                        bool bError = false;
                        foreach (DataGridViewRow row in this.dgvDetalleCaptura.Rows)
                        {
                            var parteId = Util.Entero(row.Cells["ParteID"].Value);
                            var cantidad = Util.Decimal(row.Cells["UNS"].Value);
                            var existencia = Datos.GetEntity<ParteExistencia>(p => p.ParteID == parteId && p.SucursalID == sucursalId && p.Estatus);
                            if (existencia.Existencia < cantidad)
                            {
                                row.ErrorText = string.Format("No hay existencia suficiente. Existencia: {0}, Salida: {1}", existencia.Existencia, cantidad);
                                row.DefaultCellStyle.ForeColor = Color.Red;
                                bError = true;
                            }
                        }
                        if (bError)
                        {
                            this.Cursor = Cursors.Default;
                            SplashScreen.Close();
                            UtilLocal.MensajeAdvertencia("Uno o más artículos no cuentan con existencia suficiente para la salida. No se puede continuar.");
                            this.btnFinish.Enabled = true;
                            return;
                        }

                        //Insertar Movimiento
                        var movimientoSalida = new MovimientoInventario()
                        {
                            TipoOperacionID = Util.Entero(this.cboTipoOperacion.SelectedValue),
                            TipoPagoID = Util.Entero(this.cboTipoPago.SelectedValue),
                            ProveedorID = proveedorId,
                            SucursalOrigenID = Util.Entero(this.cboUbicacionOrigen.SelectedValue),
                            SucursalDestinoID = Util.Entero(this.cboUbicacionDestino.SelectedValue),
                            FechaFactura = this.dtpFechaFacturacion.Value,
                            FechaRecepcion = this.dtpFechaRecepcion.Value,
                            FolioFactura = null,
                            Subtotal = null,
                            IVA = null,
                            ImporteTotal = 0,
                            FueLiquidado = false,
                            TipoConceptoOperacionID = Util.Entero(this.cboConceptoOperacion.SelectedValue),
                            Observacion = this.txtObservaciones.Text,
                            Articulos = null,
                            Unidades = null,
                            Seguro = null,
                            ImporteTotalSinDescuento = null
                        };
                        Datos.Guardar<MovimientoInventario>(movimientoSalida);

                        if (movimientoSalida.MovimientoInventarioID < 1)
                        {
                            this.Cursor = Cursors.Default;
                            SplashScreen.Close();
                            new EntityNotFoundException("MovimientoInventarioID", "MovimientoInventario");
                            return;
                        }

                        //Insertar MovimientoDetalle
                        foreach (DataGridViewRow row in this.dgvDetalleCaptura.Rows)
                        {
                            var parteId = Util.Entero(row.Cells["ParteID"].Value);
                            var cantidad = Util.Decimal(row.Cells["UNS"].Value);
                            var detalleMovimiento = new MovimientoInventarioDetalle()
                            {
                                MovimientoInventarioID = movimientoSalida.MovimientoInventarioID,
                                ParteID = parteId,
                                Cantidad = cantidad,
                                PrecioUnitario = 0,
                                Importe = 0,
                                FueDevolucion = false,
                                FechaRegistro = DateTime.Now,
                                Estatus = true
                            };
                            Datos.SaveOrUpdate<MovimientoInventarioDetalle>(detalleMovimiento);

                            // Se actualiza la existencia y el kardex
                            var oPartePrecio = Datos.GetEntity<PartePrecio>(c => c.ParteID == parteId && c.Estatus);
                            AdmonProc.AfectarExistenciaYKardex(parteId, sucursalId, Cat.OperacionesKardex.SalidaInventario
                                , movimientoSalida.MovimientoInventarioID.ToString(), iAutorizoID, this.cboConceptoOperacion.Text, "----", this.cboUbicacionDestino.Text
                                , (cantidad * -1), oPartePrecio.Costo.Valor(), Cat.Tablas.MovimientoInventario, movimientoSalida.MovimientoInventarioID);

                            var oExistencia = Datos.GetEntity<ParteExistencia>(c => c.ParteID == parteId && c.SucursalID == sucursalId && c.Estatus);
                            var historial = new MovimientoInventarioHistorial()
                            {
                                MovmientoInventarioID = movimientoSalida.MovimientoInventarioID,
                                ParteID = parteId,
                                ExistenciaInicial = Util.Decimal(oExistencia.Existencia + cantidad),
                                ExistenciaFinal = Util.Decimal(oExistencia.Existencia),
                                SucursalID = Util.Entero(this.cboUbicacionDestino.SelectedValue)
                            };
                            Datos.Guardar<MovimientoInventarioHistorial>(historial);

                            //Actualizar ParteExistencia
                            /*
                            var oParte = General.GetEntity<Parte>(c => c.ParteID == parteId && c.Estatus);
                            if (!oParte.EsServicio.Valor())
                            {
                                var existencia = General.GetEntity<ParteExistencia>(p => p.ParteID == parteId && p.SucursalID == sucursalId);
                                if (existencia != null)
                                {
                                    var inicial = existencia.Existencia;
                                    existencia.Existencia -= cantidad;
                                    // Datos.Guardar<ParteExistencia>(existencia);
                                    AdmonProc.AgregarExistencia(parteId, sucursalId, (cantidad * -1), Cat.Tablas.MovimientoInventario, movimientoSalida.MovimientoInventarioID);

                                    var historial = new MovimientoInventarioHistorial()
                                    {
                                        MovmientoInventarioID = movimientoSalida.MovimientoInventarioID,
                                        ParteID = parteId,
                                        ExistenciaInicial = Util.ConvertirDecimal(inicial),
                                        ExistenciaFinal = Util.ConvertirDecimal(existencia.Existencia),
                                        SucursalID = Util.ConvertirEntero(this.cboUbicacionDestino.SelectedValue)
                                    };
                                    Datos.Guardar<MovimientoInventarioHistorial>(historial);
                                }
                            }
                            // Se agrega al Kardex
                            var oPartePrecio = General.GetEntity<PartePrecio>(c => c.ParteID == parteId && c.Estatus);
                            AdmonProc.RegistrarKardex(new ParteKardex()
                            {
                                ParteID = parteId,
                                OperacionID = Cat.OperacionesKardex.SalidaInventario,
                                SucursalID = sucursalId,
                                Folio = movimientoSalida.MovimientoInventarioID.ToString(),
                                Fecha = DateTime.Now,
                                RealizoUsuarioID = iAutorizoID,
                                Entidad = "----",
                                Origen = "----",
                                Destino = this.cboUbicacionDestino.Text,
                                Cantidad = cantidad,
                                Importe = oPartePrecio.Costo.Valor(),
                                RelacionTabla = Cat.Tablas.MovimientoInventario,
                                RelacionID = movimientoSalida.MovimientoInventarioID
                            });
                            */
                        }

                        // Se manda a afectar contabilidad (AfeConta)
                        ContaProc.CrearPolizaAfectacion(Cat.ContaAfectaciones.SalidaInventario, movimientoSalida.MovimientoInventarioID
                            , ResU.Respuesta.NombreUsuario, movimientoSalida.Observacion, sucursalId);

                        SplashScreen.Close();
                        this.btnFinish.Enabled = true;
                        this.Cursor = Cursors.Default;

                        //Visor de ticket de entrada compra
                        ReporteadorMovimientos visorS = ReporteadorMovimientos.Instance;
                        visorS.oID = movimientoSalida.MovimientoInventarioID;
                        visorS.oTipoReporte = 5;
                        visorS.Load();

                        #endregion

                        break;

                    case 4:

                        #region [ Devolucion ]

                        // Se obtiene el movimiento fuente (la compra a la cual se le aplica la devolución / garantía)
                        int iFuenteMovDetID = Util.Entero(this.dgvDetalleCaptura["FuenteMovimientoInventarioDetalleID", 0].Value);
                        var oFuenteMovDet = Datos.GetEntity<MovimientoInventarioDetalle>(c => c.MovimientoInventarioDetalleID == iFuenteMovDetID && c.Estatus);
                        var oFuenteMov = Datos.GetEntity<MovimientoInventario>(c => c.MovimientoInventarioID == oFuenteMovDet.MovimientoInventarioID && c.Estatus);

                        //Validaciones
                        foreach (DataGridViewRow row in this.dgvDetalleCaptura.Rows)
                        {
                            if (Util.Entero(this.cboConceptoOperacion.SelectedValue) != Cat.MovimientosConceptosDeOperacion.DevolucionGarantia)
                            {
                                //Valida existencias antes de continuar
                                var parteId = Util.Entero(row.Cells["ParteID"].Value);
                                var sucursal = Util.Entero(this.cboUbicacionDestino.SelectedValue);
                                var unidades = Util.Decimal(row.Cells["UNS"].Value);
                                var existencias = Datos.GetEntity<ParteExistencia>(p => p.ParteID.Equals(parteId) && p.SucursalID.Equals(sucursal) && p.Estatus);
                                if (existencias.Existencia < unidades)
                                {
                                    this.Cursor = Cursors.Default;
                                    SplashScreen.Close();
                                    Util.MensajeError(string.Format("{0} {1} {2}", "El articulo", row.Cells["Numero Parte"].Value, "no cuenta con la existencia suficiente para realizar la operación"), GlobalClass.NombreApp);
                                    return;
                                }
                            }

                            //Valida que la cantidad a devolver sea igual o menor a la del movimiento
                            //if (movimientoInventario.MovimientoInventarioID > 0)
                            //{
                            //    var detalle = General.GetEntity<MovimientoInventarioDetalle>(m => m.MovimientoInventarioID.Equals(movimientoInventario.MovimientoInventarioID)
                            //        && m.ParteID.Equals(parteId) && m.Estatus);
                            //    if (unidades > detalle.Cantidad)
                            //    {
                            //        this.Cursor = Cursors.Default;
                            //        SplashScreen.Close();
                            //        Util.MensajeError(string.Format("{0} {1} {2}", "El articulo", row.Cells["Numero Parte"].Value, "tiene registrada una cantidad menor a la que intenta devolver."), GlobalClass.NombreApp);
                            //        return;
                            //    }
                            //}

                            //Validar que LA CANTIDAD del movimiento de compra, sea menor o igual que la suma de las devoluciones

                            /*
                            var mov = General.GetEntity<MovimientoInventarioView>(m => m.MovimientoInventarioID == movimientoInventario.MovimientoInventarioID && m.FolioFactura == m.FolioFactura);
                            if (mov != null)
                            {
                                var det = General.GetEntity<MovimientoInventarioDetalleView>(m => m.MovimientoInventarioID == mov.MovimientoInventarioID && m.ParteID == parteId);
                                if (det != null)
                                {
                                    var dev = General.GetEntity<MovimientosInventarioContadorDevolucionesView>(m => m.MovimientoInventarioID == movimientoInventario.MovimientoInventarioID
                                        && m.ParteID == parteId);
                                    if (dev != null)
                                    {
                                        if (det.Cantidad > dev.Cantidad)
                                        {
                                            this.Cursor = Cursors.Default;
                                            SplashScreen.Close();
                                            Util.MensajeError(string.Format("{0} {1} {2}", "El articulo", row.Cells["Numero Parte"].Value, "tiene registrada una cantidad menor en la Factura a la que intenta devolver."), GlobalClass.NombreApp);
                                            return;
                                        }
                                    }
                                }
                                else
                                {
                                    this.Cursor = Cursors.Default;
                                    SplashScreen.Close();
                                    Util.MensajeError("Error al tratar de validar la cantidad comprada.", GlobalClass.NombreApp);
                                    return;
                                }
                            }
                            else
                            {
                                this.Cursor = Cursors.Default;
                                SplashScreen.Close();
                                Util.MensajeError("Error al tratar de validar el movmiento de Compra.", GlobalClass.NombreApp);
                                return;
                            }
                            */

                            decimal mCantidad = Util.Decimal(row.Cells["UNS"].Value);
                            if (oFuenteMovDet != null && (oFuenteMovDet.Cantidad - oFuenteMovDet.CantidadDevuelta) < mCantidad)
                            {
                                this.Cursor = Cursors.Default;
                                SplashScreen.Close();
                                UtilLocal.MensajeAdvertencia(string.Format("El artículo {0} tiene registrada una cantidad menor en la factura a la que intenta devolver."
                                    , row.Cells["Numero Parte"].Value));
                                return;
                            }

                        }

                        // Se obtiene el folio factura del primer artículo a devolver
                        if (this.dgvDetalleCaptura.Rows.Count > 0)
                        {
                            this.txtFolioFactura.Text = oFuenteMov.FolioFactura;
                        }

                        //Insertar Movimiento
                        var movimientoDevolucion = new MovimientoInventario()
                        {
                            TipoOperacionID = Util.Entero(this.cboTipoOperacion.SelectedValue),
                            TipoPagoID = Util.Entero(this.cboTipoPago.SelectedValue),
                            ProveedorID = proveedorId,
                            SucursalOrigenID = Util.Entero(this.cboUbicacionOrigen.SelectedValue),
                            SucursalDestinoID = Util.Entero(this.cboUbicacionDestino.SelectedValue),
                            FechaFactura = this.dtpFechaFacturacion.Value,
                            FechaRecepcion = this.dtpFechaRecepcion.Value,
                            FolioFactura = this.txtFolioFactura.Text,
                            Subtotal = null,
                            IVA = null,
                            ImporteTotal = Util.Decimal(this.lblTotal.Text),
                            FueLiquidado = false,
                            TipoConceptoOperacionID = Util.Entero(this.cboConceptoOperacion.SelectedValue),
                            Observacion = this.txtObservaciones.Text,
                            Articulos = Util.Decimal(this.txtArticulos.Text),
                            Unidades = Util.Decimal(this.lblUnidades.Text),
                            Seguro = null,
                            ImporteTotalSinDescuento = null,
                            DeMovimientoInventarioID = oFuenteMov.MovimientoInventarioID
                        };
                        Datos.Guardar<MovimientoInventario>(movimientoDevolucion);

                        if (movimientoDevolucion.MovimientoInventarioID < 1)
                        {
                            this.Cursor = Cursors.Default;
                            SplashScreen.Close();
                            new EntityNotFoundException("MovimientoInventarioID", "MovimientoInventario");
                            return;
                        }

                        //Insertar MovimientoDetalle
                        foreach (DataGridViewRow row in this.dgvDetalleCaptura.Rows)
                        {
                            var parteId = Util.Entero(row.Cells["ParteID"].Value);
                            var cantidad = Util.Decimal(row.Cells["UNS"].Value);
                            var detalleMovimiento = new MovimientoInventarioDetalle()
                            {
                                MovimientoInventarioID = movimientoDevolucion.MovimientoInventarioID,
                                ParteID = parteId,
                                Cantidad = cantidad,
                                PrecioUnitario = Util.Decimal(row.Cells["Costo Inicial"].Value),
                                Importe = Util.Decimal(row.Cells["Importe"].Value),
                                FueDevolucion = true,
                                FechaRegistro = DateTime.Now,
                                Estatus = true
                            };
                            Datos.SaveOrUpdate<MovimientoInventarioDetalle>(detalleMovimiento);

                            // Se actualiza la existencia y el kardex
                            bool bDevGarantia = (Util.Entero(this.cboConceptoOperacion.SelectedValue) == Cat.MovimientosConceptosDeOperacion.DevolucionGarantia);
                            // Si no es de garantía, igual se mete un registro de existencia pero en cero, sólo para que quede el dato del movimiento que se hizo
                            AdmonProc.AfectarExistenciaYKardex(parteId, sucursalId, Cat.OperacionesKardex.DevolucionAProveedor,
                                movimientoDevolucion.MovimientoInventarioID.ToString(), iAutorizoID, this.cboProveedor.Text, this.cboUbicacionDestino.Text
                                , this.cboConceptoOperacion.Text, (bDevGarantia ? 0 : (cantidad * -1))
                                , Util.Decimal(row.Cells["Costo Inicial"].Value), Cat.Tablas.MovimientoInventario, movimientoDevolucion.MovimientoInventarioID);

                            var oExistencia = Datos.GetEntity<ParteExistencia>(c => c.ParteID == parteId && c.SucursalID == sucursalId && c.Estatus);
                            var historial = new MovimientoInventarioHistorial()
                            {
                                MovmientoInventarioID = movimientoDevolucion.MovimientoInventarioID,
                                ParteID = parteId,
                                ExistenciaInicial = Util.Decimal(oExistencia.Existencia + cantidad),
                                ExistenciaFinal = Util.Decimal(oExistencia.Existencia),
                                SucursalID = Util.Entero(this.cboUbicacionDestino.SelectedValue)
                            };
                            Datos.Guardar<MovimientoInventarioHistorial>(historial);

                            //Actualizar ParteExistencia, si no es garantía y no es servicio
                            /*
                            bool bDevGarantia = (Util.ConvertirEntero(this.cboConceptoOperacion.SelectedValue) == Cat.MovimientosConceptosDeOperacion.DevolucionGarantia);
                            var oParte = General.GetEntity<Parte>(c => c.ParteID == parteId && c.Estatus);
                            if (!oParte.EsServicio.Valor() && !bDevGarantia) {
                                var existencia = General.GetEntity<ParteExistencia>(p => p.ParteID == parteId && p.SucursalID == sucursalId);
                                if (existencia != null)
                                {
                                    var inicial = existencia.Existencia;
                                    existencia.Existencia -= cantidad;
                                    // Datos.Guardar<ParteExistencia>(existencia);
                                    AdmonProc.AgregarExistencia(parteId, sucursalId, (cantidad * -1), Cat.Tablas.MovimientoInventario
                                        , movimientoDevolucion.MovimientoInventarioID);

                                    var historial = new MovimientoInventarioHistorial()
                                    {
                                        MovmientoInventarioID = movimientoDevolucion.MovimientoInventarioID,
                                        ParteID = parteId,
                                        ExistenciaInicial = Util.ConvertirDecimal(inicial),
                                        ExistenciaFinal = Util.ConvertirDecimal(existencia.Existencia),
                                        SucursalID = Util.ConvertirEntero(this.cboUbicacionDestino.SelectedValue)
                                    };
                                    Datos.Guardar<MovimientoInventarioHistorial>(historial);
                                }
                            }
                            // Se agrega al Kardex
                            AdmonProc.RegistrarKardex(new ParteKardex()
                            {
                                ParteID = parteId,
                                OperacionID = Cat.OperacionesKardex.DevolucionAProveedor,
                                SucursalID = sucursalId,
                                Folio = movimientoDevolucion.MovimientoInventarioID.ToString(),
                                Fecha = DateTime.Now,
                                RealizoUsuarioID = iAutorizoID,
                                Entidad = this.cboProveedor.Text,
                                Origen = this.cboUbicacionDestino.Text,
                                Destino = (bDevGarantia ? "GARANTÍA" : proveedorId.ToString()),
                                Cantidad = (bDevGarantia ? 0 : cantidad),
                                Importe = Util.ConvertirDecimal(row.Cells["Costo Inicial"].Value),
                                RelacionTabla = Cat.Tablas.MovimientoInventario,
                                RelacionID = movimientoDevolucion.MovimientoInventarioID
                            });
                            */

                            // Se modifica la cantidad devuelta, en el detalle de la compra utilizada
                            if (oFuenteMovDet != null)
                            {
                                oFuenteMovDet.CantidadDevuelta += cantidad;
                                Datos.Guardar<MovimientoInventarioDetalle>(oFuenteMovDet);
                            }

                            // Se verifica si es una garantía, para cambiar el estatus correspondiente, y relacionar la garantía con el Mov
                            if (Util.Entero(this.cboConceptoOperacion.SelectedValue) == Cat.MovimientosConceptosDeOperacion.DevolucionGarantia)
                            {
                                int iGarantiaID = Util.Entero(row.Tag);
                                var oGarantia = Datos.GetEntity<VentaGarantia>(c => c.VentaGarantiaID == iGarantiaID && c.Estatus);
                                if (oGarantia != null)
                                {
                                    oGarantia.EstatusGenericoID = Cat.EstatusGenericos.EnRevision;
                                    oGarantia.MovimientoInventarioID = oFuenteMov.MovimientoInventarioID;
                                    Datos.Guardar<VentaGarantia>(oGarantia);
                                }
                            }
                        }

                        SplashScreen.Close();
                        this.btnFinish.Enabled = true;
                        this.Cursor = Cursors.Default;

                        //Visor de ticket de devolucion
                        ReporteadorMovimientos visorD = ReporteadorMovimientos.Instance;
                        visorD.oID = movimientoDevolucion.MovimientoInventarioID;
                        visorD.oTipoReporte = 6;
                        visorD.Load();
                        #endregion

                        break;

                    default:
                        break;
                }

                new Notificacion(string.Format("{0} {1}", this.cboTipoOperacion.Text, "Guardado exitosamente"), 2 * 1000).Mostrar(Principal.Instance);
                this.finalizar();
            }
            catch (Exception ex)
            {
                SplashScreen.Close();
                this.btnFinish.Enabled = true;
                this.Cursor = Cursors.Default;
                UtilLocal.MensajeError(ex.MensajeDeError());
            }
        }
        protected override void btnGuardar_Click(object sender, EventArgs e)
        {
            try
            {
                if (!Validaciones())
                    return;

                if (EsNuevo)
                {

                }
                else
                {
                    int iAutorizoID = 0;
                    var ResU = UtilLocal.ValidarObtenerUsuario(null, "Autorización");
                    if (ResU.Exito)
                        iAutorizoID = ResU.Respuesta.UsuarioID;
                    else
                    {
                        Util.MensajeError("Error al validar el usuario.", GlobalClass.NombreApp);
                        return;
                    }

                    SplashScreen.Show(new Splash());
                    this.btnGuardar.Enabled = false;

                    var ContingenciaCompleta = Datos.GetEntity<MovimientoInventarioContingenciasView>(c => c.MovimientoInventarioTraspasoContingenciaID == Contingencia.MovimientoInventarioTraspasoContingenciaID);
                    if (null == ContingenciaCompleta)
                        return;

                    //Actualiza la contingencia
                    Contingencia.FechaModificacion = DateTime.Now;
                    Contingencia.MovimientoInventarioEstatusContingenciaID = 1;
                    Contingencia.UsuarioID = GlobalClass.UsuarioGlobal.UsuarioID;
                    Contingencia.UsuarioSolucionoID = GlobalClass.UsuarioGlobal.UsuarioID;
                    Contingencia.FechaSoluciono = DateTime.Now;
                    Contingencia.TipoOperacionID = Util.Entero(this.cboTipoOperacion.SelectedValue);
                    Contingencia.TipoConceptoOperacionID = Util.Entero(this.cboConceptoOperacion.SelectedValue);
                    Contingencia.ObservacionSolucion = this.txtObservacion.Text;
                    if (Util.Entero(this.cboTipoOperacion.SelectedValue) == Cat.TiposDeOperacionMovimientos.SalidaInventario)
                        Contingencia.ObservacionSolucion += (" - SE CREA UNA ENTRADA PARA DEVOLVER EL TRASPASO A LA TIENDA ORIGEN Y EN EL SEGUNDO MOVIMIENTO UNA SALIDA PARA PODER HACER LA SALIDA DEL INVENTARIO");
                    Contingencia.FechaModificacion = DateTime.Now;
                    Datos.SaveOrUpdate<MovimientoInventarioTraspasoContingencia>(Contingencia);

                    int iSucursalID = ContingenciaCompleta.SucursalOrigenID.Valor();
                    string sOrigen = UtilDatos.NombreDeSucursal(ContingenciaCompleta.SucursalOrigenID.Valor());
                    string sDestino = UtilDatos.NombreDeSucursal(ContingenciaCompleta.SucursalDestinoID.Valor());
                    var oPrecio = Datos.GetEntity<PartePrecio>(c => c.ParteID == ContingenciaCompleta.ParteID && c.Estatus);

                    switch (Util.Entero(cboTipoOperacion.SelectedValue))
                    {
                        case 2:

                            #region [ Entrada Inventario ]

                            //Insertar Movimiento
                            var movimientoEntradaI = new MovimientoInventario()
                            {
                                TipoOperacionID = Util.Entero(this.cboTipoOperacion.SelectedValue),
                                TipoPagoID = 1,
                                ProveedorID = 1,
                                SucursalOrigenID = ContingenciaCompleta.SucursalOrigenID,
                                SucursalDestinoID = ContingenciaCompleta.SucursalDestinoID,
                                FechaFactura = DateTime.Now,
                                FechaRecepcion = DateTime.Now,
                                FolioFactura = null,
                                Subtotal = null,
                                IVA = null,
                                ImporteTotal = 0,
                                FueLiquidado = false,
                                TipoConceptoOperacionID = ContingenciaCompleta.TipoConceptoOperacionID,
                                Observacion = string.Format("{0}: {1}", "Traspaso por resolucion de un Conflicto. Movimiento: ", Contingencia.MovimientoInventarioID),
                                Articulos = null,
                                Unidades = null,
                                Seguro = null,
                                ImporteTotalSinDescuento = null
                            };
                            Datos.Guardar<MovimientoInventario>(movimientoEntradaI);

                            if (movimientoEntradaI.MovimientoInventarioID < 1)
                            {
                                new EntityNotFoundException("MovimientoInventarioID", "MovimientoInventario");
                                return;
                            }

                            //Insertar MovimientoDetalle
                            var detalleMovimiento = new MovimientoInventarioDetalle()
                            {
                                MovimientoInventarioID = movimientoEntradaI.MovimientoInventarioID,
                                ParteID = ContingenciaCompleta.ParteID,
                                Cantidad = Util.Decimal(ContingenciaCompleta.Diferencia),
                                PrecioUnitario = 0,
                                Importe = 0,
                                FueDevolucion = false,
                                FechaRegistro = DateTime.Now,
                                Estatus = true
                            };
                            Datos.SaveOrUpdate<MovimientoInventarioDetalle>(detalleMovimiento);

                            //Actualizar ParteExistencia
                            /* var sucursalId = ContingenciaCompleta.SucursalOrigenID;
                            var existencia = General.GetEntity<ParteExistencia>(p => p.ParteID == ContingenciaCompleta.ParteID && p.SucursalID == sucursalId);
                            if (existencia != null)
                            {
                                existencia.Existencia += Util.ConvertirDecimal(ContingenciaCompleta.Diferencia);
                                Datos.Guardar<ParteExistencia>(existencia);//dmod
                            }
                            */
                            // AdmonProc.AgregarExistencia(ContingenciaCompleta.ParteID, sucursalId.Valor(), ContingenciaCompleta.Diferencia.Valor()
                            //     , Cat.Tablas.MovimientoInventario, movimientoEntradaI.MovimientoInventarioID);

                            // Se modifica la existencia y el kardex
                            AdmonProc.AfectarExistenciaYKardex(ContingenciaCompleta.ParteID, iSucursalID, Cat.OperacionesKardex.EntradaTraspaso
                                , Contingencia.MovimientoInventarioID.ToString(), Contingencia.UsuarioSolucionoID.Valor(), "Conflicto Resuelto Entrada"
                                , sOrigen, sDestino, ContingenciaCompleta.Diferencia.Valor()
                                , oPrecio.Costo.Valor(), Cat.Tablas.MovimientoInventario, movimientoEntradaI.MovimientoInventarioID);

                            #endregion

                            break;

                        case 3:

                            #region [ Salida Inventario ]

                            //Insertar Movimiento
                            var movimientoSalida = new MovimientoInventario()
                            {
                                TipoOperacionID = Util.Entero(this.cboTipoOperacion.SelectedValue),
                                TipoPagoID = 1,
                                ProveedorID = 1,
                                SucursalOrigenID = ContingenciaCompleta.SucursalOrigenID,
                                SucursalDestinoID = ContingenciaCompleta.SucursalDestinoID,
                                FechaFactura = DateTime.Now,
                                FechaRecepcion = DateTime.Now,
                                FolioFactura = null,
                                Subtotal = null,
                                IVA = null,
                                ImporteTotal = 0,
                                FueLiquidado = false,
                                TipoConceptoOperacionID = Util.Entero(this.cboConceptoOperacion.SelectedValue),
                                Observacion = string.Format("{0}: {1}", "Traspaso por resolucion de un Conflicto. Movimiento: ", Contingencia.MovimientoInventarioID),
                                Articulos = null,
                                Unidades = null,
                                Seguro = null,
                                ImporteTotalSinDescuento = null
                            };
                            Datos.Guardar<MovimientoInventario>(movimientoSalida);

                            if (movimientoSalida.MovimientoInventarioID < 1)
                            {
                                new EntityNotFoundException("MovimientoInventarioID", "MovimientoInventario");
                                return;
                            }

                            //Insertar MovimientoDetalle
                            var detalleMovimientoS = new MovimientoInventarioDetalle()
                                {
                                    MovimientoInventarioID = movimientoSalida.MovimientoInventarioID,
                                    ParteID = ContingenciaCompleta.ParteID,
                                    Cantidad = Util.Decimal(ContingenciaCompleta.Diferencia),
                                    PrecioUnitario = 0,
                                    Importe = 0,
                                    FueDevolucion = false,
                                    FechaRegistro = DateTime.Now,
                                    Estatus = true
                                };
                            Datos.SaveOrUpdate<MovimientoInventarioDetalle>(detalleMovimientoS);

                            //No se descuenta por que ya se habia descontado en el traspaso anterior
                            // Ahora sí se generan dos registros en kardex, uno de entrada y luego uno de salida, para que al final quede igual
                            // Se hace así para mantener un registro de la operación
                            // Se hace primero la entrada
                            AdmonProc.AfectarExistenciaYKardex(ContingenciaCompleta.ParteID, iSucursalID, Cat.OperacionesKardex.EntradaTraspaso
                                , Contingencia.MovimientoInventarioID.ToString(), Contingencia.UsuarioSolucionoID.Valor(), "Conflicto Resuelto Salida"
                                , sOrigen, sDestino, ContingenciaCompleta.Diferencia.Valor()
                                , oPrecio.Costo.Valor(), Cat.Tablas.MovimientoInventario, movimientoSalida.MovimientoInventarioID);
                            // Luego la salida
                            AdmonProc.AfectarExistenciaYKardex(ContingenciaCompleta.ParteID, iSucursalID, Cat.OperacionesKardex.SalidaTraspaso
                                , Contingencia.MovimientoInventarioID.ToString(), Contingencia.UsuarioSolucionoID.Valor(), "Conflicto Resuelto Salida"
                                , sOrigen, sDestino, (ContingenciaCompleta.Diferencia.Valor() * -1)
                                , oPrecio.Costo.Valor(), Cat.Tablas.MovimientoInventario, movimientoSalida.MovimientoInventarioID);

                            #endregion

                            break;

                        case 5:

                            #region [ Traspaso ]

                            //Almacenar traspaso
                            var traspaso = new MovimientoInventario()
                            {
                                TipoOperacionID = Util.Entero(this.cboTipoOperacion.SelectedValue),
                                SucursalOrigenID = ContingenciaCompleta.SucursalOrigenID,
                                SucursalDestinoID = ContingenciaCompleta.SucursalDestinoID,
                                ImporteTotal = 0,
                                FueLiquidado = false,
                                UsuarioSolicitoTraspasoID = Contingencia.UsuarioSolucionoID,
                                ExisteContingencia = false,
                                Observacion = string.Format("{0}: {1}", "Traspaso por resolucion de un Conflicto. Movimiento: ", Contingencia.MovimientoInventarioID)
                            };
                            Datos.Guardar<MovimientoInventario>(traspaso);

                            //Almacenar el detalle del traspaso
                            if (traspaso.MovimientoInventarioID > 0)
                            {

                                var detalleTraspaso = new MovimientoInventarioDetalle()
                                {
                                    MovimientoInventarioID = traspaso.MovimientoInventarioID,
                                    ParteID = ContingenciaCompleta.ParteID,
                                    Cantidad = Util.Decimal(ContingenciaCompleta.Diferencia),
                                    PrecioUnitario = 0,
                                    Importe = 0,
                                    FueDevolucion = false,
                                    FechaRegistro = DateTime.Now,
                                    Estatus = true
                                };
                                Datos.SaveOrUpdate<MovimientoInventarioDetalle>(detalleTraspaso);

                                //No se descuenta por que ya se habia descontado en el primer traspaso
                            }

                            #endregion

                            break;

                        default:
                            break;
                    }

                }
                SplashScreen.Close();
                this.btnGuardar.Enabled = true;
                new Notificacion("Conflicto Resuelto exitosamente", 2 * 1000).Mostrar(Principal.Instance);
                catalogosTraspasos.Instance.CustomInvoke<catalogosTraspasos>(m => m.ActualizarListadoConflictos());
            }
            catch (Exception ex)
            {

                SplashScreen.Close();
                this.btnGuardar.Enabled = true;
                Util.MensajeError(ex.Message, GlobalClass.NombreApp);
            }
            this.Close();
        }
Example #6
0
        private void btnProcesar_Click(object sender, EventArgs e)
        {
            try
            {
                int iAutorizoID = 0;
                var ResU = UtilLocal.ValidarObtenerUsuario(null, "Autorización");
                if (ResU.Exito)
                    iAutorizoID = ResU.Respuesta.UsuarioID;
                else
                {
                    Util.MensajeError("Error al validar el usuario.", GlobalClass.NombreApp);
                    return;
                }

                var res = Util.MensajePregunta("¿Está seguro de que la información es correcta?", GlobalClass.NombreApp);
                if (res == DialogResult.No)
                    return;

                if (this.dgvTraspasos.Rows.Count <= 0)
                {
                    Util.MensajeError("Debe seleccionar al menos un articulo.", GlobalClass.NombreApp);
                    return;
                }

                this.Cursor = Cursors.WaitCursor;
                SplashScreen.Show(new Splash());
                this.btnProcesar.Enabled = false;

                var sucursalId = Util.Entero(this.cboUbicacionOrigen.SelectedValue);
                decimal unidades = 0;
                //Validar que la cantidad de cualquier fila sea mayor a 0
                foreach (DataGridViewRow row in this.dgvTraspasos.Rows)
                {
                    var cantidad = Util.Decimal(row.Cells["Cantidad"].Value);
                    if (cantidad <= 0)
                    {
                        Util.MensajeError(string.Format("{0} {1} {2}", "No puede traspasar el Número de Parte:", Util.Cadena(row.Cells["Numero Parte"].Value), "con cantidad en 0."), GlobalClass.NombreApp);
                        this.Cursor = Cursors.Default;
                        return;
                    }
                }

                //Validar existencias de cada articulo en la sucursal origen
                foreach (DataGridViewRow row in this.dgvTraspasos.Rows)
                {
                    if (Util.Logico(row.Cells["X"].Value).Equals(true))
                    {
                        var parteId = Util.Entero(row.Cells["ParteID"].Value);
                        var cantidad = Util.Decimal(row.Cells["Cantidad"].Value);
                        unidades += cantidad;
                        var parteExistencia = Datos.GetEntity<ParteExistencia>(p => p.ParteID.Equals(parteId) && p.SucursalID.Equals(sucursalId) && p.Estatus);
                        if (null != parteExistencia)
                        {
                            if (parteExistencia.Existencia <= 0 || cantidad > parteExistencia.Existencia)
                            {
                                Util.MensajeError(string.Format("{0}{1}", row.Cells["Numero Parte"].Value, " No cuenta con la existencia suficiente en este momento."), GlobalClass.NombreApp);
                                this.Cursor = Cursors.Default;
                                SplashScreen.Close();
                                this.btnProcesar.Enabled = true;
                                this.dgvTraspasos.Select();
                                row.Cells["Cantidad"].Selected = true;
                                return;
                            }
                        }
                    }
                }

                //Almacenar traspaso
                var traspaso = new MovimientoInventario()
                {
                    TipoOperacionID = 5,
                    SucursalOrigenID = sucursalId,
                    SucursalDestinoID = Util.Entero(this.cboUbicacionDestino.SelectedValue),
                    Unidades = unidades,
                    ImporteTotal = 0,
                    FueLiquidado = false,
                    UsuarioSolicitoTraspasoID = Util.Entero(this.cboSolicito.SelectedValue),
                    ExisteContingencia = false,
                    UsuarioID = iAutorizoID,
                    FechaRegistro = DateTime.Now,
                    Estatus = true,
                    Actualizar = true
                };
                Datos.SaveOrUpdate<MovimientoInventario>(traspaso);

                //Almacenar el detalle del traspaso
                if (traspaso.MovimientoInventarioID > 0)
                {
                    decimal mCostoTotal = 0;
                    foreach (DataGridViewRow row in this.dgvTraspasos.Rows)
                    {
                        if (Util.Logico(row.Cells["X"].Value).Equals(true))
                        {
                            var parteId = Util.Entero(row.Cells["ParteID"].Value);
                            var cantidad = Util.Decimal(row.Cells["Cantidad"].Value);
                            var detalleTraspaso = new MovimientoInventarioDetalle()
                            {
                                MovimientoInventarioID = traspaso.MovimientoInventarioID,
                                ParteID = parteId,
                                Cantidad = cantidad,
                                PrecioUnitario = 0,
                                Importe = 0,
                                FueDevolucion = false,
                                FechaRegistro = DateTime.Now,
                                Estatus = true
                            };
                            Datos.SaveOrUpdate<MovimientoInventarioDetalle>(detalleTraspaso);

                            // Se actualiza la existencia y el kardex
                            var oPartePrecio = Datos.GetEntity<PartePrecio>(c => c.ParteID == parteId && c.Estatus);
                            AdmonProc.AfectarExistenciaYKardex(parteId, sucursalId, Cat.OperacionesKardex.SalidaTraspaso, traspaso.MovimientoInventarioID.ToString()
                                , iAutorizoID, this.cboProveedor.Text, this.cboUbicacionOrigen.Text, this.cboUbicacionDestino.Text, (cantidad * -1)
                                , oPartePrecio.Costo.Valor(), Cat.Tablas.MovimientoInventario, traspaso.MovimientoInventarioID);

                            var oExistencia = Datos.GetEntity<ParteExistencia>(c => c.ParteID == parteId && c.SucursalID == sucursalId && c.Estatus);
                            var historial = new MovimientoInventarioHistorial()
                            {
                                MovmientoInventarioID = traspaso.MovimientoInventarioID,
                                ParteID = parteId,
                                ExistenciaInicial = Util.Decimal(oExistencia.Existencia + cantidad),
                                ExistenciaFinal = Util.Decimal(oExistencia.Existencia),
                                SucursalID = sucursalId
                            };
                            Datos.Guardar<MovimientoInventarioHistorial>(historial);

                            //Descontar la existencia actual de la sucursal origen
                            /*
                            var oParte = General.GetEntity<Parte>(c => c.ParteID == parteId && c.Estatus);
                            if (!oParte.EsServicio.Valor())
                            {
                                var existencia = General.GetEntity<ParteExistencia>(p => p.ParteID == parteId && p.SucursalID == sucursalId);
                                if (existencia != null)
                                {
                                    var inicial = existencia.Existencia;
                                    existencia.Existencia -= cantidad;
                                    existencia.UsuarioID = iAutorizoID;
                                    // existencia.FechaModificacion = DateTime.Now;
                                    // General.SaveOrUpdate<ParteExistencia>(existencia, existencia);
                                    AdmonProc.AgregarExistencia(parteId, sucursalId, (cantidad * -1), Cat.Tablas.MovimientoInventario, traspaso.MovimientoInventarioID);

                                    var historial = new MovimientoInventarioHistorial()
                                    {
                                        MovmientoInventarioID = traspaso.MovimientoInventarioID,
                                        ParteID = parteId,
                                        ExistenciaInicial = Util.ConvertirDecimal(inicial),
                                        ExistenciaFinal = Util.ConvertirDecimal(existencia.Existencia),
                                        SucursalID = sucursalId,
                                        UsuarioID = iAutorizoID,
                                        FechaRegistro = DateTime.Now,
                                        Estatus = true,
                                        Actualizar = true
                                    };
                                    General.SaveOrUpdate<MovimientoInventarioHistorial>(historial, historial);
                                }
                            }

                            // Se agrega al Kardex
                            var oPartePrecio = General.GetEntity<PartePrecio>(c => c.ParteID == parteId && c.Estatus);
                            AdmonProc.RegistrarKardex(new ParteKardex()
                            {
                                ParteID = parteId,
                                OperacionID = Cat.OperacionesKardex.SalidaTraspaso,
                                SucursalID = sucursalId,
                                Folio = traspaso.MovimientoInventarioID.ToString(),
                                Fecha = DateTime.Now,
                                RealizoUsuarioID = iAutorizoID,
                                Entidad = this.cboProveedor.Text,
                                Origen = this.cboUbicacionOrigen.Text,
                                Destino = this.cboUbicacionDestino.Text,
                                Cantidad = cantidad,
                                Importe = oPartePrecio.Costo.Valor(),
                                RelacionTabla = Cat.Tablas.MovimientoInventario,
                                RelacionID = traspaso.MovimientoInventarioID
                            });
                            */

                            // Se suma el importe de cada parte, para crear la póliza
                            mCostoTotal += (oPartePrecio.Costo.Valor() * cantidad);
                        }
                    }

                    // Se genera la póliza especial correspondiente (AfeConta)
                    var oPoliza = ContaProc.CrearPoliza(Cat.ContaTiposDePoliza.Diario, string.Format("TRASPASO ORIGEN {0:00} DESTINO {1:00}",
                        this.cboUbicacionOrigen.SelectedValue, this.cboUbicacionDestino.SelectedValue), Cat.ContaCuentasAuxiliares.Inventario
                        , Cat.ContaCuentasAuxiliares.Inventario, mCostoTotal, traspaso.MovimientoInventarioID.ToString()
                        , Cat.Tablas.MovimientoInventario, traspaso.MovimientoInventarioID, Util.Entero(this.cboUbicacionOrigen.SelectedValue));
                    var oCuentaQuitar = Datos.GetEntity<ContaPolizaDetalle>(c => c.ContaPolizaID == oPoliza.ContaPolizaID && c.Cargo > 0);
                    if (oCuentaQuitar != null)
                    {
                        oCuentaQuitar.Cargo = 0;
                        Datos.Guardar<ContaPolizaDetalle>(oCuentaQuitar);
                    }
                }

                //Visor de ticket de traspaso
                ReporteadorMovimientos visor = ReporteadorMovimientos.Instance;
                visor.oID = traspaso.MovimientoInventarioID;
                visor.oTipoReporte = 7;
                visor.Load();

                this.LimpiarFormulario();
                this.Cursor = Cursors.Default;
                SplashScreen.Close();
                this.btnProcesar.Enabled = true;
                new Notificacion("Traspaso Guardado exitosamente", 2 * 1000).Mostrar(Principal.Instance);
            }
            catch (Exception ex)
            {
                this.Cursor = Cursors.Default;
                SplashScreen.Close();
                this.btnProcesar.Enabled = true;
                Util.MensajeError(ex.Message, GlobalClass.NombreApp);
            }
        }