Ejemplo n.º 1
0
        /// <summary>
        /// Obtiene los almacenes en base a la organizacion, el tipo de almacen y el producto
        /// </summary>
        /// <param name="datosLotes"></param>
        /// <returns></returns>
        internal List <AlmacenInventarioLoteInfo> ObtenerListadoLotesPorOrganizacionTipoAlmacenProducto(ParametrosOrganizacionTipoAlmacenProductoActivo datosLotes)
        {
            List <AlmacenInventarioLoteInfo> almacenInventarioLote = null;

            try
            {
                var almacenDAL = new AlmacenInventarioLoteDAL();
                almacenInventarioLote = almacenDAL.ObtenerListadoLotesPorOrganizacionTipoAlmacenProducto(datosLotes);

                if (almacenInventarioLote != null)
                {
                    foreach (var almacenInventario in almacenInventarioLote)
                    {
                        if (almacenInventario.AlmacenInventario.AlmacenInventarioID > 0)
                        {
                            var almacenInventarioBl = new AlmacenInventarioBL();
                            almacenInventario.AlmacenInventario =
                                almacenInventarioBl.ObtenerAlmacenInventarioPorId(
                                    almacenInventario.AlmacenInventario.AlmacenInventarioID);
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                Logger.Error(ex);
                throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
            }

            return(almacenInventarioLote);
        }
Ejemplo n.º 2
0
        /// <summary>
        /// Obtiene almaceninventariolote por folio
        /// </summary>
        /// <param name="almacenInventarioLote"></param>
        /// <returns></returns>
        internal AlmacenInventarioLoteInfo ObtenerAlmacenInventarioLoteAlmacenCodigo(AlmacenInventarioLoteInfo almacenInventarioLote)
        {
            try
            {
                var almacenDAL = new AlmacenInventarioLoteDAL();
                almacenInventarioLote = almacenDAL.ObtenerAlmacenInventarioLoteAlmacenCodigo(almacenInventarioLote);

                if (almacenInventarioLote != null)
                {
                    if (almacenInventarioLote.AlmacenInventario.AlmacenInventarioID > 0)
                    {
                        var almacenInventarioBl = new AlmacenInventarioBL();
                        almacenInventarioLote.AlmacenInventario =
                            almacenInventarioBl.ObtenerAlmacenInventarioPorId(
                                almacenInventarioLote.AlmacenInventario.AlmacenInventarioID);
                    }
                }
            }
            catch (Exception ex)
            {
                Logger.Error(ex);
                throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
            }

            return(almacenInventarioLote);
        }
Ejemplo n.º 3
0
        /// <summary>
        /// Obtiene una lista de almaceninventariolote
        /// </summary>
        /// <param name="almacenInventario"></param>
        /// <returns></returns>
        internal List <AlmacenInventarioLoteInfo> ObtenerPorAlmacenInventarioID(AlmacenInventarioInfo almacenInventario)
        {
            List <AlmacenInventarioLoteInfo> almacenInventarioLote = null;

            try
            {
                var almacenDAL = new AlmacenInventarioLoteDAL();
                almacenInventarioLote = almacenDAL.ObtenerPorAlmacenInventarioID(almacenInventario);

                if (almacenInventarioLote != null)
                {
                    foreach (var almacenInventarioInfo in almacenInventarioLote)
                    {
                        if (almacenInventarioInfo.AlmacenInventario.AlmacenInventarioID > 0)
                        {
                            var almacenInventarioBl = new AlmacenInventarioBL();
                            almacenInventarioInfo.AlmacenInventario =
                                almacenInventarioBl.ObtenerAlmacenInventarioPorId(
                                    almacenInventarioInfo.AlmacenInventario.AlmacenInventarioID);
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                Logger.Error(ex);
                throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
            }

            return(almacenInventarioLote);
        }
Ejemplo n.º 4
0
        /// <summary>
        /// Termina la salida del producto
        /// </summary>
        /// <param name="salida"></param>
        /// <returns></returns>
        internal MemoryStream TerminarSalidaProducto(SalidaProductoInfo salida)
        {
            try
            {
                Logger.Info();
                bool         generaFactura = salida.GeneraFactura;
                MemoryStream resultado     = null;
                var          almacenBl     = new AlmacenBL();
                var          almacenMovimientoDetalleDAL = new AlmacenMovimientoDetalleDAL();
                var          almacenMovimiento           = new AlmacenMovimientoInfo();
                var          almacenInventarioLoteBl     = new AlmacenInventarioLoteBL();
                var          almacenInventarioBl         = new AlmacenInventarioBL();
                var          salidaProductoDal           = new SalidaProductoDAL();

                PolizaAbstract     poliza  = null;
                IList <PolizaInfo> polizas = null;
                using (var transaction = new TransactionScope())
                {
                    almacenMovimiento.AlmacenID         = salida.Almacen.AlmacenID;
                    almacenMovimiento.TipoMovimientoID  = salida.TipoMovimiento.TipoMovimientoID;
                    almacenMovimiento.UsuarioCreacionID = salida.UsuarioModificacionId;
                    almacenMovimiento.Status            = (int)EstatusInventario.Aplicado;

                    AlmacenMovimientoInfo almacenMovimientoGenerado =
                        almacenBl.GuardarAlmacenMovimiento(almacenMovimiento);

                    if (almacenMovimientoGenerado != null)
                    {
                        AlmacenInventarioLoteInfo almacenInventarioLote =
                            almacenInventarioLoteBl.ObtenerAlmacenInventarioLotePorId(
                                salida.AlmacenInventarioLote.AlmacenInventarioLoteId);
                        var listaAlmacenInventarioDetalle = new List <AlmacenMovimientoDetalle>();

                        var movimientoDetalle = new AlmacenMovimientoDetalle
                        {
                            AlmacenMovimientoID =
                                almacenMovimientoGenerado.AlmacenMovimientoID,
                            AlmacenInventarioLoteId =
                                salida.AlmacenInventarioLote.AlmacenInventarioLoteId,
                            Precio     = almacenInventarioLote.PrecioPromedio,
                            ProductoID = salida.Producto.ProductoId,
                            Cantidad   = salida.PesoBruto - salida.PesoTara,
                            Piezas     = salida.Piezas,
                            Importe    =
                                (salida.PesoBruto - salida.PesoTara) *
                                almacenInventarioLote.PrecioPromedio,
                            UsuarioCreacionID = salida.UsuarioModificacionId
                        };
                        listaAlmacenInventarioDetalle.Add(movimientoDetalle);

                        almacenMovimientoDetalleDAL.GuardarAlmacenMovimientoDetalle(listaAlmacenInventarioDetalle,
                                                                                    almacenMovimientoGenerado.
                                                                                    AlmacenMovimientoID);
                        if (almacenInventarioLote != null)
                        {
                            almacenInventarioLote.Cantidad = almacenInventarioLote.Cantidad -
                                                             (salida.PesoBruto - salida.PesoTara);
                            almacenInventarioLote.Importe = almacenInventarioLote.PrecioPromedio *
                                                            almacenInventarioLote.Cantidad;

                            almacenInventarioLote.UsuarioModificacionId = salida.UsuarioModificacionId;
                            almacenInventarioLoteBl.Actualizar(almacenInventarioLote);

                            AlmacenInfo almacen = almacenBl.ObtenerPorID(almacenMovimiento.AlmacenID);
                            List <AlmacenInventarioInfo> listaAlmacenlmacenInventario =
                                almacenInventarioBl.ObtienePorAlmacenId(almacen);
                            if (listaAlmacenlmacenInventario != null)
                            {
                                AlmacenInventarioInfo inventarioProducto = listaAlmacenlmacenInventario.FirstOrDefault(
                                    registro => registro.ProductoID == salida.Producto.ProductoId);

                                if (inventarioProducto != null)
                                {
                                    inventarioProducto.Cantidad = inventarioProducto.Cantidad -
                                                                  (salida.PesoBruto - salida.PesoTara);
                                    inventarioProducto.Importe = (inventarioProducto.PrecioPromedio *
                                                                  inventarioProducto.Cantidad);
                                    //Actualiza inventario
                                    inventarioProducto.UsuarioModificacionID = salida.UsuarioModificacionId;
                                    inventarioProducto.ProductoID            = salida.Producto.ProductoId;
                                    inventarioProducto.AlmacenID             = almacen.AlmacenID;
                                    almacenInventarioBl.ActualizarPorProductoId(inventarioProducto);
                                    salida.GeneraFactura = generaFactura;
                                    salidaProductoDal.TerminarSalidaProducto(salida, almacenMovimientoGenerado);

                                    #region POLIZA

                                    poliza =
                                        FabricaPoliza.ObtenerInstancia().ObtenerTipoPoliza(
                                            TipoPoliza.SalidaVentaProducto);
                                    salida.Importe = (salida.PesoBruto - salida.PesoTara) * salida.Precio;
                                    salida         = ObtenerFolioPorReimpresion(salida);
                                    polizas        = poliza.GeneraPoliza(salida);
                                    if (polizas != null)
                                    {
                                        var polizaBL = new PolizaBL();
                                        polizas.ToList().ForEach(datos =>
                                        {
                                            datos.OrganizacionID =
                                                salida.Organizacion.OrganizacionID;
                                            datos.UsuarioCreacionID =
                                                salida.UsuarioCreacionId;
                                            datos.ArchivoEnviadoServidor = 1;
                                        });
                                        polizaBL.GuardarServicioPI(polizas, TipoPoliza.SalidaVentaProducto);
                                        if (salida.Almacen == null)
                                        {
                                            salida.Almacen = new AlmacenInfo();
                                        }
                                        salida.Almacen.Organizacion = new OrganizacionInfo
                                        {
                                            OrganizacionID =
                                                salida.Organizacion.OrganizacionID
                                        };
                                        resultado = poliza.ImprimePoliza(salida, polizas);
                                    }

                                    #endregion POLIZA

                                    if (generaFactura)
                                    {
                                        #region FACTURA

                                        if (salida.TipoMovimiento.TipoMovimientoID ==
                                            TipoMovimiento.ProductoSalidaVenta.GetHashCode())
                                        {
                                            //Genera el xml y lo guarda en la ruta especificada en la configuración
                                            var facturaBl = new FacturaBL();
                                            facturaBl.GenerarDatosFacturaVentaDeMateriaPrima(salida);
                                        }

                                        #endregion
                                    }

                                    transaction.Complete();
                                }
                                else
                                {
                                    throw new ExcepcionDesconocida(
                                              Properties.ResourceServices.InventarioNormal_ErrorMovimientos);
                                }
                            }
                            else
                            {
                                throw new ExcepcionDesconocida(
                                          Properties.ResourceServices.InventarioNormal_ErrorMovimientos);
                            }
                        }
                        else
                        {
                            throw new ExcepcionDesconocida(
                                      Properties.ResourceServices.InventarioNormal_ErrorMovimientos);
                        }
                    }
                    else
                    {
                        throw new ExcepcionDesconocida(
                                  Properties.ResourceServices.InventarioNormal_ErrorMovimientos);
                    }
                }
                return(resultado);
            }
            catch (ExcepcionServicio ex)
            {
                Logger.Error(ex);
                throw;
            }
            catch (ExcepcionDesconocida)
            {
                throw;
            }
            catch (ExcepcionGenerica)
            {
                throw;
            }
            catch (Exception ex)
            {
                Logger.Error(ex);
                throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
            }
        }
Ejemplo n.º 5
0
        private long GenerarMovimientoEntradaCancelacion(AlmacenMovimientoInfo info, UsuarioInfo usuario)
        {
            var almacenInventarioBL        = new AlmacenInventarioBL();
            var almacenInventarioLoteBL    = new AlmacenInventarioLoteBL();
            var almacenMovimientoBL        = new AlmacenMovimientoBL();
            var almacenMovimientoDetalleBL = new AlmacenMovimientoDetalleBL();

            AlmacenMovimientoDetalle detalle = info.ListaAlmacenMovimientoDetalle.FirstOrDefault();

            if (detalle == null)
            {
                return(0);
            }

            //decimal cantidadTraspaso = detalle.Cantidad;

            List <AlmacenInventarioInfo> inventariosDestino       = almacenInventarioBL.ObtienePorAlmacenId(info.Almacen);
            AlmacenInventarioInfo        almacenInventarioDestino = null;

            if (inventariosDestino != null && inventariosDestino.Any())
            {
                almacenInventarioDestino =
                    inventariosDestino.FirstOrDefault(inv => inv.ProductoID == detalle.Producto.ProductoId);
                if (almacenInventarioDestino != null)
                {
                    almacenInventarioDestino.Cantidad              = almacenInventarioDestino.Cantidad + detalle.Cantidad;
                    almacenInventarioDestino.Importe               = almacenInventarioDestino.Importe + detalle.Importe;
                    almacenInventarioDestino.PrecioPromedio        = almacenInventarioDestino.Importe / almacenInventarioDestino.Cantidad;
                    almacenInventarioDestino.UsuarioModificacionID = usuario.UsuarioID;

                    almacenInventarioBL.Actualizar(almacenInventarioDestino);
                }
            }
            if (detalle.AlmacenInventarioLoteId != 0)
            {
                AlmacenInventarioLoteInfo loteDestino = almacenInventarioLoteBL.ObtenerAlmacenInventarioLotePorId(detalle.AlmacenInventarioLoteId);

                if (loteDestino != null)
                {
                    loteDestino.Cantidad              = loteDestino.Cantidad + detalle.Cantidad;
                    loteDestino.Importe               = loteDestino.Importe + detalle.Importe;
                    loteDestino.PrecioPromedio        = loteDestino.Importe / loteDestino.Cantidad;
                    loteDestino.UsuarioModificacionId = usuario.UsuarioID;

                    almacenInventarioLoteBL.Actualizar(loteDestino);
                }
            }
            var almacenMovimientoDestino = new AlmacenMovimientoInfo
            {
                AlmacenID         = info.Almacen.AlmacenID,
                TipoMovimientoID  = TipoMovimiento.EntradaAlmacen.GetHashCode(),
                ProveedorId       = info.ProveedorId,
                Status            = Estatus.AplicadoInv.GetHashCode(),
                UsuarioCreacionID = usuario.UsuarioID,
            };
            long almacenMovimientoID = almacenMovimientoBL.Crear(almacenMovimientoDestino);

            if (almacenInventarioDestino != null)
            {
                var almacenMovimientoDetalleInfo = new AlmacenMovimientoDetalle
                {
                    AlmacenMovimientoID     = almacenMovimientoID,
                    AlmacenInventarioLoteId = detalle.AlmacenInventarioLoteId,
                    //ContratoId = detalle.ContratoId,
                    Piezas            = 0,
                    ProductoID        = detalle.Producto.ProductoId,
                    Precio            = detalle.Precio,
                    Cantidad          = detalle.Cantidad,
                    Importe           = detalle.Importe,
                    UsuarioCreacionID = usuario.UsuarioID
                };
                almacenMovimientoDetalleBL.Crear(almacenMovimientoDetalleInfo);
            }
            return(almacenMovimientoID);
        }
Ejemplo n.º 6
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);
        }
Ejemplo n.º 7
0
        private long GenerarMovimientoSalida(TraspasoMpPaMedInfo info)
        {
            var     almacenInventarioBL        = new AlmacenInventarioBL();
            var     almacenInventarioLoteBL    = new AlmacenInventarioLoteBL();
            var     almacenMovimientoBL        = new AlmacenMovimientoBL();
            var     almacenMovimientoDetalleBL = new AlmacenMovimientoDetalleBL();
            decimal cantidadTraspaso           = info.CantidadTraspasarOrigen;

            List <AlmacenInventarioInfo> inventariosOrigen       = almacenInventarioBL.ObtienePorAlmacenId(info.AlmacenOrigen);
            AlmacenInventarioInfo        almacenInventarioOrigen = null;
            decimal precioPromedio = 0;
            decimal importe        = 0;

            if (inventariosOrigen != null && inventariosOrigen.Any())
            {
                almacenInventarioOrigen =
                    inventariosOrigen.FirstOrDefault(inv => inv.ProductoID == info.ProductoOrigen.ProductoId);
                if (almacenInventarioOrigen != null)
                {
                    almacenInventarioOrigen.Cantidad = almacenInventarioOrigen.Cantidad - cantidadTraspaso;
                    almacenInventarioOrigen.Importe  = almacenInventarioOrigen.Importe -
                                                       Math.Round(cantidadTraspaso * almacenInventarioOrigen.PrecioPromedio, 2);
                    if (almacenInventarioOrigen.Importe < 0)
                    {
                        almacenInventarioOrigen.Importe = 0;
                    }
                    if (almacenInventarioOrigen.Cantidad > 0)
                    {
                        almacenInventarioOrigen.PrecioPromedio = almacenInventarioOrigen.Importe / almacenInventarioOrigen.Cantidad;
                    }
                    almacenInventarioOrigen.UsuarioModificacionID = info.Usuario.UsuarioID;

                    almacenInventarioBL.Actualizar(almacenInventarioOrigen);
                    precioPromedio = almacenInventarioOrigen.PrecioPromedio;
                    importe        = precioPromedio * cantidadTraspaso;
                }
            }
            if (info.LoteMpOrigen.AlmacenInventarioLoteId != 0)
            {
                AlmacenInventarioLoteInfo loteOrigen = almacenInventarioLoteBL.ObtenerAlmacenInventarioLotePorId(info.LoteMpOrigen.AlmacenInventarioLoteId);

                if (loteOrigen != null)
                {
                    loteOrigen.Cantidad = loteOrigen.Cantidad - cantidadTraspaso;
                    loteOrigen.Importe  = loteOrigen.Importe - Math.Round(cantidadTraspaso * loteOrigen.PrecioPromedio, 2);
                    if (loteOrigen.Importe < 0)
                    {
                        loteOrigen.Importe = 0;
                    }
                    if (loteOrigen.Cantidad > 0)
                    {
                        loteOrigen.PrecioPromedio = loteOrigen.Importe / loteOrigen.Cantidad;
                    }
                    loteOrigen.UsuarioModificacionId = info.Usuario.UsuarioID;

                    almacenInventarioLoteBL.Actualizar(loteOrigen);
                    precioPromedio = loteOrigen.PrecioPromedio;
                    importe        = precioPromedio * cantidadTraspaso;
                }
            }
            var almacenMovimientoOrigen = new AlmacenMovimientoInfo
            {
                AlmacenID         = info.AlmacenOrigen.AlmacenID,
                TipoMovimientoID  = TipoMovimiento.ProductoSalidaTraspaso.GetHashCode(),
                ProveedorId       = info.ProveedorOrigen.ProveedorID,
                Status            = Estatus.AplicadoInv.GetHashCode(),
                UsuarioCreacionID = info.Usuario.UsuarioID,
                Observaciones     = info.JustificacionDestino
            };
            long almacenMovimientoID = almacenMovimientoBL.Crear(almacenMovimientoOrigen);

            if (almacenInventarioOrigen != null)
            {
                var almacenMovimientoDetalleInfo = new AlmacenMovimientoDetalle
                {
                    AlmacenMovimientoID     = almacenMovimientoID,
                    AlmacenInventarioLoteId = info.LoteMpOrigen.AlmacenInventarioLoteId,
                    Piezas            = 0,
                    ProductoID        = info.ProductoOrigen.ProductoId,
                    Precio            = precioPromedio,
                    Cantidad          = cantidadTraspaso,
                    Importe           = importe,
                    UsuarioCreacionID = info.Usuario.UsuarioID
                };
                almacenMovimientoDetalleBL.Crear(almacenMovimientoDetalleInfo);
            }
            info.ImporteTraspaso = importe;
            return(almacenMovimientoID);
        }
        /// <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);
            }
        }
Ejemplo n.º 9
0
        internal PremezclaDistribucionInfo GuardarPremezclaDistribucion(DistribucionDeIngredientesInfo distribucionIngredientes)
        {
            PremezclaDistribucionInfo distribucion = null;

            try
            {
                var  almacenMovimientoBl             = new AlmacenMovimientoBL();
                var  almacenInventarioLoteBl         = new AlmacenInventarioLoteBL();
                var  almacenInventarioBl             = new AlmacenInventarioBL();
                var  almacenMovimientoDetalleBl      = new AlmacenMovimientoDetalleBL();
                var  premezclaDistribucionDal        = new PremezclaDistribucionDAL();
                var  premezclaDistribucionDetalleDal = new PremezclaDistribucionDetalleDAL();
                var  premezclaDistribucionCostoDal   = new PremezclaDistribucionCostoDAL();
                long almacenMovimientoId             = 0;
                // Afectamos el inventario.
                using (var transaction = new TransactionScope())
                {
                    distribucion = premezclaDistribucionDal.GuardarPremezclaDistribucion(new PremezclaDistribucionInfo
                    {
                        ProveedorId       = distribucionIngredientes.Proveedor.ProveedorID,
                        Iva               = distribucionIngredientes.Iva,
                        ProductoId        = distribucionIngredientes.Producto.ProductoId,
                        CantidadExistente = distribucionIngredientes.CantidadTotal,
                        CostoUnitario     = distribucionIngredientes.CostoUnitario,
                        UsuarioCreacionId = distribucionIngredientes.UsuarioId,
                    });

                    distribucionIngredientes.PremezclaDistribucionID = distribucion.PremezclaDistribucionId;

                    distribucion.ListaPremezclaDistribucionCosto =
                        premezclaDistribucionCostoDal.GuardarPremezclaDistribucionCosto(distribucionIngredientes);

                    /* Se calcula el costo extra y se proratea entre las organizaciones*/
                    //decimal costoDeCostosPorOrganizacion = 0;
                    decimal importeCostoTotal = 0;

                    if (distribucionIngredientes.ListaOrganizaciones.Any())
                    {
                        importeCostoTotal = distribucionIngredientes.ListaPremezclaDistribucionCosto.Sum(c => c.Importe);
                    }

                    foreach (var distribucionorganizaciones in distribucionIngredientes.ListaOrganizaciones)
                    {
                        decimal porcentajeSurtido = distribucionIngredientes.CantidadTotal > 0 ?
                                                    (decimal)distribucionorganizaciones.CantidadSurtir / (decimal)distribucionIngredientes.CantidadTotal : 0;
                        if (distribucionorganizaciones.Lote.AlmacenInventarioLoteId != 0)
                        {
                            // Se Genera un movimiento de almacen
                            ////Insertar en almacenmovimiento
                            var almacenMovimientoInfo = new AlmacenMovimientoInfo
                            {
                                ProveedorId       = distribucionIngredientes.Proveedor.ProveedorID,
                                AlmacenID         = distribucionorganizaciones.Lote.AlmacenInventario.Almacen.AlmacenID,
                                TipoMovimientoID  = TipoMovimiento.EntradaAlmacen.GetHashCode(),
                                Observaciones     = "",
                                Status            = Estatus.AplicadoInv.GetHashCode(),
                                UsuarioCreacionID = distribucionIngredientes.UsuarioId
                            };
                            almacenMovimientoId = almacenMovimientoBl.Crear(almacenMovimientoInfo);

                            //Se crea el Almacen Movimiento Costo
                            GuardarCosto(distribucionIngredientes, almacenMovimientoId, distribucionorganizaciones);

                            // Se modifica el Almacen Inventario
                            distribucionorganizaciones.Lote.AlmacenInventario.Cantidad =
                                distribucionorganizaciones.Lote.AlmacenInventario.Cantidad + distribucionorganizaciones.CantidadSurtir;

                            distribucionorganizaciones.Lote.AlmacenInventario.Importe =
                                distribucionorganizaciones.Lote.AlmacenInventario.Importe + distribucionorganizaciones.CostoTotal + (importeCostoTotal * porcentajeSurtido);

                            distribucionorganizaciones.Lote.AlmacenInventario.PrecioPromedio = distribucionorganizaciones.Lote.AlmacenInventario.Importe / distribucionorganizaciones.Lote.AlmacenInventario.Cantidad;



                            distribucionorganizaciones.Lote.AlmacenInventario.UsuarioModificacionID =
                                distribucionIngredientes.UsuarioId;
                            almacenInventarioBl.Actualizar(distribucionorganizaciones.Lote.AlmacenInventario);

                            // Se modifica el Almacen Inventario Lote
                            distribucionorganizaciones.Lote.Cantidad =
                                distribucionorganizaciones.Lote.Cantidad + distribucionorganizaciones.CantidadSurtir;

                            distribucionorganizaciones.Lote.Importe = distribucionorganizaciones.Lote.Importe + distribucionorganizaciones.CostoTotal + (importeCostoTotal * porcentajeSurtido);

                            distribucionorganizaciones.Lote.PrecioPromedio = distribucionorganizaciones.Lote.Importe / distribucionorganizaciones.Lote.Cantidad;


                            distribucionorganizaciones.Lote.UsuarioModificacionId = distribucionIngredientes.UsuarioId;
                            almacenInventarioLoteBl.Actualizar(distribucionorganizaciones.Lote);

                            // Se genera el Almacen Movimiento Detalle
                            almacenMovimientoDetalleBl.Crear(new AlmacenMovimientoDetalle
                            {
                                AlmacenMovimientoID     = almacenMovimientoId,
                                AlmacenInventarioLoteId = distribucionorganizaciones.Lote.AlmacenInventarioLoteId,
                                Piezas            = 0,
                                ProductoID        = distribucionorganizaciones.Lote.AlmacenInventario.ProductoID,
                                Precio            = distribucionorganizaciones.CostoUnitario,
                                Cantidad          = distribucionorganizaciones.CantidadSurtir,
                                Importe           = distribucionorganizaciones.CostoTotal,
                                UsuarioCreacionID = distribucionIngredientes.UsuarioId,
                                FechaCreacion     = DateTime.Now
                            });

                            var premezclaDistribucionDetalle = premezclaDistribucionDetalleDal.GuardarPremezclaDistribucionDetalle(new PremezclaDistribucionDetalleInfo
                            {
                                AlmacenMovimientoId     = almacenMovimientoId,
                                PremezclaDistribucionId = distribucion.PremezclaDistribucionId,
                                CantidadASurtir         = distribucionorganizaciones.CantidadSurtir,
                                OrganizacionId          = distribucionorganizaciones.Organizacion.OrganizacionID,
                                UsuarioCreacionId       = distribucionIngredientes.UsuarioId
                            });
                            distribucion.ListaPremezclaDistribucionDetalle.Add(premezclaDistribucionDetalle);

                            foreach (var distribucionOrg in distribucionIngredientes
                                     .ListaOrganizaciones.Where(distribucionOrg =>
                                                                distribucionOrg.Organizacion.OrganizacionID == premezclaDistribucionDetalle.OrganizacionId))
                            {
                                distribucionOrg.AlmaceMovimiento = new AlmacenMovimientoInfo
                                {
                                    AlmacenMovimientoID = premezclaDistribucionDetalle.AlmacenMovimientoId
                                };
                            }
                        }
                    }

                    #region POLIZA

                    distribucionIngredientes.AlmaceMovimientoID = almacenMovimientoId;
                    var poliza = FabricaPoliza.ObtenerInstancia().ObtenerTipoPoliza(TipoPoliza.PolizaPremezcla);
                    distribucionIngredientes.FechaEntrada = DateTime.Now;
                    IList <PolizaInfo> polizas = poliza.GeneraPoliza(distribucionIngredientes);
                    if (polizas != null && polizas.Any())
                    {
                        var polizaBL       = new PolizaBL();
                        int organizacionID =
                            distribucionIngredientes.ListaOrganizaciones[0].Organizacion.OrganizacionID;
                        int usuarioCreacionID = distribucionIngredientes.UsuarioId;
                        polizas.ToList().ForEach(datos =>
                        {
                            datos.OrganizacionID         = organizacionID;
                            datos.UsuarioCreacionID      = usuarioCreacionID;
                            datos.ArchivoEnviadoServidor = 1;
                        });
                        polizaBL.GuardarServicioPI(polizas, TipoPoliza.PolizaPremezcla);
                    }

                    #endregion POLIZA
                    transaction.Complete();
                }

                return(distribucion);
            }
            catch (ExcepcionServicio ex)
            {
                Logger.Error(ex);
                throw;
            }
            catch (Exception ex)
            {
                Logger.Error(ex);
                throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
            }
        }
Ejemplo n.º 10
0
        /// <summary>
        /// Actualiza la recepcion de materia prima
        /// </summary>
        /// <param name="listaSurtido"></param>
        /// <param name="pedido"></param>
        /// <returns></returns>
        internal bool ActualizarRecepcionMateriaPrima(List <SurtidoPedidoInfo> listaSurtido, PedidoInfo pedido)
        {
            bool resultado;

            try
            {
                Logger.Info();
                var almacenInventarioBl     = new AlmacenInventarioBL();
                var almacenInventarioLoteBl = new AlmacenInventarioLoteBL();
                var almacenBl            = new AlmacenBL();
                var proveedorChofeBl     = new ProveedorChoferBL();
                int proveedorId          = 0;
                var pesajeMateriaPrimaBl = new PesajeMateriaPrimaBL();

                int                                  organizacionID;
                PolizaAbstract                       poliza;
                IList <PolizaInfo>                   polizas;
                IList <ResultadoPolizaModel>         resultadoPolizaModel;
                var                                  contenedorAlmacenesMovimientos = new List <ContenedorAlmacenMovimientoCierreDia>();
                ContenedorAlmacenMovimientoCierreDia contenedorAlmacenMovimiento;
                var                                  surtidoGenerarPoliza = new List <SurtidoPedidoInfo>();
                using (var transaction = new TransactionScope())
                {
                    ProgramacionMateriaPrimaInfo programacionMateriaPrima;
                    var programacionMateriaPrimaBL = new ProgramacionMateriaPrimaBL();
                    foreach (var surtidoTmp in listaSurtido)
                    {
                        if (surtidoTmp.Seleccionado)
                        {
                            programacionMateriaPrima = programacionMateriaPrimaBL.
                                                       ObtenerPorProgramacionMateriaPrimaTicket(
                                surtidoTmp.ProgramacionMateriaPrima.ProgramacionMateriaPrimaId,
                                surtidoTmp.PesajeMateriaPrima.Ticket);
                            if (programacionMateriaPrima != null)
                            {
                                continue;
                            }
                            surtidoGenerarPoliza.Add(surtidoTmp);

                            var pesaje = pesajeMateriaPrimaBl.ObtenerPorId(surtidoTmp.PesajeMateriaPrima);

                            // Se consulta el proveedor del Proveedor chofer seleccionado para el pesaje.
                            var proveedorChofeInfo = proveedorChofeBl.ObtenerProveedorChoferPorId(
                                surtidoTmp.PesajeMateriaPrima.ProveedorChoferID);

                            if (proveedorChofeInfo != null)
                            {
                                proveedorId = proveedorChofeInfo.Proveedor.ProveedorID;
                            }

                            //SE OBTIENEN LOS DATOS DEL LOTE DESTINO
                            var almacenInventarioLoteDestino =
                                almacenInventarioLoteBl.ObtenerAlmacenInventarioLotePorId(
                                    surtidoTmp.PedidoDetalle.InventarioLoteDestino.AlmacenInventarioLoteId);
                            //SE OBTIENEN LOS DATOS DEL LOTE ORIGEN
                            var almacenInventarioLoteOrigen =
                                almacenInventarioLoteBl.ObtenerAlmacenInventarioLotePorId(
                                    surtidoTmp.ProgramacionMateriaPrima.InventarioLoteOrigen
                                    .AlmacenInventarioLoteId);

                            #region  INVENTARIO ORIGEN

                            // GENERA MOVIMIENTO DE INVENTARIO
                            var almacenMovimiento = almacenBl.GuardarAlmacenMovimiento(new AlmacenMovimientoInfo
                            {
                                AlmacenID =
                                    almacenInventarioLoteOrigen
                                    .AlmacenInventario.
                                    AlmacenID,
                                TipoMovimientoID =
                                    (int)
                                    TipoMovimiento.
                                    PaseProceso,
                                Observaciones      = "",
                                Status             = (int)EstatusInventario.Aplicado,
                                AnimalMovimientoID = 0,
                                ProveedorId        = proveedorId,
                                UsuarioCreacionID  =
                                    pedido.
                                    UsuarioModificacion.
                                    UsuarioID
                            });

                            // SE LE ASIGNA EL MOVIMIENTO GENERADO AL PESAJE
                            pesaje.AlmacenMovimientoOrigenId = almacenMovimiento.AlmacenMovimientoID;
                            contenedorAlmacenMovimiento      = new ContenedorAlmacenMovimientoCierreDia
                            {
                                AlmacenMovimiento = new AlmacenMovimientoInfo
                                {
                                    AlmacenMovimientoID =
                                        almacenMovimiento.
                                        AlmacenMovimientoID
                                }
                            };
                            contenedorAlmacenesMovimientos.Add(contenedorAlmacenMovimiento);

                            // GENERA EL DETALLE DEL MOVIMIENTO
                            almacenBl.GuardarAlmacenMovimientoDetalleProducto(
                                new AlmacenMovimientoDetalle
                            {
                                AlmacenMovimientoID = almacenMovimiento.AlmacenMovimientoID,
                                ProductoID          = surtidoTmp.Producto.ProductoId,
                                Precio   = almacenInventarioLoteOrigen.PrecioPromedio,
                                Cantidad = surtidoTmp.CantidadEntregada,
                                Importe  =
                                    almacenInventarioLoteOrigen.PrecioPromedio * surtidoTmp.CantidadEntregada,
                                AlmacenInventarioLoteId =
                                    almacenInventarioLoteOrigen.AlmacenInventarioLoteId,
                                ContratoId        = 0,
                                Piezas            = surtidoTmp.PesajeMateriaPrima.Piezas,
                                UsuarioCreacionID = pedido.UsuarioModificacion.UsuarioID
                            });
                            // GENERA LA SALIDA DEL INVENTARIO LOTE
                            almacenInventarioLoteOrigen.Cantidad -= surtidoTmp.CantidadEntregada;
                            almacenInventarioLoteOrigen.Piezas   -= surtidoTmp.PesajeMateriaPrima.Piezas;
                            almacenInventarioLoteOrigen.Importe   = almacenInventarioLoteOrigen.PrecioPromedio *
                                                                    almacenInventarioLoteOrigen.Cantidad;
                            almacenInventarioLoteOrigen.UsuarioModificacionId =
                                pedido.UsuarioModificacion.UsuarioID;
                            almacenInventarioLoteBl.Actualizar(almacenInventarioLoteOrigen);

                            // GENERA LA SALIDA DEL ALMACEN INVENTARIO
                            var almacenInventarioInfo =
                                almacenInventarioBl.ObtenerAlmacenInventarioPorId(
                                    almacenInventarioLoteOrigen.AlmacenInventario.AlmacenInventarioID);
                            almacenInventarioInfo.Cantidad = almacenInventarioInfo.Cantidad -
                                                             surtidoTmp.CantidadEntregada;
                            almacenInventarioInfo.Importe = almacenInventarioInfo.PrecioPromedio *
                                                            almacenInventarioInfo.Cantidad;
                            almacenInventarioInfo.UsuarioModificacionID = pedido.UsuarioModificacion.UsuarioID;
                            almacenInventarioBl.Actualizar(almacenInventarioInfo);

                            #endregion

                            #region  INVENTARIO DESTINO
                            //Obtener costos de flete
                            var fleteInternoPl = new FleteInternoPL();
                            var listadoCostos  = fleteInternoPl.ObtenerCostosPorFleteConfiguracion(new FleteInternoInfo
                            {
                                Organizacion =
                                    new OrganizacionInfo {
                                    OrganizacionID = pedido.Organizacion.OrganizacionID
                                },
                                AlmacenOrigen = new AlmacenInfo {
                                    AlmacenID = almacenInventarioLoteOrigen.AlmacenInventario.AlmacenID
                                },
                                Producto = new ProductoInfo {
                                    ProductoId = surtidoTmp.Producto.ProductoId
                                }
                            }, new ProveedorInfo {
                                ProveedorID = surtidoTmp.Proveedor.ProveedorID
                            });

                            decimal importeCostos = 0;
                            if (listadoCostos != null)
                            {
                                foreach (var fleteInternoCostoInfo in listadoCostos)
                                {
                                    if (fleteInternoCostoInfo.TipoTarifaID == TipoTarifaEnum.Viaje.GetHashCode())
                                    {
                                        importeCostos += fleteInternoCostoInfo.Tarifa;
                                    }
                                    else
                                    {
                                        importeCostos += (surtidoTmp.CantidadEntregada / 1000) *
                                                         fleteInternoCostoInfo.Tarifa;
                                    }
                                }
                                //importeCostos = listadoCostos.Sum(fleteInternoCostoInfo => fleteInternoCostoInfo.Tarifa);
                            }

                            almacenMovimiento = almacenBl.GuardarAlmacenMovimiento(new AlmacenMovimientoInfo
                            {
                                AlmacenID =
                                    almacenInventarioLoteDestino
                                    .AlmacenInventario.
                                    AlmacenID,
                                TipoMovimientoID =
                                    (int)
                                    TipoMovimiento.
                                    RecepcionAProceso,
                                Observaciones =
                                    pedido.Observaciones,
                                Status             = (int)EstatusInventario.Aplicado,
                                AnimalMovimientoID = 0,
                                ProveedorId        = proveedorId,
                                UsuarioCreacionID  =
                                    pedido.
                                    UsuarioModificacion.
                                    UsuarioID
                            });

                            // SE LE ASIGNA EL MOVIMIENTO AL PESAJE
                            pesaje.AlmacenMovimientoDestinoId = almacenMovimiento.AlmacenMovimientoID;

                            // GENERA LA ENTRADA DEL INVENTARIO LOTE
                            almacenInventarioLoteDestino.Piezas += surtidoTmp.PesajeMateriaPrima.Piezas;
                            decimal importe = surtidoTmp.CantidadEntregada *
                                              almacenInventarioLoteOrigen.PrecioPromedio;
                            almacenInventarioLoteDestino.Importe       += importe;
                            almacenInventarioLoteDestino.Cantidad      += surtidoTmp.CantidadEntregada;
                            almacenInventarioLoteDestino.PrecioPromedio = almacenInventarioLoteDestino.Importe /
                                                                          almacenInventarioLoteDestino.Cantidad;
                            almacenInventarioLoteDestino.UsuarioModificacionId =
                                pedido.UsuarioModificacion.UsuarioID;
                            //
                            //Se agregan los costos al importe del lote
                            //importeCostos = importeCostos * surtidoTmp.CantidadEntregada;
                            almacenInventarioLoteDestino.Importe        = almacenInventarioLoteDestino.Importe + importeCostos;
                            almacenInventarioLoteDestino.PrecioPromedio = almacenInventarioLoteDestino.Importe /
                                                                          almacenInventarioLoteDestino.Cantidad;
                            //
                            almacenInventarioLoteBl.Actualizar(almacenInventarioLoteDestino);

                            // GENERA EL DETALLE DEL MOVIMIENTO
                            almacenBl.GuardarAlmacenMovimientoDetalleProducto(
                                new AlmacenMovimientoDetalle
                            {
                                AlmacenMovimientoID = almacenMovimiento.AlmacenMovimientoID,
                                ProductoID          = surtidoTmp.Producto.ProductoId,
                                Precio   = almacenInventarioLoteOrigen.PrecioPromedio,
                                Cantidad = surtidoTmp.CantidadEntregada,
                                Importe  = importe,
                                AlmacenInventarioLoteId =
                                    almacenInventarioLoteDestino.AlmacenInventarioLoteId,
                                ContratoId        = 0,
                                Piezas            = surtidoTmp.PesajeMateriaPrima.Piezas,
                                UsuarioCreacionID = pedido.UsuarioModificacion.UsuarioID
                            });

                            //Guarda almacen movimiento costo
                            if (listadoCostos != null)
                            {
                                foreach (var fleteInternoCostoInfo in listadoCostos)
                                {
                                    var     almacenMovimientoCosto = new AlmacenMovimientoCostoBL();
                                    decimal importeCostoFlete      = 0;

                                    if (fleteInternoCostoInfo.TipoTarifaID == TipoTarifaEnum.Viaje.GetHashCode())
                                    {
                                        importeCostoFlete = fleteInternoCostoInfo.Tarifa;
                                    }
                                    else
                                    {
                                        importeCostoFlete = (surtidoTmp.CantidadEntregada / 1000) *
                                                            fleteInternoCostoInfo.Tarifa;
                                    }

                                    almacenMovimientoCosto.Crear(new AlmacenMovimientoCostoInfo
                                    {
                                        AlmacenMovimientoId = almacenMovimiento.AlmacenMovimientoID,
                                        ProveedorId         = surtidoTmp.Proveedor.ProveedorID,
                                        CostoId             = fleteInternoCostoInfo.Costo.CostoID,
                                        Importe             = importeCostoFlete,
                                        Cantidad            = surtidoTmp.CantidadEntregada,
                                        Activo            = EstatusEnum.Activo,
                                        UsuarioCreacionId = pedido.UsuarioModificacion.UsuarioID
                                    });
                                }
                            }
                            //
                            programacionMateriaPrimaBL.ActualizarAlmacenMovimiento(
                                surtidoTmp.ProgramacionMateriaPrima.ProgramacionMateriaPrimaId,
                                almacenMovimiento.AlmacenMovimientoID);

                            // GENERA LA ENTRADA DEL ALMACEN INVENTARIO
                            almacenInventarioInfo =
                                almacenInventarioBl.ObtenerAlmacenInventarioPorId(
                                    almacenInventarioLoteDestino.AlmacenInventario.AlmacenInventarioID);

                            List <AlmacenInventarioLoteInfo> listaAlmacenInventarioLote =
                                almacenInventarioLoteBl.ObtenerPorAlmacenInventarioID(almacenInventarioInfo);

                            var almacenInventario = new AlmacenInventarioInfo();
                            almacenInventario.AlmacenInventarioID = almacenInventarioInfo.AlmacenInventarioID;
                            // SE SUMAN LAS CANTIDADES E IMPORTES QUE TIENE EL ALMACEN
                            foreach (var almacenInventarioLoteInfo in listaAlmacenInventarioLote)
                            {
                                almacenInventario.Cantidad += almacenInventarioLoteInfo.Cantidad;
                                almacenInventario.Importe  += almacenInventarioLoteInfo.Importe;
                            }

                            almacenInventario.PrecioPromedio = almacenInventario.Importe /
                                                               almacenInventario.Cantidad;

                            almacenInventario.UsuarioModificacionID = pedido.UsuarioModificacion.UsuarioID;
                            almacenInventario.ProductoID            = surtidoTmp.Producto.ProductoId;
                            almacenInventario.AlmacenID             =
                                almacenInventarioLoteDestino.AlmacenInventario.AlmacenID;
                            almacenInventarioBl.ActualizarPorProductoId(almacenInventario);

                            #endregion

                            // SE ACTUALIZA EL PESAJE DE MATERIA PRIMA
                            pesaje.EstatusID             = (int)Estatus.PedidoCompletado;
                            pesaje.Activo                = false;
                            pesaje.UsuarioModificacionID = pedido.UsuarioModificacion.UsuarioID;
                            pesajeMateriaPrimaBl.ActualizarPesajePorId(pesaje);
                        }
                    }

                    #region POLIZA

                    organizacionID = pedido.Organizacion.OrganizacionID;
                    string lotes = ObtenerXMLLote(listaSurtido);
                    var    pesajeMateriaPrimaBL = new PesajeMateriaPrimaBL();
                    List <PolizaPaseProcesoModel> datosPoliza =
                        pesajeMateriaPrimaBL.ObtenerValoresPolizaPaseProceso(pedido.FolioPedido, organizacionID,
                                                                             lotes);
                    if (datosPoliza != null)
                    {
                        datosPoliza = (from dp in datosPoliza
                                       from ls in surtidoGenerarPoliza
                                       where dp.Proveedor.ProveedorID == ls.Proveedor.ProveedorID &&
                                       dp.Producto.ProductoId == ls.Producto.ProductoId &&
                                       dp.PesajeMateriaPrima.Ticket == ls.PesajeMateriaPrima.Ticket
                                       select dp).ToList();
                    }
                    if (datosPoliza != null && datosPoliza.Any())
                    {
                        poliza = FabricaPoliza.ObtenerInstancia().ObtenerTipoPoliza(TipoPoliza.PaseProceso);
                        IList <PolizaPaseProcesoModel> polizasPaseProcesoModel;
                        resultadoPolizaModel = new List <ResultadoPolizaModel>();
                        datosPoliza          =
                            datosPoliza.GroupBy(prod => new { prod.Producto, prod.ProveedorChofer, prod.PesajeMateriaPrima.Ticket })
                            .Select(grupo => new PolizaPaseProcesoModel
                        {
                            Organizacion             = grupo.Select(org => org.Organizacion).FirstOrDefault(),
                            Almacen                  = grupo.Select(alm => alm.Almacen).FirstOrDefault(),
                            Producto                 = grupo.Key.Producto,
                            Proveedor                = grupo.Select(prov => prov.Proveedor).FirstOrDefault(),
                            AlmacenMovimiento        = grupo.Select(alm => alm.AlmacenMovimiento).FirstOrDefault(),
                            AlmacenMovimientoDetalle = grupo.Select(alm => alm.AlmacenMovimientoDetalle).FirstOrDefault(),
                            AlmacenInventarioLote    = grupo.Select(alm => alm.AlmacenInventarioLote).FirstOrDefault(),
                            FleteInterno             = grupo.Select(flete => flete.FleteInterno).FirstOrDefault(),
                            FleteInternoCosto        = grupo.Select(flete => flete.FleteInternoCosto).FirstOrDefault(),
                            Pedido                      = grupo.Select(ped => ped.Pedido).FirstOrDefault(),
                            ProveedorChofer             = grupo.Key.ProveedorChofer,
                            PesajeMateriaPrima          = grupo.Select(pesaje => pesaje.PesajeMateriaPrima).FirstOrDefault(),
                            ProgramacionMateriaPrima    = grupo.Select(prog => prog.ProgramacionMateriaPrima).FirstOrDefault(),
                            ListaAlmacenMovimientoCosto = grupo.Select(prog => prog.ListaAlmacenMovimientoCosto).FirstOrDefault(),
                        }).ToList();
                        IList <PolizaInfo> polizaExistente;
                        var polizaBL = new PolizaBL();
                        for (var indexPoliza = 0; indexPoliza < datosPoliza.Count; indexPoliza++)
                        {
                            polizasPaseProcesoModel = new List <PolizaPaseProcesoModel> {
                                datosPoliza[indexPoliza]
                            };
                            polizas = poliza.GeneraPoliza(polizasPaseProcesoModel);
                            if (polizas != null)
                            {
                                var resultadoPoliza = new ResultadoPolizaModel
                                {
                                    Polizas = polizas
                                };
                                polizas.ToList().ForEach(datos =>
                                {
                                    datos.OrganizacionID    = organizacionID;
                                    datos.UsuarioCreacionID =
                                        pedido.UsuarioModificacion.UsuarioID;
                                    datos.ArchivoEnviadoServidor = 1;
                                });
                                polizaExistente = polizaBL.ObtenerPoliza(TipoPoliza.PaseProceso, organizacionID,
                                                                         pedido.FechaPedido,
                                                                         string.Format("{0}-{1}", pedido.FolioPedido,
                                                                                       datosPoliza[indexPoliza].
                                                                                       PesajeMateriaPrima.Ticket),
                                                                         "PP", 1);
                                if (polizaExistente != null && polizaExistente.Any())
                                {
                                    List <PolizaInfo> excluir = (from existente in polizaExistente
                                                                 join guardar in polizas on existente.Concepto equals guardar.Concepto
                                                                 select guardar).ToList();
                                    polizas = polizas.Except(excluir).ToList();
                                }
                                if (polizas.Any())
                                {
                                    polizaBL.GuardarServicioPI(polizas, TipoPoliza.PaseProceso);
                                    resultadoPolizaModel.Add(resultadoPoliza);
                                }
                            }
                        }
                        var almacenMovimientoBL = new AlmacenMovimientoBL();
                        contenedorAlmacenesMovimientos.ForEach(alm => alm.Almacen = new AlmacenInfo
                        {
                            UsuarioModificacionID =
                                pedido.
                                UsuarioModificacion.
                                UsuarioID
                        });
                        almacenMovimientoBL.ActualizarGeneracionPoliza(contenedorAlmacenesMovimientos);
                    }

                    #endregion POLIZA

                    transaction.Complete();
                    resultado = true;
                }
            }
            catch (ExcepcionGenerica exg)
            {
                resultado = false;
                Logger.Error(exg);
            }
            catch (Exception ex)
            {
                resultado = false;
                Logger.Error(ex);
            }
            return(resultado);
        }
Ejemplo n.º 11
0
        /// <summary>
        /// Registra el envio de alimento de una organizacion a otra
        /// </summary>
        /// <param name="envioAlimento">Información del envio de alimento a guardar</param>
        /// <returns>Regresa una confirmación de registro del envio de alimento</returns>
        internal EnvioAlimentoInfo RegistrarEnvioAlimento(EnvioAlimentoInfo envioAlimento)
        {
            EnvioAlimentoInfo confirmacion = new EnvioAlimentoInfo();

            try
            {
                Logger.Info();
                AlmacenMovimientoBL almacenMovimientoBL = new AlmacenMovimientoBL();

                EnvioAlimentoDAL           salidaAlimentoDAL          = new EnvioAlimentoDAL();
                AlmacenMovimientoDetalleBL almacenMovimientoDetalleBl = new AlmacenMovimientoDetalleBL();
                AlmacenMovimientoDetalle   detalleMovimiento          = new AlmacenMovimientoDetalle();
                AlmacenInventarioBL        inventario = new AlmacenInventarioBL();
                AlmacenInventarioLoteBL    loteBl     = new AlmacenInventarioLoteBL();

                AlmacenMovimientoInfo almacenMovimiento = new AlmacenMovimientoInfo();
                almacenMovimiento.AlmacenID        = envioAlimento.Almacen.AlmacenID;
                almacenMovimiento.TipoMovimientoID = TipoMovimiento.ProductoSalidaTraspaso.GetHashCode();

                almacenMovimiento.Status                = Estatus.AplicadoInv.GetHashCode();
                almacenMovimiento.UsuarioCreacionID     = envioAlimento.UsuarioCreacionID;
                almacenMovimiento.UsuarioModificacionID = envioAlimento.UsuarioCreacionID;
                almacenMovimiento.EsEnvioAlimento       = true;
                almacenMovimiento.OrganizacionID        = envioAlimento.Origen.OrganizacionID;

                PolizaAbstract     poliza       = null;
                IList <PolizaInfo> listaPolizas = null;

                using (var transaccion = new TransactionScope())
                {
                    //registrar en TB AlmacenMovimiento
                    long almacenMovimientoID = almacenMovimientoBL.Crear(almacenMovimiento);
                    almacenMovimiento.AlmacenMovimientoID = almacenMovimientoID;
                    envioAlimento.AlmacenMovimientoId     = almacenMovimientoID;

                    if (envioAlimento.AlmacenMovimientoId == 0)
                    {
                        return new EnvioAlimentoInfo {
                                   EnvioId = 0
                        }
                    }
                    ;

                    //registrar en TB AlmacenMovimientoDetalle
                    detalleMovimiento.AlmacenMovimientoID = almacenMovimiento.AlmacenMovimientoID;
                    almacenMovimiento = almacenMovimientoBL.ObtenerPorId(almacenMovimiento.AlmacenMovimientoID);

                    if (almacenMovimiento.AlmacenMovimientoID == 0)
                    {
                        return new EnvioAlimentoInfo {
                                   EnvioId = 0
                        }
                    }
                    ;

                    envioAlimento.Folio        = almacenMovimiento.FolioMovimiento;
                    detalleMovimiento.Producto = envioAlimento.Producto;

                    if (detalleMovimiento.Producto.ManejaLote)
                    {
                        detalleMovimiento.AlmacenInventarioLoteId = envioAlimento.AlmacenInventario.ListaAlmacenInventarioLote.FirstOrDefault().AlmacenInventarioLoteId;

                        detalleMovimiento.Precio = envioAlimento.AlmacenInventario.ListaAlmacenInventarioLote.FirstOrDefault().PrecioPromedio;
                    }
                    else
                    {
                        detalleMovimiento.Precio = envioAlimento.AlmacenInventario.PrecioPromedio;
                    }

                    detalleMovimiento.ProductoID        = envioAlimento.Producto.ProductoId;
                    detalleMovimiento.Cantidad          = envioAlimento.Cantidad;
                    detalleMovimiento.Importe           = envioAlimento.Importe;
                    detalleMovimiento.UsuarioCreacionID = envioAlimento.UsuarioCreacionID;
                    detalleMovimiento.Piezas            = envioAlimento.Piezas;
                    int almacenMovimientoDetalleid = almacenMovimientoDetalleBl.Crear(detalleMovimiento);
                    if (almacenMovimientoDetalleid == 0)
                    {
                        return new EnvioAlimentoInfo {
                                   EnvioId = 0
                        }
                    }
                    ;

                    //registrar en TB EnvioProducto
                    confirmacion = salidaAlimentoDAL.RegistrarEnvioAlimento(envioAlimento);

                    if (confirmacion.EnvioId == 0)
                    {
                        return new EnvioAlimentoInfo {
                                   EnvioId = 0
                        }
                    }
                    ;

                    envioAlimento.EnvioId    = confirmacion.EnvioId;
                    envioAlimento.FechaEnvio = confirmacion.FechaEnvio;

                    envioAlimento.AlmacenInventario.Cantidad -= envioAlimento.Cantidad;
                    envioAlimento.AlmacenInventario.Importe  -= envioAlimento.Importe;
                    decimal precioPromedioInicial = 0M;
                    if (envioAlimento.Producto.ManejaLote)
                    {
                        precioPromedioInicial = envioAlimento.AlmacenInventario.ListaAlmacenInventarioLote.FirstOrDefault().PrecioPromedio;
                    }
                    else
                    {
                        precioPromedioInicial = envioAlimento.AlmacenInventario.PrecioPromedio;
                    }
                    if (envioAlimento.AlmacenInventario.Cantidad == 0)
                    {
                        envioAlimento.AlmacenInventario.PrecioPromedio = 0M;
                    }

                    if (envioAlimento.AlmacenInventario.Cantidad < 0)
                    {
                        envioAlimento.AlmacenInventario.Cantidad = 0;
                    }

                    if (envioAlimento.AlmacenInventario.Importe < 0)
                    {
                        envioAlimento.AlmacenInventario.Importe = 0;
                    }

                    if (envioAlimento.AlmacenInventario.Cantidad > 0 && envioAlimento.AlmacenInventario.Importe > 0)
                    {
                        envioAlimento.AlmacenInventario.PrecioPromedio = envioAlimento.AlmacenInventario.Importe / envioAlimento.AlmacenInventario.Cantidad;
                    }

                    envioAlimento.AlmacenInventario.UsuarioModificacionID = envioAlimento.UsuarioCreacionID;
                    inventario.ActualizarPorProductoId(envioAlimento.AlmacenInventario);

                    if (envioAlimento.Producto.ManejaLote)
                    {
                        FechaInfo fechaInfo = new FechaBL().ObtenerFechaActual();
                        envioAlimento.AlmacenInventario.ListaAlmacenInventarioLote.FirstOrDefault().Cantidad -= envioAlimento.Cantidad;
                        envioAlimento.AlmacenInventario.ListaAlmacenInventarioLote.FirstOrDefault().Importe  -= envioAlimento.Importe;

                        if (envioAlimento.AlmacenInventario.ListaAlmacenInventarioLote.FirstOrDefault().Cantidad <= 0)
                        {
                            envioAlimento.AlmacenInventario.ListaAlmacenInventarioLote.FirstOrDefault().PrecioPromedio = 0M;
                            envioAlimento.AlmacenInventario.ListaAlmacenInventarioLote.FirstOrDefault().Cantidad       = 0;
                            envioAlimento.AlmacenInventario.ListaAlmacenInventarioLote.FirstOrDefault().Importe        = 0;

                            envioAlimento.AlmacenInventario.ListaAlmacenInventarioLote.FirstOrDefault().FechaInicio = fechaInfo.FechaActual;
                        }

                        if (envioAlimento.AlmacenInventario.ListaAlmacenInventarioLote.FirstOrDefault().Importe > 0 && envioAlimento.AlmacenInventario.ListaAlmacenInventarioLote.FirstOrDefault().Cantidad > 0)
                        {
                            envioAlimento.AlmacenInventario.ListaAlmacenInventarioLote.FirstOrDefault().PrecioPromedio = envioAlimento.AlmacenInventario.ListaAlmacenInventarioLote.FirstOrDefault().Importe / envioAlimento.AlmacenInventario.ListaAlmacenInventarioLote.FirstOrDefault().Cantidad;
                        }
                        else
                        {
                            envioAlimento.AlmacenInventario.ListaAlmacenInventarioLote.FirstOrDefault().Activo   = EstatusEnum.Inactivo;
                            envioAlimento.AlmacenInventario.ListaAlmacenInventarioLote.FirstOrDefault().FechaFin = fechaInfo.FechaActual;
                        }

                        if (envioAlimento.Producto.SubfamiliaId == SubFamiliasEnum.Forrajes.GetHashCode())
                        {
                            envioAlimento.AlmacenInventario.ListaAlmacenInventarioLote.FirstOrDefault().Piezas -= envioAlimento.Piezas;
                            if (envioAlimento.AlmacenInventario.ListaAlmacenInventarioLote.FirstOrDefault().Piezas < 0)
                            {
                                envioAlimento.AlmacenInventario.ListaAlmacenInventarioLote.FirstOrDefault().Piezas = 0;
                            }
                        }

                        envioAlimento.AlmacenInventario.ListaAlmacenInventarioLote.FirstOrDefault().UsuarioModificacionId = envioAlimento.UsuarioCreacionID;
                        loteBl.ActualizarEnvioAlimento(envioAlimento.AlmacenInventario.ListaAlmacenInventarioLote.FirstOrDefault());
                    }

                    if (salidaAlimentoDAL.RegistrarRecepcionProductoEnc(envioAlimento, TipoMovimiento.ProductoSalidaTraspaso) == 0)
                    {
                        return new EnvioAlimentoInfo {
                                   EnvioId = 0
                        }
                    }
                    ;

                    if (salidaAlimentoDAL.RegistrarRecepcionProductoDet(envioAlimento, TipoMovimiento.ProductoSalidaTraspaso) == 0)
                    {
                        return new EnvioAlimentoInfo {
                                   EnvioId = 0
                        }
                    }
                    ;

                    poliza = FabricaPoliza.ObtenerInstancia().ObtenerTipoPoliza(TipoPoliza.SalidaTraspaso);

                    SolicitudProductoInfo oSolicitud = new SolicitudProductoInfo();
                    oSolicitud.FolioSolicitud    = envioAlimento.Folio;
                    oSolicitud.OrganizacionID    = envioAlimento.Origen.OrganizacionID;
                    oSolicitud.AlmacenGeneralID  = envioAlimento.Almacen.AlmacenID;
                    oSolicitud.Almacen           = new AlmacenBL().ObtenerAlmacenPorOrganizacion(envioAlimento.Destino.OrganizacionID).FirstOrDefault();
                    oSolicitud.FechaEntrega      = envioAlimento.FechaEnvio;
                    oSolicitud.UsuarioCreacionID = envioAlimento.UsuarioCreacionID;
                    oSolicitud.Detalle           = new List <SolicitudProductoDetalleInfo>();
                    SolicitudProductoDetalleInfo detalle = new SolicitudProductoDetalleInfo()
                    {
                        Cantidad       = envioAlimento.Cantidad,
                        PrecioPromedio = envioAlimento.Producto.ManejaLote ? envioAlimento.AlmacenInventario.ListaAlmacenInventarioLote.FirstOrDefault().PrecioPromedio: envioAlimento.AlmacenInventario.PrecioPromedio,
                        Producto       = envioAlimento.Producto
                    };
                    detalle.PrecioPromedio = decimal.Round(detalle.PrecioPromedio, 2);
                    if (detalle.PrecioPromedio == 0)
                    {
                        detalle.PrecioPromedio = precioPromedioInicial;
                    }
                    oSolicitud.Detalle.Add(detalle);

                    listaPolizas = poliza.GeneraPoliza(oSolicitud);
                    var polizaDAL = new PolizaDAL();
                    if (listaPolizas != null && listaPolizas.Any())
                    {
                        string Referencia = "03  " + envioAlimento.Folio.ToString() + new Random().Next(10, 20).ToString() + new Random().Next(30, 40) + DateTime.Now.Millisecond.ToString() + listaPolizas.ToList().FirstOrDefault().ClaseDocumento;
                        listaPolizas.ToList().ForEach(datos =>
                        {
                            datos.NumeroReferencia       = envioAlimento.Folio.ToString();
                            datos.OrganizacionID         = oSolicitud.OrganizacionID;
                            datos.UsuarioCreacionID      = envioAlimento.UsuarioCreacionID;
                            datos.Activo                 = EstatusEnum.Activo;
                            datos.ArchivoEnviadoServidor = 1;
                            datos.Referencia3            = Referencia;
                        });

                        ParametroOrganizacionInfo oParametroOrg = new ParametroOrganizacionBL().ObtenerPorOrganizacionIDClaveParametro(oSolicitud.OrganizacionID, ParametrosEnum.CuentaInventarioTransito.ToString());
                        if (oParametroOrg != null)
                        {
                            listaPolizas[listaPolizas.ToList().FindIndex(datos => datos.NumeroLinea.Trim() == "1")].Cuenta = oParametroOrg.Valor;
                        }

                        envioAlimento.Poliza = poliza.ImprimePoliza(oSolicitud, listaPolizas);
                        polizaDAL.CrearServicioPI(listaPolizas, TipoPoliza.SalidaTraspaso);

                        transaccion.Complete();
                    }
                }

                return(envioAlimento);
            }
            catch (Exception ex)
            {
                Logger.Error(ex);
                throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
            }
        }
Ejemplo n.º 12
0
        /// <summary>
        /// Se actualiza inventario y lote
        /// </summary>
        /// <param name="diferenciasDeInventariosInfo"></param>
        /// <param name="usuarioId"></param>
        internal void ActualizarInventarioYLote(DiferenciasDeInventariosInfo diferenciasDeInventariosInfo, int usuarioId)
        {
            var almacenInventarioBl     = new AlmacenInventarioBL();
            var almacenInventarioLoteBl = new AlmacenInventarioLoteBL();
            //Actualiza inventario
            //Obtenemos el inventario de acuerdo al almacen y producto obtenido
            var inventarioInfo = almacenInventarioBl.ObtenerPorAlmacenIdProductoId(new AlmacenInventarioInfo()
            {
                AlmacenID = diferenciasDeInventariosInfo.Almacen.AlmacenID, ProductoID = diferenciasDeInventariosInfo.Producto.ProductoId
            });

            if (inventarioInfo != null)
            {
                if (diferenciasDeInventariosInfo.AlmacenMovimiento.TipoMovimientoID ==
                    TipoMovimiento.SalidaPorAjuste.GetHashCode())
                {
                    inventarioInfo.Cantidad = inventarioInfo.Cantidad -
                                              diferenciasDeInventariosInfo.DiferenciaInventario;
                    inventarioInfo.Importe = inventarioInfo.PrecioPromedio * inventarioInfo.Cantidad;
                }
                if (diferenciasDeInventariosInfo.AlmacenMovimiento.TipoMovimientoID ==
                    TipoMovimiento.EntradaPorAjuste.GetHashCode())
                {
                    inventarioInfo.Cantidad = inventarioInfo.Cantidad +
                                              diferenciasDeInventariosInfo.DiferenciaInventario;
                    inventarioInfo.Importe = inventarioInfo.PrecioPromedio * inventarioInfo.Cantidad;
                }
                inventarioInfo.UsuarioModificacionID = usuarioId;
                //Actualiza inventario
                almacenInventarioBl.Actualizar(inventarioInfo);
            }

            //Actualiza inventario lote
            var almacenInventarioLoteInfo =
                almacenInventarioLoteBl.ObtenerAlmacenInventarioLotePorId(
                    diferenciasDeInventariosInfo.AlmacenInventarioLote.AlmacenInventarioLoteId);

            if (almacenInventarioLoteInfo != null)
            {
                if (diferenciasDeInventariosInfo.AlmacenMovimiento.TipoMovimientoID ==
                    TipoMovimiento.SalidaPorAjuste.GetHashCode())
                {
                    almacenInventarioLoteInfo.Cantidad = almacenInventarioLoteInfo.Cantidad -
                                                         diferenciasDeInventariosInfo.DiferenciaInventario;
                    almacenInventarioLoteInfo.Importe = almacenInventarioLoteInfo.PrecioPromedio * almacenInventarioLoteInfo.Cantidad;
                }
                if (diferenciasDeInventariosInfo.AlmacenMovimiento.TipoMovimientoID ==
                    TipoMovimiento.EntradaPorAjuste.GetHashCode())
                {
                    almacenInventarioLoteInfo.Cantidad = almacenInventarioLoteInfo.Cantidad +
                                                         diferenciasDeInventariosInfo.DiferenciaInventario;
                    almacenInventarioLoteInfo.Importe = almacenInventarioLoteInfo.PrecioPromedio * almacenInventarioLoteInfo.Cantidad;
                }
                almacenInventarioLoteInfo.UsuarioModificacionId = usuarioId;
                //Actualiza inventario
                almacenInventarioLoteBl.Actualizar(almacenInventarioLoteInfo);
                //Kilogramos teoricos en 0 se desactiva el lote
                //if (diferenciasDeInventariosInfo.KilogramosFisicos == 0)
                //{
                //    //Desactivar lote
                //    almacenInventarioLoteBl.DesactivarLote(almacenInventarioLoteInfo);
                //}
            }
        }
Ejemplo n.º 13
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);
            }
        }
Ejemplo n.º 14
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);
        }