コード例 #1
0
        /// <summary>
        /// Crear un nuevo lote en AlamcenInventarioLote
        /// </summary>
        private void CrearNuevoLote()
        {
            try
            {
                AlmacenInventarioLoteInfo almacenInventarioLote = null;

                int usuarioId = AuxConfiguracion.ObtenerUsuarioLogueado();
                var almacenInventarioLotePl = new AlmacenInventarioLotePL();
                var almacenInventarioPl     = new AlmacenInventarioPL();

                var almacenInventario = new AlmacenInventarioInfo
                {
                    AlmacenID  = Contexto.AlmacenDestino.AlmacenID,
                    ProductoID = Contexto.ProductoDestino.ProductoId
                };

                almacenInventario = almacenInventarioPl.ObtenerPorAlmacenIdProductoId(almacenInventario);

                // Si el producto no se encuentra en el almacen inventario, lo insertamos
                if (almacenInventario == null)
                {
                    almacenInventario = new AlmacenInventarioInfo
                    {
                        AlmacenInventarioID =
                            almacenInventarioPl.Crear(new AlmacenInventarioInfo
                        {
                            AlmacenID         = Contexto.AlmacenDestino.AlmacenID,
                            ProductoID        = Contexto.ProductoDestino.ProductoId,
                            UsuarioCreacionID = usuarioId
                        }),
                        AlmacenID = Contexto.AlmacenDestino.AlmacenID
                    };
                }

                int loteIdCreado = almacenInventarioLotePl.Crear(new AlmacenInventarioLoteInfo
                {
                    AlmacenInventarioLoteId = 0,
                    AlmacenInventario       =
                        new AlmacenInventarioInfo {
                        AlmacenInventarioID = almacenInventario.AlmacenInventarioID
                    },
                    Cantidad          = 0,
                    PrecioPromedio    = 0,
                    Piezas            = 0,
                    Importe           = 0,
                    Activo            = EstatusEnum.Activo,
                    UsuarioCreacionId = usuarioId,
                }, new AlmacenInventarioInfo
                {
                    AlmacenID  = almacenInventario.AlmacenID,
                    ProductoID = Contexto.ProductoDestino.ProductoId
                });

                almacenInventarioLote = almacenInventarioLotePl.ObtenerAlmacenInventarioLotePorId(loteIdCreado);


                Contexto.LoteMpDestino         = almacenInventarioLote;
                skAyudaLoteMPDestino.IsEnabled = false;
            }
            catch (Exception ex)
            {
                Logger.Error(ex);
                SkMessageBox.Show(Application.Current.Windows[ConstantesVista.WindowPrincipal],
                                  Properties.Resources.TraspasoMPPAMED_ErrorCrearLote, MessageBoxButton.OK,
                                  MessageImage.Error);
            }
        }
コード例 #2
0
        /// <summary>
        /// Guarda los datos para un gasto materia prima
        /// </summary>
        /// <param name="gasto"></param>
        /// <returns></returns>
        internal long Guardar(GastoMateriaPrimaInfo gasto)
        {
            long folioGasto = 0;

            try
            {
                Logger.Info();
                IList <PolizaInfo> polizas;
                PolizaAbstract     poliza;
                using (var transaction = new TransactionScope())
                {
                    var tipoOrg = gasto.Organizacion.TipoOrganizacion.TipoOrganizacionID;
                    var gastoMateriaPrimaDal = new GastoMateriaPrimaDAL();

                    if (gasto.GuardaAretes)
                    {
                        gastoMateriaPrimaDal.GuardarAretes(gasto);
                    }

                    if (tipoOrg == TipoOrganizacion.Centro.GetHashCode() || tipoOrg == TipoOrganizacion.Cadis.GetHashCode() || tipoOrg == TipoOrganizacion.Descanso.GetHashCode())
                    {
                        #region CENTROS

                        gasto.TipoFolio           = TipoFolio.GastoMateriaPrima;
                        gasto.AlmacenMovimientoID = null;
                        folioGasto = gastoMateriaPrimaDal.Guardar(gasto);

                        #endregion CENTROS
                    }
                    else
                    {
                        #region SIAP

                        #region MOVIMIENTOS

                        var listaAlmacenDetalle = new List <AlmacenMovimientoDetalle>();

                        var almacenMovimiento = new AlmacenMovimientoInfo
                        {
                            AlmacenID         = gasto.AlmacenID,
                            TipoMovimientoID  = gasto.TipoMovimiento.TipoMovimientoID,
                            ProveedorId       = gasto.Proveedor.ProveedorID,
                            Observaciones     = gasto.Observaciones,
                            Status            = (int)EstatusInventario.Aplicado,
                            UsuarioCreacionID = gasto.UsuarioCreacionID
                        };
                        var almacenMovimientoBl = new AlmacenMovimientoBL();
                        var almacenMovimientoID = almacenMovimientoBl.Crear(almacenMovimiento);
                        gasto.AlmacenMovimientoID = almacenMovimientoID;

                        var almacenMovimientoDetalle = new AlmacenMovimientoDetalle
                        {
                            AlmacenMovimientoID = almacenMovimientoID,
                            ProductoID          = gasto.Producto.ProductoId,
                            UsuarioCreacionID   = gasto.UsuarioCreacionID,
                            Importe             = gasto.Importe,
                            Cantidad            = 0,
                            Precio = 0
                        };
                        if (gasto.UnidadMedida)
                        {
                            almacenMovimientoDetalle.Cantidad = gasto.Kilogramos;
                            if (gasto.Kilogramos > 0)
                            {
                                almacenMovimientoDetalle.Precio = gasto.Importe / gasto.Kilogramos;
                            }
                            else
                            {
                                almacenMovimientoDetalle.Precio = 0;
                            }
                        }
                        gasto.TipoFolio = TipoFolio.GastoMateriaPrima;
                        int gastoMateriaPrimaID = gastoMateriaPrimaDal.Guardar(gasto);
                        //Actualizamos en AlmacenInventarioLote
                        if (gasto.AlmacenInventarioLote.AlmacenInventarioLoteId != 0)
                        {
                            almacenMovimientoDetalle.AlmacenInventarioLoteId =
                                gasto.AlmacenInventarioLote.AlmacenInventarioLoteId;

                            var almacenInventarioLote     = new AlmacenInventarioLoteDAL();
                            var almacenInventarioLoteInfo = new AlmacenInventarioLoteInfo();
                            almacenInventarioLoteInfo =
                                almacenInventarioLote.ObtenerAlmacenInventarioLotePorId(
                                    gasto.AlmacenInventarioLote.AlmacenInventarioLoteId);
                            almacenInventarioLoteInfo.UsuarioModificacionId = gasto.UsuarioCreacionID;
                            if (gasto.TipoMovimiento.TipoMovimientoID == (int)TipoMovimiento.EntradaPorAjuste)
                            {
                                almacenInventarioLoteInfo.Importe  += gasto.Importe;
                                almacenInventarioLoteInfo.Cantidad += gasto.Kilogramos;
                            }
                            else // Salida por Ajuste
                            {
                                almacenInventarioLoteInfo.Importe  -= gasto.Importe;
                                almacenInventarioLoteInfo.Cantidad -= gasto.Kilogramos;
                            }
                            if (almacenInventarioLoteInfo.Cantidad == 0)
                            {
                                almacenInventarioLoteInfo.PrecioPromedio = 0;
                            }
                            else
                            {
                                almacenInventarioLoteInfo.PrecioPromedio = almacenInventarioLoteInfo.Importe /
                                                                           almacenInventarioLoteInfo.Cantidad;
                            }
                            almacenInventarioLote.Actualizar(almacenInventarioLoteInfo);
                        }
                        // Actualizamos en AlmacenInventario
                        var almacenInventario     = new AlmacenInventarioDAL();
                        var almacenInventarioInfo = new AlmacenInventarioInfo
                        {
                            AlmacenID  = gasto.AlmacenID,
                            ProductoID = gasto.Producto.ProductoId
                        };
                        almacenInventarioInfo = almacenInventario.ObtenerPorAlmacenIdProductoId(almacenInventarioInfo);
                        if (gasto.TipoMovimiento.TipoMovimientoID == (int)TipoMovimiento.EntradaPorAjuste)
                        {
                            almacenInventarioInfo.Importe  += gasto.Importe;
                            almacenInventarioInfo.Cantidad += gasto.Kilogramos;
                            gasto.EsEntrada = true;
                        }
                        else // Salida por Ajuste
                        {
                            almacenInventarioInfo.Importe  -= gasto.Importe;
                            almacenInventarioInfo.Cantidad -= gasto.Kilogramos;
                        }
                        almacenInventarioInfo.UsuarioModificacionID = gasto.UsuarioCreacionID;
                        if (almacenInventarioInfo.Cantidad == 0)
                        {
                            almacenInventarioInfo.PrecioPromedio = 0;
                        }
                        else
                        {
                            almacenInventarioInfo.PrecioPromedio = almacenInventarioInfo.Importe / almacenInventarioInfo.Cantidad;
                        }
                        almacenInventario.Actualizar(almacenInventarioInfo);

                        listaAlmacenDetalle.Add(almacenMovimientoDetalle);
                        var almacenMovimientoDetalleBL = new AlmacenMovimientoDetalleBL();
                        almacenMovimientoDetalleBL.GuardarAlmacenMovimientoDetalle(listaAlmacenDetalle, almacenMovimientoID);

                        #endregion MOVIMIENTOS

                        #region POLIZA

                        GastoMateriaPrimaInfo gastoMateriaGuardado = gastoMateriaPrimaDal.ObtenerPorID(gastoMateriaPrimaID);

                        gasto.Fecha      = gastoMateriaGuardado.Fecha;
                        gasto.FolioGasto = gastoMateriaGuardado.FolioGasto;
                        folioGasto       = gastoMateriaGuardado.FolioGasto;
                        poliza           = FabricaPoliza.ObtenerInstancia().ObtenerTipoPoliza(TipoPoliza.GastosMateriaPrima);
                        polizas          = poliza.GeneraPoliza(gasto);
                        if (polizas != null && polizas.Any())
                        {
                            polizas.ToList().ForEach(datos =>
                            {
                                datos.OrganizacionID         = gasto.Organizacion.OrganizacionID;
                                datos.UsuarioCreacionID      = gasto.UsuarioCreacionID;
                                datos.ArchivoEnviadoServidor = 1;
                            });
                            var polizaBL = new PolizaBL();
                            if (gasto.EsEntrada)
                            {
                                polizaBL.GuardarServicioPI(polizas, TipoPoliza.EntradaAjuste);
                            }
                            else
                            {
                                polizaBL.GuardarServicioPI(polizas, TipoPoliza.SalidaAjuste);
                            }
                        }

                        #endregion POLIZA

                        #endregion SIAP
                    }

                    transaction.Complete();
                }
                return(folioGasto);
            }
            catch (ExcepcionServicio ex)
            {
                Logger.Error(ex);
                throw;
            }
            catch (ExcepcionGenerica)
            {
                throw;
            }
            catch (Exception ex)
            {
                Logger.Error(ex);
                throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
            }
        }
コード例 #3
0
 /// <summary>
 /// Obtiene los parametros para consultar por almaceninventarioid
 /// </summary>
 /// <param name="almacenInventario"></param>
 /// <returns></returns>
 internal static Dictionary <string, object> ObtenerParametroObtenerPorAlmacenInventarioID(AlmacenInventarioInfo almacenInventario)
 {
     try
     {
         Logger.Info();
         var parametros =
             new Dictionary <string, object>
         {
             { "@AlmacenInventarioID", almacenInventario.AlmacenInventarioID }
         };
         return(parametros);
     }
     catch (Exception ex)
     {
         Logger.Error(ex);
         throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
     }
 }
コード例 #4
0
 /// <summary>
 /// Obtiene los parametros para insertar un registro almacen inventario lote
 /// </summary>
 /// <param name="almacenInventarioLoteInfo"></param>
 /// <param name="almacenInventarioInfo"></param>
 /// <returns></returns>
 internal static Dictionary <string, object> ObtenerParametrosCrear(AlmacenInventarioLoteInfo almacenInventarioLoteInfo, AlmacenInventarioInfo almacenInventarioInfo)
 {
     try
     {
         Logger.Info();
         var parametros =
             new Dictionary <string, object>
         {
             { "@AlmacenInventarioID", almacenInventarioLoteInfo.AlmacenInventario.AlmacenInventarioID },
             { "@Cantidad", almacenInventarioLoteInfo.Cantidad },
             { "@PrecioPromedio", almacenInventarioLoteInfo.PrecioPromedio },
             { "@Piezas", almacenInventarioLoteInfo.Piezas },
             { "@Importe", almacenInventarioLoteInfo.Importe },
             { "@Activo", almacenInventarioLoteInfo.Activo.GetHashCode() },
             { "@UsuarioCreacionID", almacenInventarioLoteInfo.UsuarioCreacionId },
             { "@AlmacenID", almacenInventarioInfo.AlmacenID },
             { "@ProductoID", almacenInventarioInfo.ProductoID }
         };
         return(parametros);
     }
     catch (Exception ex)
     {
         Logger.Error(ex);
         throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
     }
 }
コード例 #5
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);
            }
        }
コード例 #6
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);
        }
コード例 #7
0
        /// <summary>
        /// Obtener inventario por almacenid, productoid
        /// </summary>
        /// <param name="almacenInventarioInfo"></param>
        /// <returns></returns>
        internal AlmacenInventarioInfo ObtenerPorOrganizacionIdAlmacenIdProductoIdParaPlantaCentroCadisDesc(AlmacenInventarioInfo almacenInventarioInfo, int organizacionId)
        {
            AlmacenInventarioInfo result;

            try
            {
                var almacenDal = new AlmacenInventarioDAL();
                result = almacenDal.ObtenerPorOrganizacionIdAlmacenIdProductoIdParaPlantaCentroCadisDesc(almacenInventarioInfo, organizacionId);
            }
            catch (Exception ex)
            {
                Logger.Error(ex);
                throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
            }
            return(result);
        }
コード例 #8
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);
            }
        }
コード例 #9
0
 /// <summary>
 /// Obtiene inventario por almacen y producto
 /// </summary>
 /// <param name="almacenInventarioInfo"></param>
 /// <returns></returns>
 internal AlmacenInventarioInfo ObtenerPorOrganizacionIdAlmacenIdProductoIdParaPlantaCentroCadisDesc(AlmacenInventarioInfo almacenInventarioInfo, int organizacionId)
 {
     try
     {
         Logger.Info();
         var parameters = AuxAlmacenInventarioDAL.ObtenerParametrosObtenerPorOrganizacionIDAlmacenIdProductoId(almacenInventarioInfo, organizacionId);
         var ds         = Retrieve("AlmacenInventario_ObtenerPorOrganizacionIdAlmacenIDProductoIDCentroCadisDesc", parameters);
         AlmacenInventarioInfo result = null;
         if (ValidateDataSet(ds))
         {
             result = MapAlmacenInventarioDAL.ObtenerAlmacenInventarioId(ds);
         }
         return(result);
     }
     catch (SqlException ex)
     {
         Logger.Error(ex);
         throw new ExcepcionServicio(MethodBase.GetCurrentMethod(), ex);
     }
     catch (DataException ex)
     {
         Logger.Error(ex);
         throw new ExcepcionServicio(MethodBase.GetCurrentMethod(), ex);
     }
     catch (Exception ex)
     {
         Logger.Error(ex);
         throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
     }
 }
コード例 #10
0
        /// <summary>
        /// Genera la carga inicial de los inventarios
        /// </summary>
        /// <param name="cargaInventarios"></param>
        /// <returns></returns>
        public void GenerarCargaInicial(List <CargaMPPAModel> cargaInventarios)
        {
            try
            {
                var almacenInventarioBL     = new AlmacenInventarioBL();
                var almacenInventarioLoteBL = new AlmacenInventarioLoteBL();
                var fechaBL = new FechaBL();

                FechaInfo fechaActual = fechaBL.ObtenerFechaActual();

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

                        var almacenInventario = almacenInventarioBL.ObtenerPorAlmacenIdProductoId(almacenInventarioFiltro);

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

                        var almacenInventarioLote = new AlmacenInventarioLoteInfo();

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

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

                    transaction.Complete();
                }
            }
            catch (ExcepcionGenerica)
            {
                throw;
            }
            catch (Exception ex)
            {
                Logger.Error(ex);
                throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
            }
        }
コード例 #11
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);
        }
コード例 #12
0
        public static AlmacenInventarioLoteInfo ObtenerNuevoLoteMateriaPrima(int productoId, string tipoalmacen)
        {
            try
            {
                var seguridad = HttpContext.Current.Session["Seguridad"] as SeguridadInfo;
                int organizacionId = 0, usuarioId = 0, tipoAlmacen = 0;

                AlmacenInventarioLoteInfo almacenInventarioLote = null;

                if (seguridad != null)
                {
                    organizacionId = seguridad.Usuario.Organizacion.OrganizacionID;
                    usuarioId      = seguridad.Usuario.UsuarioID;
                }

                switch (tipoalmacen)
                {
                case "rbLoteAlmacen":
                    tipoAlmacen = (int)TipoAlmacenEnum.MateriasPrimas;
                    break;

                case "rbLoteProceso":
                    tipoAlmacen = (int)TipoAlmacenEnum.PlantaDeAlimentos;
                    break;

                case "rbBodegaExterna":
                    tipoAlmacen = (int)TipoAlmacenEnum.BodegaExterna;
                    break;
                }

                var almacenInventarioLotePl = new AlmacenInventarioLotePL();
                var almacenPl               = new AlmacenPL();
                var almacenInventarioPl     = new AlmacenInventarioPL();

                var almacenInventario =
                    almacenPl.ObtenerAlmacenInventarioPorOrganizacionTipoAlmacen(new ParametrosOrganizacionTipoAlmacenProductoActivo
                {
                    OrganizacionId = organizacionId,
                    TipoAlmacenId  = tipoAlmacen,
                    Activo         = (int)EstatusEnum.Activo,
                    ProductoId     = productoId
                });

                // Si el producto no se encuentra en el almacen inventario, lo insertamos
                if (almacenInventario == null)
                {
                    var listaAlmacenOrganizacion = almacenPl.ObtenerAlmacenPorOrganizacion(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 en pantalla
                            if (almacenInfo.TipoAlmacen.TipoAlmacenID == tipoAlmacen)
                            {
                                almacenInventario = new AlmacenInventarioInfo
                                {
                                    AlmacenInventarioID =
                                        almacenInventarioPl.Crear(new AlmacenInventarioInfo
                                    {
                                        AlmacenID         = almacenInfo.AlmacenID,
                                        ProductoID        = productoId,
                                        UsuarioCreacionID = usuarioId
                                    }),
                                    AlmacenID = almacenInfo.AlmacenID
                                };
                                break;
                            }
                        }
                    }
                }

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

                    almacenInventarioLote = almacenInventarioLotePl.ObtenerAlmacenInventarioLotePorId(loteIdCreado);
                }

                return(almacenInventarioLote);
            }
            catch (Exception ex)
            {
                Logger.Error(ex);
                throw new SystemException(ex.Message);
            }
        }
コード例 #13
0
        /// <summary>
        /// Obtiene una lista de almaceninventariolote
        /// </summary>
        /// <param name="almacenInventario"></param>
        /// <returns></returns>
        internal List <AlmacenInventarioLoteInfo> ObtenerPorAlmacenInventarioIDLigero(AlmacenInventarioInfo almacenInventario)
        {
            List <AlmacenInventarioLoteInfo> almacenInventarioLote;

            try
            {
                var almacenDAL = new AlmacenInventarioLoteDAL();
                almacenInventarioLote = almacenDAL.ObtenerPorAlmacenInventarioID(almacenInventario);
            }
            catch (Exception ex)
            {
                Logger.Error(ex);
                throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
            }

            return(almacenInventarioLote);
        }
コード例 #14
0
 /// <summary>
 /// Obtiene parametros para obtener inventario por almacenid y productoid
 /// </summary>
 /// <param name="almacenInventarioInfo"></param>
 /// <returns></returns>
 internal static Dictionary <string, object> ObtenerPorOrganizacionIdAlmacenIdProductoIdParaPlantaCentroCadisDesc(AlmacenInventarioInfo almacenInventarioInfo, int OrganizacionId)
 {
     try
     {
         Logger.Info();
         var parametros =
             new Dictionary <string, object>
         {
             { "@ProductoID", almacenInventarioInfo.ProductoID },
             { "@Activo", EstatusEnum.Activo.GetHashCode() },
             { "@OrganizacionId", OrganizacionId }
         };
         return(parametros);
     }
     catch (Exception ex)
     {
         Logger.Error(ex);
         throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
     }
 }
コード例 #15
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);
        }
コード例 #16
0
 /// <summary>
 /// Obtener parametros para obtener actualizar almacen inventario
 /// </summary>
 /// <param name="almacenInventarioInfo"></param>
 /// <returns></returns>
 public static Dictionary <string, object> ObtenerParametrosActualizarAlmacenInventario(AlmacenInventarioInfo almacenInventarioInfo)
 {
     try
     {
         Logger.Info();
         var parametros =
             new Dictionary <string, object>
         {
             { "@AlmacenInventarioID", almacenInventarioInfo.AlmacenInventarioID },
             { "@Cantidad", almacenInventarioInfo.Cantidad },
             { "@Importe", almacenInventarioInfo.Importe },
             { "@UsuarioModificacionID", almacenInventarioInfo.UsuarioModificacionID }
         };
         return(parametros);
     }
     catch (Exception ex)
     {
         Logger.Error(ex);
         throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
     }
 }
コード例 #17
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);
        }
コード例 #18
0
        /// <summary>
        /// Valida si el stock actual no cubre el envio que se intenta registrar
        /// </summary>
        /// <returns>Regresa True si la canidad de envio excede el inventario actual</returns>
        private bool ValidarSalidaExcede(out string error)
        {
            AlmacenInventarioPL   almacenInventarioPL   = new AlmacenInventarioPL();
            AlmacenInventarioInfo inventarioActualizado = almacenInventarioPL.ObtenerPorAlmacenIdProductoId(EnvioAlimento.AlmacenInventario);

            if (EnvioAlimento.Producto.ManejaLote)
            {
                AlmacenInventarioLotePL   inventarioLotePL = new AlmacenInventarioLotePL();
                AlmacenInventarioLoteInfo loteActual       = inventarioLotePL.ObtenerAlmacenInventarioLotePorId(EnvioAlimento.AlmacenInventario.ListaAlmacenInventarioLote.FirstOrDefault().AlmacenInventarioLoteId);

                if (loteActual.Cantidad == 0)
                {
                    error = Properties.Resources.EnvioAlimento_MsgProductoSinInventario;
                    LimpiarProducto();
                    this.EnvioAlimento.Producto = new ProductoInfo {
                        ProductoId = 0, SubfamiliaId = (int)this.cmbSubFamilia.SelectedValue
                    };
                    cmbAlmacen.ItemsSource = new List <AlmacenInfo>();
                    this.skAyudaProducto.LimpiarCampos();
                    cmbAlmacen.IsEnabled = false;
                    this.skAyudaProducto.LimpiarCampos();
                    this.skAyudaProducto.txtClave.Focus();

                    txtCantidadEnvio.Text      = string.Empty;
                    txtPrecioPromedio.Text     = string.Empty;
                    txtCantidadInventario.Text = string.Empty;
                    return(true);
                }

                if ((loteActual.Cantidad - decimal.Parse(txtCantidadEnvio.Text)) < 0)
                {
                    error = Properties.Resources.EnvioAlimento_MsgCantidadInventarioNegativo;
                    LimpiarProducto();
                    txtCantidadEnvio.Text      = string.Empty;
                    txtPrecioPromedio.Text     = string.Empty;
                    txtCantidadInventario.Text = string.Empty;
                    return(true);
                }
                error = string.Empty;
                return(false);
            }
            else
            {
                if (inventarioActualizado.Cantidad == 0)
                {
                    error = Properties.Resources.EnvioAlimento_MsgProductoSinInventario;
                    LimpiarProducto();
                    this.skAyudaProducto.LimpiarCampos();
                    this.skAyudaProducto.txtClave.Focus();

                    txtCantidadEnvio.Text      = string.Empty;
                    txtPrecioPromedio.Text     = string.Empty;
                    txtCantidadInventario.Text = string.Empty;
                    return(true);
                }

                if (((inventarioActualizado.Cantidad - decimal.Parse(txtCantidadEnvio.Text.Trim())) < 0))
                {
                    error = Properties.Resources.EnvioAlimento_MsgCantidadInventarioNegativo;
                    LimpiarProducto();
                    txtCantidadEnvio.Text      = string.Empty;
                    txtPrecioPromedio.Text     = string.Empty;
                    txtCantidadInventario.Text = string.Empty;
                    return(true);
                }
                else
                {
                    error = string.Empty;
                    return(false);
                }
            }
        }
コード例 #19
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);
        }