Exemple #1
0
        public static void AfectarExistenciaYKardex(int iParteID, int iSucursalID, int iOperacionID, string sFolio, int iUsuarioID, string sEntidad
                                                    , string sOrigen, string sDestino, decimal mCantidad, decimal mImporte, string sTabla, int iId)
        {
            // Se manda a afectar la existencia
            AdmonProc.AgregarExistencia(iParteID, iSucursalID, mCantidad, sTabla, iId);

            // Se manda a afectar en el kardex
            var oSucursal = Datos.GetEntity <Sucursal>(c => c.SucursalID == iSucursalID && c.Estatus);
            var oKardex   = new ParteKardex()
            {
                ParteID          = iParteID,
                OperacionID      = iOperacionID,
                SucursalID       = iSucursalID,
                Folio            = sFolio,
                Fecha            = DateTime.Now,
                RealizoUsuarioID = iUsuarioID,
                Entidad          = sEntidad,
                Origen           = sOrigen,
                Destino          = sDestino,
                Cantidad         = mCantidad,
                Importe          = mImporte,
                RelacionTabla    = sTabla,
                RelacionID       = iId
            };

            AdmonProc.RegistrarKardex(oKardex);
        }
Exemple #2
0
        public static ResAcc Venta(Venta oVenta, List <VentaDetalle> Detalle)
        {
            bool bMod = (oVenta.VentaID > 0);

            if (bMod)
            {
                throw new Exception("No se ha programado funcionalidad para cuando la Venta ya exista.");
            }

            // Se generan datos predeterminados o globales, en caso de que apliquen
            oVenta.Fecha                 = (oVenta.Fecha != DateTime.MinValue ? oVenta.Fecha : DateTime.Now);
            oVenta.VentaEstatusID        = (oVenta.VentaEstatusID > 0 ? oVenta.VentaEstatusID : Cat.VentasEstatus.Realizada);
            oVenta.RealizoUsuarioID      = (oVenta.RealizoUsuarioID > 0 ? oVenta.RealizoUsuarioID : Theos.UsuarioID);
            oVenta.SucursalID            = (oVenta.SucursalID > 0 ? oVenta.SucursalID : Theos.SucursalID);
            oVenta.ComisionistaClienteID = (oVenta.ComisionistaClienteID > 0 ? oVenta.ComisionistaClienteID : null);
            oVenta.ClienteVehiculoID     = (oVenta.ClienteVehiculoID > 0 ? oVenta.ClienteVehiculoID : null);

            // Se obtiene el folio correspondiente

            /* string sFolio = Config.Valor("Ventas.Folio");
             * Config.EstablecerValor("Ventas.Folio", (Util.ConvertirEntero(sFolio) + 1).ToString().PadLeft(7, '0'));
             * oVenta.Folio = sFolio; */

            // Se guarda la venta
            Datos.Guardar <Venta>(oVenta);

            // Se guarda el detalle
            foreach (var ParteDetalle in Detalle)
            {
                if (ParteDetalle.VentaDetalleID > 0)
                {
                    continue;                                   // No es una venta nueva, no se ha especificado que hacer en estos casos
                }
                ParteDetalle.VentaID = oVenta.VentaID;
                Datos.Guardar <VentaDetalle>(ParteDetalle);

                // Se afecta la existencia
                // AdmonProc.AgregarExistencia(ParteDetalle.ParteID, oVenta.SucursalID, (ParteDetalle.Cantidad * -1), Cat.Tablas.Venta, oVenta.VentaID);
                // Se meten datos a kardex que se actualizarán posteriormente, al cobrar la venta
                AdmonProc.AfectarExistenciaYKardex(ParteDetalle.ParteID, oVenta.SucursalID, Cat.OperacionesKardex.Venta, null, oVenta.RealizoUsuarioID, "", "", ""
                                                   , (ParteDetalle.Cantidad * -1), 0, Cat.Tablas.Venta, oVenta.VentaID);
            }

            // Se generar datos relevantes al cliente comisionista, si hubiera
            if (oVenta.ComisionistaClienteID.Valor() > 0)
            {
                // Se calcula el importe de la comisión
                decimal mComision = UtilDatos.VentaComisionCliente(oVenta.VentaID, oVenta.ComisionistaClienteID.Valor());
                // Se genera una nota de crédito, por la comisión
                if (mComision > 0)
                {
                    VentasProc.GenerarNotaDeCredito(oVenta.ComisionistaClienteID.Valor(), mComision, "", Cat.OrigenesNotaDeCredito.Comision, oVenta.VentaID);
                }
            }

            return(new ResAcc(true));
        }
Exemple #3
0
        public static void EliminarVenta(int iVentaID)
        {
            var oVenta = Datos.GetEntity <Venta>(q => q.VentaID == iVentaID && q.Estatus);

            // De momento sólo están contempladas las ventas que sólo han sido registradas. No cobradas, pagadas, canceladas
            if (oVenta.VentaEstatusID != Cat.VentasEstatus.Realizada)
            {
                return;
            }

            var oVentaDet = Datos.GetListOf <VentaDetalle>(q => q.VentaID == oVenta.VentaID && q.Estatus);

            // Se regresa la existencia y se borra el detalle de la venta
            foreach (var oParteDet in oVentaDet)
            {
                AdmonProc.AgregarExistencia(oParteDet.ParteID, oVenta.SucursalID, oParteDet.Cantidad, Cat.Tablas.Venta, iVentaID);
                Datos.Eliminar <VentaDetalle>(oParteDet, true);
            }
            // Se borra la venta en sí
            Datos.Eliminar <Venta>(oVenta, true);

            // Se borran los datos del kardex
            var oPartesKardex = Datos.GetListOf <ParteKardex>(c => c.OperacionID == Cat.OperacionesKardex.Venta && c.RelacionTabla == Cat.Tablas.Venta &&
                                                              c.RelacionID == iVentaID);

            foreach (var oReg in oVentaDet)
            {
                var oKardex = oPartesKardex.FirstOrDefault(c => c.ParteID == oReg.ParteID);
                if (oKardex == null)
                {
                    continue;
                }
                Datos.Eliminar <ParteKardex>(oKardex);
                // Se verifica si hubo algún otro movimiento en kardex de la misma parte, para hacer el reajuste
                var oDespues = Datos.GetListOf <ParteKardex>(c => c.ParteKardexID > oKardex.ParteKardexID && c.ParteID == oKardex.ParteID);
                foreach (var oRegD in oDespues)
                {
                    oRegD.ExistenciaNueva += (oKardex.Cantidad * -1);
                    Datos.Guardar <ParteKardex>(oRegD);
                }
            }
        }
Exemple #4
0
        public static ResAcc RecibirTraspaso(int iUsuarioID, string sMotivo, List <modDetalleTraspaso> oDetalle, bool bValidarContingencia)
        {
            if (oDetalle.Count <= 0)
            {
                return(new ResAcc("No hay nada que recibir."));
            }

            // Validar que lo recibido sea menor o igual que lo enviado
            foreach (var oReg in oDetalle)
            {
                if (oReg.Recibido > oReg.Cantidad)
                {
                    return(new ResAcc("Existen uno o más artículos que tienen una cantidad recibida mayor a lo enviado."));
                }
            }

            // Se verifica si existe alguna contingencia
            bool bExisteContingencia = false;

            foreach (var oReg in oDetalle)
            {
                if (oReg.Recibido < oReg.Cantidad)
                {
                    bExisteContingencia = true;
                    break;
                }
            }

            if (bExisteContingencia && bValidarContingencia)
            {
                return(new ResAcc("El traspaso tiene uno o más conflictos.", Cat.CodigosRes.ConflictoEnTraspasos));
            }

            // Se valida el motivo, en caso de que haya habido contingencia
            if (bExisteContingencia && string.IsNullOrEmpty(sMotivo))
            {
                return(new ResAcc("Debes especificar un motivo."));
            }

            // Se obtiene el MovimientoInventario correspondiente al traspaso
            int iRecibirUnoID = oDetalle[0].MovimientoInventarioDetalleID;
            var oRecibirUno   = Datos.GetEntity <MovimientoInventarioDetalle>(c => c.MovimientoInventarioDetalleID == iRecibirUnoID && c.Estatus);
            int iMovID        = oRecibirUno.MovimientoInventarioID;
            var oTraspasoV    = Datos.GetEntity <MovimientoInventarioView>(c => c.MovimientoInventarioID == iMovID);
            int iSucursalID   = oTraspasoV.SucursalDestinoID.Valor();

            //
            decimal mCostoTotal = 0;

            foreach (var oReg in oDetalle)
            {
                // Si la cantidad recibida es menor a lo enviado, almacenar la contingencia
                if (oReg.Recibido < oReg.Cantidad)
                {
                    var contingencia = new MovimientoInventarioTraspasoContingencia()
                    {
                        MovimientoInventarioID        = iMovID,
                        MovimientoInventarioDetalleID = oReg.MovimientoInventarioDetalleID,
                        ParteID            = oReg.ParteID,
                        CantidadEnviada    = oReg.Cantidad,
                        CantidadRecibida   = oReg.Recibido,
                        CantidadDiferencia = (oReg.Cantidad - oReg.Recibido),
                        Comentario         = sMotivo,
                        UsuarioID          = iUsuarioID,
                        MovimientoInventarioEstatusContingenciaID = Cat.TraspasoEstatusContingencias.NoSolucionado
                    };
                    Datos.Guardar <MovimientoInventarioTraspasoContingencia>(contingencia);
                }

                //Aumentar la existencia actual de la sucursal destino
                var oParte = Datos.GetEntity <Parte>(c => c.ParteID == oReg.ParteID && c.Estatus);
                if (!oParte.EsServicio.Valor())
                {
                    var existencia = Datos.GetEntity <ParteExistencia>(p => p.ParteID == oReg.ParteID && p.SucursalID == iSucursalID);
                    if (existencia != null)
                    {
                        var inicial = existencia.Existencia;
                        existencia.Existencia       += oReg.Recibido;
                        existencia.UsuarioID         = iUsuarioID;
                        existencia.FechaModificacion = DateTime.Now;
                        Datos.Guardar <ParteExistencia>(existencia);

                        var historial = new MovimientoInventarioHistorial()
                        {
                            MovmientoInventarioID = iMovID,
                            ParteID           = oReg.ParteID,
                            ExistenciaInicial = Util.Decimal(inicial),
                            ExistenciaFinal   = Util.Decimal(existencia.Existencia),
                            SucursalID        = iSucursalID,
                            UsuarioID         = iUsuarioID
                        };
                        Datos.Guardar <MovimientoInventarioHistorial>(historial);
                    }
                }

                // Se agrega al Kardex
                var oPartePrecio = Datos.GetEntity <PartePrecio>(c => c.ParteID == oReg.ParteID && c.Estatus);
                AdmonProc.RegistrarKardex(new ParteKardex()
                {
                    ParteID          = oReg.ParteID,
                    OperacionID      = Cat.OperacionesKardex.EntradaTraspaso,
                    SucursalID       = iSucursalID,
                    Folio            = iMovID.ToString(),
                    Fecha            = DateTime.Now,
                    RealizoUsuarioID = iUsuarioID,
                    Entidad          = Util.Cadena(oTraspasoV.NombreProveedor),
                    Origen           = oTraspasoV.SucursalOrigen,
                    Destino          = oTraspasoV.SucursalDestino,
                    Cantidad         = oReg.Recibido,
                    Importe          = oPartePrecio.Costo.Valor()
                });

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

            // Se genera la póliza especial correspondiente (AfeConta)
            var oUsuario = Datos.GetEntity <Usuario>(c => c.UsuarioID == iUsuarioID && c.Estatus);
            var oPoliza  = ContaProc.CrearPoliza(Cat.ContaTiposDePoliza.Diario, string.Format("TRASPASO ORIGEN {0:00} DESTINO {1:00}"
                                                                                              , oTraspasoV.SucursalOrigenID, oTraspasoV.SucursalDestinoID), Cat.ContaCuentasAuxiliares.Inventario, 0, mCostoTotal
                                                 , oUsuario.NombreUsuario, Cat.Tablas.MovimientoInventario, iMovID, iSucursalID);

            //Actualizar el movimiento con los datos (fecha y usuario que recibio)
            var movimiento = Datos.GetEntity <MovimientoInventario>(m => m.MovimientoInventarioID == iMovID);

            if (null != movimiento)
            {
                movimiento.ExisteContingencia       = bExisteContingencia;
                movimiento.UsuarioRecibioTraspasoID = iUsuarioID;
                movimiento.FechaRecepcion           = DateTime.Now;
                movimiento.FechaModificacion        = DateTime.Now;
                Datos.Guardar <MovimientoInventario>(movimiento);
            }

            return(new ResAcc());
        }
Exemple #5
0
 public static ProveedorParteGanancia ObtenerParteDescuentoGanancia(int?iProveedorID, int?iMarcaID, int?iLineaID, int?iParteID)
 {
     return(AdmonProc.ObtenerParteDescuentoGanancia(iProveedorID, iMarcaID, iLineaID, iParteID, false));
 }
Exemple #6
0
        public static string ObtenerImagenParte(int iParteID)
        {
            var oImagenes = AdmonProc.ObtenerImagenesParte(iParteID);

            return(oImagenes.Count > 0 ? oImagenes[0] : "");
        }
Exemple #7
0
        public static ResAcc VentaDevolucion(VentaDevolucion oDevolucion, List <VentaDevolucionDetalle> oDetalle)
        {
            // Se generan datos predeterminados o globales, en caso de que apliquen
            oDevolucion.Fecha      = (oDevolucion.Fecha != DateTime.MinValue ? oDevolucion.Fecha : DateTime.Now);
            oDevolucion.SucursalID = (oDevolucion.SucursalID > 0 ? oDevolucion.SucursalID : Theos.SucursalID);

            // Se guarda la devolución
            Datos.Guardar <VentaDevolucion>(oDevolucion);

            // Se guarda el detalle
            VentaDetalle oParteVenta;

            foreach (var ParteDetalle in oDetalle)
            {
                ParteDetalle.VentaDevolucionID = oDevolucion.VentaDevolucionID;
                Datos.Guardar <VentaDevolucionDetalle>(ParteDetalle);

                // Se quita el producto de la venta
                oParteVenta = Datos.GetEntity <VentaDetalle>(q => q.Estatus &&
                                                             q.VentaID == oDevolucion.VentaID &&
                                                             q.ParteID == ParteDetalle.ParteID &&
                                                             q.Cantidad == ParteDetalle.Cantidad &&
                                                             q.PrecioUnitario == ParteDetalle.PrecioUnitario &&
                                                             q.Iva == ParteDetalle.Iva);

                oParteVenta.Estatus = false;
                Datos.Guardar <VentaDetalle>(oParteVenta, false);

                // Se afecta la existencia
                // AdmonProc.AgregarExistencia(ParteDetalle.ParteID, GlobalClass.SucursalID, ParteDetalle.Cantidad, Cat.Tablas.VentaDevolucion, oDevolucion.VentaDevolucionID);
                var oDevV = Datos.GetEntity <VentasDevolucionesView>(c => c.VentaDevolucionID == oDevolucion.VentaDevolucionID);
                AdmonProc.AfectarExistenciaYKardex(ParteDetalle.ParteID, Theos.SucursalID, Cat.OperacionesKardex.VentaCancelada, oDevV.FolioDeVenta
                                                   , oDevV.RealizoUsuarioID, oDevV.Cliente, oDevV.ClienteID.ToString(), oDevV.Sucursal, ParteDetalle.Cantidad
                                                   , (ParteDetalle.PrecioUnitario + ParteDetalle.Iva), Cat.Tablas.VentaDevolucion, oDevolucion.VentaDevolucionID);
            }

            // Si es cancelación, se cambia el estatus de la venta
            var oVenta = Datos.GetEntity <Venta>(c => c.VentaID == oDevolucion.VentaID && c.Estatus);

            if (oDevolucion.EsCancelacion)
            {
                // Se verifica si la venta ha tenido pagos
                var oVentaV = Datos.GetEntity <VentasView>(c => c.VentaID == oDevolucion.VentaID);
                oVenta.VentaEstatusID = (oVentaV.Pagado > 0 ? Cat.VentasEstatus.Cancelada : Cat.VentasEstatus.CanceladaSinPago);
                Datos.Guardar <Venta>(oVenta);
            }

            // Se verifican notas de crédito que pudieran cancelarse, por cliente comisionista
            if (oVenta.ComisionistaClienteID > 0)
            {
                // Se calcula el importe de la comisión que se debe quitar
                var          oComisionista = Datos.GetEntity <Cliente>(q => q.ClienteID == oVenta.ComisionistaClienteID && q.Estatus);
                decimal      mComision     = 0;
                PreciosParte oPrecios;
                foreach (var ParteD in oDetalle)
                {
                    oPrecios   = new PreciosParte(ParteD.ParteID);
                    mComision += (((ParteD.PrecioUnitario + ParteD.Iva) - oPrecios.ObtenerPrecio(oComisionista.ListaDePrecios)) * ParteD.Cantidad);
                }
                // Se genera una nota de crédito negativa
                if (mComision > 0)
                {
                    VentasProc.GenerarNotaDeCredito(oComisionista.ClienteID, (mComision * -1), "", Cat.OrigenesNotaDeCredito.Devolucion, oVenta.VentaID);
                }
            }

            return(new ResAcc(true));
        }