コード例 #1
0
        private long GenerarMovimientoEntrada(TraspasoMpPaMedInfo info)
        {
            var     almacenInventarioBL        = new AlmacenInventarioBL();
            var     almacenInventarioLoteBL    = new AlmacenInventarioLoteBL();
            var     almacenMovimientoBL        = new AlmacenMovimientoBL();
            var     almacenMovimientoDetalleBL = new AlmacenMovimientoDetalleBL();
            decimal cantidadTraspaso           = info.CantidadTraspasarDestino;

            decimal precioPromedio = 0;

            List <AlmacenInventarioInfo> inventariosDestino = almacenInventarioBL.ObtienePorAlmacenId(info.AlmacenDestino);

            if (inventariosDestino != null && inventariosDestino.Any())
            {
                AlmacenInventarioInfo almacenInventarioDestino = inventariosDestino.FirstOrDefault(inv => inv.ProductoID == info.ProductoDestino.ProductoId);
                if (almacenInventarioDestino != null)
                {
                    almacenInventarioDestino.Cantidad              = almacenInventarioDestino.Cantidad + cantidadTraspaso;
                    almacenInventarioDestino.Importe               = almacenInventarioDestino.Importe + info.ImporteTraspaso;
                    almacenInventarioDestino.PrecioPromedio        = almacenInventarioDestino.Importe / almacenInventarioDestino.Cantidad;
                    almacenInventarioDestino.UsuarioModificacionID = info.Usuario.UsuarioID;

                    almacenInventarioBL.Actualizar(almacenInventarioDestino);
                }
                else
                {
                    //Crear el Inventario

                    var almacenInventarioGuardar = new AlmacenInventarioInfo
                    {
                        AlmacenID         = info.AlmacenDestino.AlmacenID,
                        ProductoID        = info.ProductoDestino.ProductoId,
                        Cantidad          = cantidadTraspaso,
                        Importe           = info.ImporteTraspaso,
                        PrecioPromedio    = info.ImporteTraspaso / cantidadTraspaso,
                        UsuarioCreacionID = info.Usuario.UsuarioID
                    };
                    almacenInventarioBL.Crear(almacenInventarioGuardar);
                }
            }
            else
            {
                //Crear el Inventario

                var almacenInventarioGuardar = new AlmacenInventarioInfo
                {
                    AlmacenID         = info.AlmacenDestino.AlmacenID,
                    ProductoID        = info.ProductoDestino.ProductoId,
                    Cantidad          = cantidadTraspaso,
                    Importe           = info.ImporteTraspaso,
                    PrecioPromedio    = info.ImporteTraspaso / cantidadTraspaso,
                    UsuarioCreacionID = info.Usuario.UsuarioID
                };
                almacenInventarioBL.Crear(almacenInventarioGuardar);
            }
            if (info.LoteMpDestino.AlmacenInventarioLoteId != 0)
            {
                AlmacenInventarioLoteInfo loteDestino = almacenInventarioLoteBL.ObtenerAlmacenInventarioLotePorId(info.LoteMpDestino.AlmacenInventarioLoteId);

                if (loteDestino != null)
                {
                    loteDestino.Cantidad              = loteDestino.Cantidad + cantidadTraspaso;
                    loteDestino.Importe               = loteDestino.Importe + info.ImporteTraspaso;
                    loteDestino.PrecioPromedio        = loteDestino.Importe / loteDestino.Cantidad;
                    loteDestino.UsuarioModificacionId = info.Usuario.UsuarioID;

                    almacenInventarioLoteBL.Actualizar(loteDestino);
                }
            }
            var almacenMovimientoDestino = new AlmacenMovimientoInfo
            {
                AlmacenID         = info.AlmacenDestino.AlmacenID,
                TipoMovimientoID  = TipoMovimiento.EntradaAlmacen.GetHashCode(),
                ProveedorId       = info.ProveedorDestino.ProveedorID,
                Status            = Estatus.AplicadoInv.GetHashCode(),
                UsuarioCreacionID = info.Usuario.UsuarioID,
                Observaciones     = info.JustificacionDestino
            };
            long almacenMovimientoID = almacenMovimientoBL.Crear(almacenMovimientoDestino);

            precioPromedio = info.ImporteTraspaso / info.CantidadTraspasarDestino;

            var almacenMovimientoDetalleInfo = new AlmacenMovimientoDetalle
            {
                AlmacenMovimientoID = almacenMovimientoID,
                //ContratoId = info.ContratoDestino.ContratoId,
                AlmacenInventarioLoteId = info.LoteMpDestino.AlmacenInventarioLoteId,
                Piezas            = 0,
                ProductoID        = info.ProductoDestino.ProductoId,
                Precio            = precioPromedio,
                Cantidad          = cantidadTraspaso,
                Importe           = info.ImporteTraspaso,
                UsuarioCreacionID = info.Usuario.UsuarioID
            };

            almacenMovimientoDetalleBL.Crear(almacenMovimientoDetalleInfo);

            return(almacenMovimientoID);
        }
コード例 #2
0
        /// <summary>
        /// Crea el nuevo lote para la organizacion producto tipo almacen seleccionados
        /// </summary>
        /// <param name="parametro"></param>
        /// <returns></returns>
        internal AlmacenInventarioLoteInfo CrearLotePorOrganizacionTipoAlmacenProducto(ParametrosOrganizacionTipoAlmacenProductoActivo parametro)
        {
            try
            {
                var almacenBl               = new AlmacenBL();
                var almacenInventarioBl     = new AlmacenInventarioBL();
                var almacenInventarioLoteBl = new AlmacenInventarioLoteBL();

                AlmacenInventarioLoteInfo almacenInventarioLote = null;

                var almacenInventario =
                    almacenBl.ObtenerAlmacenInventarioPorOrganizacionTipoAlmacen(new ParametrosOrganizacionTipoAlmacenProductoActivo
                {
                    OrganizacionId = parametro.OrganizacionId,
                    TipoAlmacenId  = parametro.TipoAlmacenId,
                    Activo         = parametro.Activo,
                    ProductoId     = parametro.ProductoId
                });

                // Si el producto no se encuentra en el almacen inventario, lo insertamos
                if (almacenInventario == null)
                {
                    var listaAlmacenOrganizacion = almacenBl.ObtenerAlmacenPorOrganizacion(parametro.OrganizacionId);
                    if (listaAlmacenOrganizacion != null)
                    {
                        // Obtenemos el almacen y validamos que sea del mismo tipo Almacen
                        foreach (AlmacenInfo almacenInfo in listaAlmacenOrganizacion)
                        {
                            // Aqui se valida que el almacen sea del tipo seleccionado
                            if (almacenInfo.TipoAlmacen.TipoAlmacenID == parametro.TipoAlmacenId)
                            {
                                almacenInventario = new AlmacenInventarioInfo
                                {
                                    AlmacenInventarioID =
                                        almacenInventarioBl.Crear(new AlmacenInventarioInfo
                                    {
                                        AlmacenID         = almacenInfo.AlmacenID,
                                        ProductoID        = parametro.ProductoId,
                                        UsuarioCreacionID = parametro.UsuarioId
                                    }),
                                    AlmacenID = almacenInfo.AlmacenID
                                };
                                break;
                            }
                        }
                    }
                }

                if (almacenInventario != null)
                {
                    int loteIdCreado = almacenInventarioLoteBl.Crear(new AlmacenInventarioLoteInfo
                    {
                        AlmacenInventarioLoteId = 0,
                        AlmacenInventario       =
                            new AlmacenInventarioInfo
                        {
                            AlmacenInventarioID = almacenInventario.AlmacenInventarioID
                        },
                        Cantidad          = 0,
                        PrecioPromedio    = 0,
                        Piezas            = 0,
                        Importe           = 0,
                        Activo            = (EstatusEnum)parametro.Activo,
                        UsuarioCreacionId = parametro.UsuarioId,
                    }, new AlmacenInventarioInfo
                    {
                        AlmacenID  = almacenInventario.AlmacenID,
                        ProductoID = parametro.ProductoId
                    });

                    almacenInventarioLote =
                        almacenInventarioLoteBl.ObtenerAlmacenInventarioLotePorId(loteIdCreado);
                }

                return(almacenInventarioLote);
            }
            catch (Exception ex)
            {
                Logger.Error(ex);
                throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
            }
        }
コード例 #3
0
        /// <summary>
        /// Genera la carga inicial de los inventarios
        /// </summary>
        /// <param name="cargaInventarios"></param>
        /// <returns></returns>
        public void GenerarCargaInicial(List <CargaMPPAModel> cargaInventarios)
        {
            try
            {
                var almacenInventarioBL     = new AlmacenInventarioBL();
                var almacenInventarioLoteBL = new AlmacenInventarioLoteBL();
                var fechaBL = new FechaBL();

                FechaInfo fechaActual = fechaBL.ObtenerFechaActual();

                using (var transaction = new TransactionScope())
                {
                    foreach (var cargaInventario in cargaInventarios)
                    {
                        if (cargaInventario.AlmacenInventario == null)
                        {
                            cargaInventario.AlmacenInventario = new AlmacenInventarioInfo();
                        }
                        var almacenInventarioFiltro = new AlmacenInventarioInfo
                        {
                            AlmacenID  = cargaInventario.AlmacenID,
                            ProductoID = cargaInventario.ProductoID
                        };

                        var almacenInventario = almacenInventarioBL.ObtenerPorAlmacenIdProductoId(almacenInventarioFiltro);

                        if (almacenInventario == null)
                        {
                            almacenInventario = new AlmacenInventarioInfo();
                        }

                        var almacenInventarioLote = new AlmacenInventarioLoteInfo();

                        almacenInventario.Importe        = almacenInventario.Importe + cargaInventario.ImporteActual;
                        almacenInventario.Cantidad       = almacenInventario.Cantidad + cargaInventario.CantidadActual;
                        almacenInventario.PrecioPromedio = almacenInventario.Importe /
                                                           almacenInventario.Cantidad;
                        almacenInventario.AlmacenID             = cargaInventario.Almacen.AlmacenID;
                        almacenInventario.ProductoID            = cargaInventario.Producto.ProductoId;
                        almacenInventario.UsuarioCreacionID     = 1;
                        almacenInventario.UsuarioModificacionID = 1;

                        if (almacenInventario.AlmacenInventarioID == 0)
                        {
                            int almacenInventarioID = almacenInventarioBL.Crear(almacenInventario);
                            almacenInventario.AlmacenInventarioID = almacenInventarioID;
                        }
                        else
                        {
                            almacenInventarioBL.Actualizar(almacenInventario);
                        }
                        if (cargaInventario.Producto.ManejaLote)
                        {
                            almacenInventarioLote = new AlmacenInventarioLoteInfo
                            {
                                AlmacenInventario = almacenInventario,
                                Cantidad          = cargaInventario.CantidadActual,
                                Importe           = cargaInventario.ImporteActual,
                                PrecioPromedio    =
                                    cargaInventario.ImporteActual /
                                    cargaInventario.CantidadActual,
                                Lote        = cargaInventario.Lote,
                                Piezas      = cargaInventario.Piezas,
                                FechaInicio =
                                    cargaInventario.FechaInicioLote == DateTime.MinValue
                                                                        ? fechaActual.FechaActual
                                                                        : cargaInventario.FechaInicioLote,
                                UsuarioCreacionId = 1,
                                Activo            = EstatusEnum.Activo
                            };
                            int almacenInventaroLoteID =
                                almacenInventarioLoteBL.CrearConTodosParametros(almacenInventarioLote);
                            almacenInventarioLote.AlmacenInventarioLoteId = almacenInventaroLoteID;
                        }
                        GenerarMovimientosAlmacen(cargaInventario, almacenInventarioLote);
                    }

                    transaction.Complete();
                }
            }
            catch (ExcepcionGenerica)
            {
                throw;
            }
            catch (Exception ex)
            {
                Logger.Error(ex);
                throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
            }
        }
コード例 #4
0
        internal bool GuardarInventario(RecepcionProductoInfo recepcionProducto)
        {
            try
            {
                AlmacenBL           almacenBl           = new AlmacenBL();
                AlmacenInventarioBL almacenInventarioBl = new AlmacenInventarioBL();
                foreach (var recepcionProductodetalle in recepcionProducto.ListaRecepcionProductoDetalle)
                {
                    AlmacenInfo almacen = almacenBl.ObtenerPorID(recepcionProducto.Almacen.AlmacenID);
                    List <AlmacenInventarioInfo> listaAlmacenlmacenInventario =
                        almacenInventarioBl.ObtienePorAlmacenId(almacen);

                    if (listaAlmacenlmacenInventario != null)
                    {
                        List <AlmacenInventarioInfo> almacenInventarioListaResultado =
                            listaAlmacenlmacenInventario.Where(
                                registro => registro.ProductoID == recepcionProductodetalle.Producto.ProductoId)
                            .ToList();

                        if (almacenInventarioListaResultado.Count > 0)
                        {
                            var almacenInventario = almacenInventarioListaResultado[0];
                            almacenInventario.Cantidad = almacenInventario.Cantidad +
                                                         recepcionProductodetalle.Cantidad;
                            almacenInventario.Importe               = almacenInventario.Importe + recepcionProductodetalle.Importe;
                            almacenInventario.PrecioPromedio        = almacenInventario.Importe / almacenInventario.Cantidad;
                            almacenInventario.UsuarioModificacionID = recepcionProducto.UsuarioCreacion.UsuarioID;

                            almacenInventarioBl.Actualizar(almacenInventario);
                        }
                        else
                        {
                            var almacenInventarioNuevo = new AlmacenInventarioInfo();
                            almacenInventarioNuevo.Almacen        = recepcionProducto.Almacen;
                            almacenInventarioNuevo.AlmacenID      = recepcionProducto.Almacen.AlmacenID;
                            almacenInventarioNuevo.Producto       = recepcionProductodetalle.Producto;
                            almacenInventarioNuevo.ProductoID     = recepcionProductodetalle.Producto.ProductoId;
                            almacenInventarioNuevo.Cantidad       = recepcionProductodetalle.Cantidad;
                            almacenInventarioNuevo.Importe        = recepcionProductodetalle.Importe;
                            almacenInventarioNuevo.PrecioPromedio = almacenInventarioNuevo.Importe /
                                                                    almacenInventarioNuevo.Cantidad;
                            almacenInventarioNuevo.UsuarioCreacionID = recepcionProducto.UsuarioCreacion.UsuarioID;
                            almacenInventarioBl.Crear(almacenInventarioNuevo);
                        }
                    }
                    else
                    {
                        var almacenInventarioNuevo = new AlmacenInventarioInfo();
                        almacenInventarioNuevo.Almacen        = recepcionProducto.Almacen;
                        almacenInventarioNuevo.AlmacenID      = recepcionProducto.Almacen.AlmacenID;
                        almacenInventarioNuevo.Producto       = recepcionProductodetalle.Producto;
                        almacenInventarioNuevo.ProductoID     = recepcionProductodetalle.Producto.ProductoId;
                        almacenInventarioNuevo.Cantidad       = recepcionProductodetalle.Cantidad;
                        almacenInventarioNuevo.Importe        = recepcionProductodetalle.Importe;
                        almacenInventarioNuevo.PrecioPromedio = almacenInventarioNuevo.Importe /
                                                                almacenInventarioNuevo.Cantidad;
                        almacenInventarioNuevo.UsuarioCreacionID = recepcionProducto.UsuarioCreacion.UsuarioID;
                        almacenInventarioBl.Crear(almacenInventarioNuevo);
                    }
                }
                return(true);
            }
            catch (Exception ex)
            {
                Logger.Error(ex);
            }
            return(false);
        }