Beispiel #1
0
        public IActionResult EgresoMateriaPrima(MovimientoInventario movimientoInventario)
        {
            ViewData["ProveedorFk"]  = new SelectList(_context.Proveedor, "NumeroProveedor", "NombreProveedor");
            ViewData["InventarioFk"] = new SelectList(_context.Agregado, "CodMateriaPrima", "NombreMateriaPrima");

            var listInventario = _context.Inventario.Where(i => i.AgregadoFk == movimientoInventario.InventarioFk).FirstOrDefault();

            Random ran = new Random();

            if (movimientoInventario.Cantidad < listInventario.Total)
            {
                if (ModelState.IsValid)
                {
                    listInventario.Total = listInventario.Total - movimientoInventario.Cantidad;
                    movimientoInventario.InventarioFk = listInventario.CodInventario;

                    if (User.Identity.IsAuthenticated)
                    {
                        movimientoInventario.Digitador       = User.FindFirst(ClaimTypes.NameIdentifier).Value;
                        movimientoInventario.FechaDigitador  = DateTime.Now;
                        movimientoInventario.FechaMovimiento = DateTime.Now;
                        movimientoInventario.TipoMovimiento  = "E";
                    }
                    //  movimientoInventario.Factura = ran.Next(20, 100).ToString();
                    // movimientoInventario.PrecioUnitario = ran.Next(20, 100);
                    _context.Add(movimientoInventario);
                    _context.SaveChanges();
                    return(RedirectToAction(nameof(Index)));
                }
            }
            //  var listInventarios = _context.Inventario;
            return(View());
        }
Beispiel #2
0
        public async Task <IActionResult> PutMovimientoInventario(int id, MovimientoInventario movimientoInventario)
        {
            if (id != movimientoInventario.Id)
            {
                return(BadRequest());
            }

            _context.Entry(movimientoInventario).State = EntityState.Modified;

            try
            {
                await _context.SaveChangesAsync();
            }
            catch (DbUpdateConcurrencyException)
            {
                if (!MovimientoInventarioExists(id))
                {
                    return(NotFound());
                }
                else
                {
                    throw;
                }
            }

            return(NoContent());
        }
Beispiel #3
0
        public async Task <IActionResult> Edit(int id, [Bind("CodMovimientoInventario,TipoMovimiento,FechaMovimiento,Factura,PrecioUnitario,Cantidad,Observacion,InventarioFk,ProveedorFk,OrdenAprovisionamientoFk,Digitador,FechaDigitador")] MovimientoInventario movimientoInventario)
        {
            if (id != movimientoInventario.CodMovimientoInventario)
            {
                return(NotFound());
            }

            if (ModelState.IsValid)
            {
                try
                {
                    _context.Update(movimientoInventario);
                    await _context.SaveChangesAsync();
                }
                catch (DbUpdateConcurrencyException)
                {
                    if (!MovimientoInventarioExists(movimientoInventario.CodMovimientoInventario))
                    {
                        return(NotFound());
                    }
                    else
                    {
                        throw;
                    }
                }
                return(RedirectToAction(nameof(Index)));
            }
            ViewData["InventarioFk"]             = new SelectList(_context.Inventario, "CodInventario", "CodInventario", movimientoInventario.InventarioFk);
            ViewData["OrdenAprovisionamientoFk"] = new SelectList(_context.OrdenAprovisionamiento, "NumeroOrdenAprovisionamiento", "NumeroOrdenAprovisionamiento", movimientoInventario.OrdenAprovisionamientoFk);
            ViewData["ProveedorFk"] = new SelectList(_context.Proveedor, "NumeroProveedor", "NumeroProveedor", movimientoInventario.ProveedorFk);
            return(View(movimientoInventario));
        }
Beispiel #4
0
        public async Task BuscarInventario(int productoId, int depositoId)
        {
            if (productoId != 0 && depositoId != 0)
            {
                inventario = await http.GetJsonAsync <Inventario>($"api/inventario/DetalleInventario?productoId={productoId}&depositoId={depositoId}");

                paginaActual = 1;
                if (inventario.Id != 0)
                {
                    await ListarMovimientosInventario(paginaActual);
                }
                movimientoInventario = new MovimientoInventario
                {
                    Inventario = new Inventario
                    {
                        ProductoPresentacion   = productoPresentacion,
                        Deposito               = deposito,
                        ProductoPresentacionId = productoPresentacion.Id,
                        DepositoId             = deposito.Id,
                        Id = inventario.Id
                    }
                    ,
                    InventarioId = inventario.Id
                };
            }
        }
Beispiel #5
0
        public async Task <ActionResult <OrdenProduccion> > PostOrdenProduccion(OrdenProduccion ordenProduccion)
        {
            try
            {
                ordenProduccion.Deposito = null;
                ordenProduccion.detallesOrdenProduccion.ForEach(x => x.ProductoPresentacion = null);

                _context.ordenProduccion.Add(ordenProduccion);
                ordenProduccion.EstadoOrdenProduccionId = 1;
                await _context.SaveChangesAsync();



                ordenProduccion = await _context.ordenProduccion
                                  .Include(x => x.detallesOrdenProduccion)
                                  .FirstOrDefaultAsync(x => x.Id == ordenProduccion.Id);


                foreach (DetalleOrdenProduccion detalle in ordenProduccion.detallesOrdenProduccion)
                {
                    Inventario inventarioDb = _context.inventario.FirstOrDefault(x => x.DepositoId == ordenProduccion.DepositoId && x.ProductoPresentacionId == detalle.ProductoPresentacionId);
                    if (inventarioDb == null)
                    {
                        inventarioDb = new Inventario {
                            DepositoId = ordenProduccion.DepositoId, ProductoPresentacionId = detalle.ProductoPresentacionId
                        };
                        _context.inventario.Add(inventarioDb);
                        await _context.SaveChangesAsync();
                    }
                    //

                    inventarioDb.cantidadUnidadesEnExistencia += detalle.cantidad;

                    _context.Entry(inventarioDb).State = EntityState.Modified;

                    MovimientoInventario movimiento = new MovimientoInventario
                    {
                        cantidadUnidadesMovida = detalle.cantidad,
                        entra             = true,
                        sale              = false,
                        InventarioId      = inventarioDb.Id,
                        OrdenProduccionId = ordenProduccion.Id
                    };
                    _context.Entry(movimiento).State = EntityState.Added;
                }
                _context.Entry(ordenProduccion).State = EntityState.Unchanged;
                await _context.SaveChangesAsync();

                return(CreatedAtAction("GetOrdenProduccion", new { id = ordenProduccion.Id }, ordenProduccion));
            }
            catch (Exception ex)
            {
                throw;
            }
        }
Beispiel #6
0
        public async Task <IActionResult> Create(MovimientoInventario movimientoInventario)
        {
            if (ModelState.IsValid)
            {
                _context.Add(movimientoInventario);
                await _context.SaveChangesAsync();

                return(RedirectToAction(nameof(Index)));
            }
            ViewData["InventarioFk"]             = new SelectList(_context.Inventario, "CodInventario", "CodInventario", movimientoInventario.InventarioFk);
            ViewData["OrdenAprovisionamientoFk"] = new SelectList(_context.OrdenAprovisionamiento, "NumeroOrdenAprovisionamiento", "NumeroOrdenAprovisionamiento", movimientoInventario.OrdenAprovisionamientoFk);
            ViewData["ProveedorFk"] = new SelectList(_context.Proveedor, "NumeroProveedor", "NumeroProveedor", movimientoInventario.ProveedorFk);
            return(View(movimientoInventario));
        }
Beispiel #7
0
        public static MovimientoInventario CrearDevolucionProveedor(int iProveedorID, int iOrigenID, decimal mImporte, string sObservacion)
        {
            var oMov = new MovimientoInventario()
            {
                TipoOperacionID = Cat.TiposDeOperacionMovimientos.DevolucionAProveedor,
                ProveedorID     = iProveedorID,
                // DevolucionOrigenID = iOrigenID,
                ImporteTotal = mImporte,
                Observacion  = sObservacion
            };

            Datos.Guardar <MovimientoInventario>(oMov);

            return(oMov);
        }
Beispiel #8
0
        public async Task BuscarInventario()
        {
            if (inventarioId != 0 && inventarioId != null)
            {
                inventario = await http.GetJsonAsync <Inventario>($"api/inventario/{inventarioId}");

                paginaActual = 1;
                await ListarMovimientosInventario(paginaActual);

                deposito             = inventario.Deposito;
                productoPresentacion = inventario.ProductoPresentacion;
                movimientoInventario = new MovimientoInventario {
                    Inventario = inventario, InventarioId = inventario.Id
                };
            }
        }
Beispiel #9
0
        // GET: /MovimientoInventarioResidente/Create
        public ActionResult Create()
        {
            string usuario = System.Web.HttpContext.Current.Session["User"].ToString();

            ViewBag.MovimientoInventarioId = new SelectList(db.MovimientoInventario, "MovimientoInventarioId", "Consecutivo");
            //    ViewBag.EstadoMovimientoId = new SelectList(db.EstadoMovimientoes, "EstadoMovimientoId", "Descripcion");
            //    ViewBag.TerceroId = new SelectList(db.Terceroes, "TerceroId", "RazonSocial");
            var _tmusu = from c in db.TipoMovimiento join cm in db.UsuarioTipoMovimiento on c.TipoMovimientoId equals cm.TipoMovimientoId where cm.Usuario.Login == usuario select c;

            //validar los movimientos de entrada y salida de medicamentos --> preconfigurarlos
            ViewBag.TipoMovimientoId = new SelectList(_tmusu, "TipoMovimientoId", "Descripcion");
            //    ViewBag.UbicacionDestinoId = new SelectList(db.UbicacionDestino, "UbicacionDestinoId", "Descripcion");
            MovimientoInventario movimiento = new MovimientoInventario();

            movimiento.Fecha = DateTime.Now;
            MovimientoInventarioResidente movimientoResidente = new MovimientoInventarioResidente();

            movimientoResidente.MovimientoInventario = movimiento;

            return(View());
        }
Beispiel #10
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());
            }
        }
Beispiel #11
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);
            }
        }
        public ActionResult <MovimientoInventario> Create([FromBody] MovimientoInventario movimiento)
        {
            _movimientoInventarioService.Create(movimiento);

            return(CreatedAtRoute("GetMovimientoInventario", new { id = movimiento.Id.ToString() }, movimiento));
        }
Beispiel #13
0
        public async Task <ActionResult <MovimientoInventario> > PostMovimientoInventario(MovimientoInventario movimientoInventario)
        {
            try
            {
                if (movimientoInventario.InventarioId == 0)
                {
                    movimientoInventario.Inventario.Deposito             = null;
                    movimientoInventario.Inventario.ProductoPresentacion = null;

                    _context.inventario.Add(movimientoInventario.Inventario);
                    await _context.SaveChangesAsync();

                    movimientoInventario.InventarioId = movimientoInventario.Inventario.Id;
                }
                Inventario inventarioDb = await _context.inventario.FirstAsync(x => x.Id == movimientoInventario.InventarioId);

                if (movimientoInventario.entra)
                {
                    inventarioDb.cantidadUnidadesEnExistencia += movimientoInventario.cantidadUnidadesMovida;
                }
                else if (movimientoInventario.sale)
                {
                    inventarioDb.cantidadUnidadesEnExistencia -= movimientoInventario.cantidadUnidadesMovida;
                }
                movimientoInventario.Inventario = null;

                _context.Entry(inventarioDb).State = EntityState.Modified;
                _context.movimientoInventario.Add(movimientoInventario);

                await _context.SaveChangesAsync();

                return(CreatedAtAction("GetMovimientoInventario", new { id = movimientoInventario.Id }, movimientoInventario));
            }
            catch (Exception ex)
            {
                throw;
            }
        }
Beispiel #14
0
        public MovimientoInventario Create(MovimientoInventario movimiento)
        {
            _movimientoInventario.InsertOne(movimiento);

            return(movimiento);
        }
Beispiel #15
0
 public void Update(string id, MovimientoInventario movimiento) =>
 _movimientoInventario.ReplaceOne(mov => mov.Id == id, movimiento);
Beispiel #16
0
        public IActionResult IngresoMateriaPrima(MovimientoInventario movimientoInventario)
        {
            if (ModelState.IsValid)
            {
                List <MovimientoInventario> listMov = new List <MovimientoInventario>();
                if (User.Identity.IsAuthenticated)
                {
                    movimientoInventario.Digitador      = User.FindFirst(ClaimTypes.NameIdentifier).Value;
                    movimientoInventario.FechaDigitador = DateTime.Now;
                }

                var detalleOrdenAprov = _context.DetalleAprovisionamiento
                                        .Include(j => j.InventarioFkNavigation)
                                        .Where(i => i.OrdenAprovisionamientoFk == movimientoInventario.OrdenAprovisionamientoFk).ToList();
                Random ran = new Random();

                var aumentar = _context.Inventario.ToList();

                foreach (var item in detalleOrdenAprov)
                {
                    listMov.Add(new MovimientoInventario()
                    {
                        Cantidad                 = item.Cantidad,
                        PrecioUnitario           = ran.Next(20, 100),
                        Digitador                = movimientoInventario.Digitador,
                        FechaDigitador           = movimientoInventario.FechaDigitador,
                        FechaMovimiento          = DateTime.Now,
                        Factura                  = ran.Next(20, 100).ToString(),
                        Observacion              = movimientoInventario.Observacion,
                        OrdenAprovisionamientoFk = movimientoInventario.OrdenAprovisionamientoFk,
                        ProveedorFk              = movimientoInventario.ProveedorFk,
                        TipoMovimiento           = "I",
                        InventarioFk             = item.InventarioFk
                    });

                    item.InventarioFkNavigation.Total = item.InventarioFkNavigation.Total + item.Cantidad;
                }

                var ordenAp = _context.OrdenAprovisionamiento.Find(movimientoInventario.OrdenAprovisionamientoFk);
                var ListDet = _context.DetalleAprovisionamiento.Where(i => i.OrdenAprovisionamientoFk == movimientoInventario.OrdenAprovisionamientoFk).ToList();


                //var ListDetalle = _context.DetalleAprovisionamiento.ToList();
                foreach (var item in ListDet)
                {
                    item.Ingresado = true;
                }
                ordenAp.FechaEntrega    = DateTime.Now;
                ordenAp.EstadoEntregado = true;

                foreach (var item in listMov)
                {
                    _context.Add(item);
                }

                // movimientoInventario.Cantidad

                // _context.Add(movimientoInventario);
                _context.SaveChanges();
                return(RedirectToAction(nameof(Index)));
            }
            ViewData["ProveedorFk"] = new SelectList(_context.Proveedor, "NumeroProveedor", "NombreProveedor");
            ViewData["OrdenAprovisionamientoFk"] = new SelectList(_context.OrdenAprovisionamiento.Where(i => i.EstadoEntregado == false), "NumeroOrdenAprovisionamiento", "FechaEstimadaEntrega");

            // return View(inventario);

            return(View());
        }
Beispiel #17
0
        private void AgruparMovimientos()
        {
            // Se valida que haya un proveedor seleccionado
            if (this.Proveedor.ProveedorID <= 0)
            {
                UtilLocal.MensajeAdvertencia("No hay ningún proveedor seleccionado. No se puede continuar.");
                return;
            }

            var oMovsSel = new List<int>();
            foreach (DataGridViewRow oFila in this.dgvMovimientosNoPagados.Rows)
            {
                if (!Util.Logico(oFila.Cells["pen_Sel"].Value))
                    continue;

                // Se valida que no se seleccione un movimiento agrupador
                if (Util.Logico(oFila.Cells["pen_EsAgrupador"].Value))
                {
                    UtilLocal.MensajeAdvertencia("No se puede agrupar un movimiento que ya es agrupador.");
                    return;
                }
                //
                if (Util.Logico(oFila.Cells["pen_Sel"].Value))
                    oMovsSel.Add(Util.Entero(oFila.Cells["pen_MovimientoInventarioID"].Value));
            }
            if (oMovsSel.Count <= 0)
            {
                UtilLocal.MensajeAdvertencia("No hay movimientos seleccionados para agrupar.");
                return;
            }

            var frmAgrupar = new MovimientosAgrupar(oMovsSel);
            if (frmAgrupar.ShowDialog(Principal.Instance) == DialogResult.OK)
            {
                Cargando.Mostrar();
                // Se obtienen los movimientos a agrupar
                var oMovsAgr = new List<MovimientoInventario>();
                foreach (int iMovID in oMovsSel)
                    oMovsAgr.Add(Datos.GetEntity<MovimientoInventario>(c => c.MovimientoInventarioID == iMovID && c.Estatus));
                // Se crea el movimiento agrupador
                var oMovAgr = new MovimientoInventario()
                {
                    TipoOperacionID = Cat.TiposDeOperacionMovimientos.EntradaCompra,
                    ProveedorID = this.Proveedor.ProveedorID,
                    FechaRecepcion = frmAgrupar.FechaGuardar,
                    Subtotal = oMovsAgr.Sum(c => c.Subtotal),
                    IVA = oMovsAgr.Sum(c => c.IVA),
                    ImporteTotal = oMovsAgr.Sum(c => c.ImporteTotal),
                    FueLiquidado = false,
                    ImporteFactura = oMovsAgr.Sum(c => c.ImporteFactura),
                    EsAgrupador = true
                };
                Datos.Guardar<MovimientoInventario>(oMovAgr);
                // Se hace la agrupación
                foreach (var oReg in oMovsAgr)
                {
                    oReg.MovimientoAgrupadorID = oMovAgr.MovimientoInventarioID;
                    Datos.Guardar<MovimientoInventario>(oReg);
                }
                Cargando.Cerrar();
                this.CargarMovimientosNoPagados(this.Proveedor.ProveedorID);
            }
            frmAgrupar.Dispose();
        }
Beispiel #18
0
 public void Remove(MovimientoInventario movimiento) =>
 _movimientoInventario.DeleteOne(mov => mov.Id == movimiento.Id);
        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();
        }
Beispiel #20
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();
        }
Beispiel #21
0
        public static MovimientoInventario CrearDevolucionProveedor(int iProveedorID, int iOrigenID, decimal mImporte, string sObservacion)
        {
            var oMov = new MovimientoInventario()
            {
                TipoOperacionID = Cat.TiposDeOperacionMovimientos.DevolucionAProveedor,
                ProveedorID = iProveedorID,
                // DevolucionOrigenID = iOrigenID,
                ImporteTotal = mImporte,
                Observacion = sObservacion
            };
            Datos.Guardar<MovimientoInventario>(oMov);

            return oMov;
        }