예제 #1
0
        /// <summary>
        /// Obtiene un flujo de datos
        /// para la generacion de la reimpresion
        /// de la poliza de pase a proceso
        /// </summary>
        /// <param name="pedidoInfo"></param>
        /// <param name="polizaClave"></param>
        /// <returns></returns>
        private IList <ResultadoPolizaModel> ReimpresionPolizaPaseProceso(PedidoInfo pedidoInfo, TipoPolizaInfo polizaClave)
        {
            var polizaBL = new PolizaBL();
            IList <PolizaInfo> polizasVenta = polizaBL.ObtenerPoliza(TipoPoliza.PaseProceso,
                                                                     pedidoInfo.Organizacion.OrganizacionID,
                                                                     pedidoInfo.FechaPedido,
                                                                     pedidoInfo.FolioPedido.ToString(),
                                                                     polizaClave.ClavePoliza, 1);
            IList <ResultadoPolizaModel> resultadoPolizaModel = null;

            if (polizasVenta != null)
            {
                List <int> foliosPedidos = new List <int>();
                foreach (var polizaventas in polizasVenta)
                {
                    //PP-348-1 22,350  COSTOS
                    int indiceFolio = 1;
                    var conceptos   = polizaventas.Concepto.Split('-');

                    int folio;
                    int.TryParse(conceptos[indiceFolio], out folio);
                    if (folio > 0)
                    {
                        foliosPedidos.Add(folio);
                    }
                }
                foliosPedidos        = foliosPedidos.Distinct().ToList();
                resultadoPolizaModel = new List <ResultadoPolizaModel>();
                foreach (var folio in foliosPedidos)
                {
                    var poliza = FabricaPoliza.ObtenerInstancia().ObtenerTipoPoliza(TipoPoliza.PaseProceso);
                    var pesajeMateriaPrimaBL = new PesajeMateriaPrimaBL();
                    List <PolizaPaseProcesoModel> datosPoliza =
                        pesajeMateriaPrimaBL.ObtenerValoresPolizaPaseProcesoReimpresion(folio,
                                                                                        pedidoInfo.Organizacion.
                                                                                        OrganizacionID);
                    if (datosPoliza != null && datosPoliza.Any())
                    {
                        IList <PolizaPaseProcesoModel> polizasPaseProcesoModel;


                        datosPoliza =
                            datosPoliza.GroupBy(
                                prod => new { prod.Producto.ProductoId, prod.ProveedorChofer.ProveedorChoferID, prod.PesajeMateriaPrima.Ticket })
                            .Select(grupo => new PolizaPaseProcesoModel
                        {
                            Organizacion =
                                grupo.Select(org => org.Organizacion).FirstOrDefault(),
                            Almacen           = grupo.Select(alm => alm.Almacen).FirstOrDefault(),
                            Producto          = grupo.Select(pro => pro.Producto).FirstOrDefault(),
                            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.Select(prov => prov.ProveedorChofer).FirstOrDefault(),
                            PesajeMateriaPrima =
                                grupo.Select(pesaje => pesaje.PesajeMateriaPrima).
                                FirstOrDefault(),
                            ProgramacionMateriaPrima =
                                grupo.Select(prog => prog.ProgramacionMateriaPrima).
                                FirstOrDefault(),
                            ListaAlmacenMovimientoCosto = grupo.Select(prog => prog.ListaAlmacenMovimientoCosto).
                                                          FirstOrDefault(),
                        }).OrderBy(ticket => ticket.PesajeMateriaPrima.Ticket).ToList();
                        for (int indexPoliza = 0; indexPoliza < datosPoliza.Count; indexPoliza++)
                        {
                            polizasPaseProcesoModel = new List <PolizaPaseProcesoModel> {
                                datosPoliza[indexPoliza]
                            };
                            polizasVenta = poliza.GeneraPoliza(polizasPaseProcesoModel);
                            MemoryStream stream = poliza.ImprimePoliza(polizasPaseProcesoModel, polizasVenta);

                            PolizaPaseProcesoModel polizaActual = polizasPaseProcesoModel.FirstOrDefault();
                            string nomenclaturaArchivo          = string.Empty;
                            if (polizaActual != null)
                            {
                                nomenclaturaArchivo = String.Format("{0}-{1}", polizaActual.Pedido.FolioPedido,
                                                                    polizaActual.PesajeMateriaPrima.Ticket);
                            }
                            var resultadoPoliza = new ResultadoPolizaModel
                            {
                                NomenclaturaArchivo = nomenclaturaArchivo,
                                PDF = stream
                            };
                            //polizasVenta.ToList().ForEach(datos =>
                            //                                  {
                            //                                      datos.OrganizacionID = 1;
                            //                                      datos.UsuarioCreacionID = 1;
                            //                                  });
                            //polizaBL.Guardar(polizasVenta, TipoPoliza.PaseProceso);
                            resultadoPolizaModel.Add(resultadoPoliza);
                        }
                    }
                }
            }
            return(resultadoPolizaModel);
        }
예제 #2
0
        /// <summary>
        /// Metodo para actualizar los ajustes de inventario contenidos en el grid
        /// </summary>
        /// <param name="articulosDiferenciasInventario"></param>
        /// <param name="almacenMovimientoInfo"></param>
        /// <returns></returns>
        public IList <ResultadoPolizaModel> GuardarAjusteDeInventario(List <AjusteDeInventarioDiferenciasInventarioInfo> articulosDiferenciasInventario, AlmacenMovimientoInfo almacenMovimientoInfo)
        {
            try
            {
                var            resultadosPolizaModel = new List <ResultadoPolizaModel>();
                PolizaAbstract poliza = null;
                var            cierreDiaInventarioDAL      = new CierreDiaInventarioDAL();
                var            almacenMovimientoDetalleDAL = new AlmacenMovimientoDetalleDAL();
                var            articulosEntrada            = new List <AjusteDeInventarioDiferenciasInventarioInfo>();
                var            articulosSalida             = new List <AjusteDeInventarioDiferenciasInventarioInfo>();
                using (var transaction = new TransactionScope())
                {
                    Logger.Info();
                    if (articulosDiferenciasInventario != null)
                    {
                        var seleccionados =
                            articulosDiferenciasInventario.Any(articulosComprobar => articulosComprobar.Seleccionado);
                        if (seleccionados)
                        {
                            foreach (var articulos in articulosDiferenciasInventario.Where(art => art.Seleccionado))
                            {
                                ActualizarArticulosDiferencias(articulos, almacenMovimientoInfo);
                            }
                            almacenMovimientoInfo.Status = (int)EstatusInventario.Aplicado;
                            var almacenBL = new AlmacenBL();
                            almacenBL.ActualizarAlmacenMovimiento(almacenMovimientoInfo);

                            articulosEntrada =
                                articulosDiferenciasInventario.Where(mov => (mov.Seleccionado && mov.Cantidad > 0)).
                                ToList();

                            articulosSalida =
                                articulosDiferenciasInventario.Where(mov => (mov.Seleccionado && mov.Cantidad < 0)).
                                ToList();

                            //Generar los Movimientos de Entrada y Salida

                            #region Movimientos Entrada

                            if (articulosEntrada.Any())
                            {
                                var movimientoEntrada = new AlmacenCierreDiaInventarioInfo
                                {
                                    Almacen        = almacenMovimientoInfo.Almacen,
                                    TipoMovimiento =
                                        TipoMovimiento.EntradaPorAjuste.GetHashCode(),
                                    Observaciones     = almacenMovimientoInfo.Observaciones,
                                    Estatus           = EstatusInventario.Autorizado.GetHashCode(),
                                    UsuarioCreacionId =
                                        almacenMovimientoInfo.UsuarioModificacionID
                                };

                                var movimientosEntrada = (from detalle in articulosEntrada

                                                          select new AlmacenMovimientoDetalle
                                {
                                    ProductoID = detalle.ProductoID,
                                    Precio = detalle.Precio,
                                    Cantidad = Math.Abs(detalle.Cantidad),
                                    Importe =
                                        Math.Round(
                                            Convert.ToDecimal(
                                                Math.Abs(detalle.Cantidad)) *
                                            detalle.Precio, 2),
                                    UsuarioCreacionID =
                                        almacenMovimientoInfo.UsuarioModificacionID
                                }).ToList();

                                AlmacenCierreDiaInventarioInfo resultadoAlmacenMovimiento =
                                    cierreDiaInventarioDAL.GuardarAlmacenMovimiento(movimientoEntrada);

                                almacenMovimientoDetalleDAL.GuardarAlmacenMovimientoDetalle(movimientosEntrada,
                                                                                            resultadoAlmacenMovimiento.
                                                                                            AlmacenMovimientoID);
                            }

                            #endregion Movimientos Entrada

                            #region Movimientos Salida

                            if (articulosSalida.Any())
                            {
                                var movimientoSalida = new AlmacenCierreDiaInventarioInfo
                                {
                                    Almacen        = almacenMovimientoInfo.Almacen,
                                    TipoMovimiento =
                                        TipoMovimiento.SalidaPorAjuste.GetHashCode(),
                                    Observaciones     = almacenMovimientoInfo.Observaciones,
                                    Estatus           = EstatusInventario.Autorizado.GetHashCode(),
                                    UsuarioCreacionId =
                                        almacenMovimientoInfo.UsuarioModificacionID
                                };

                                var movimientosSalida = (from detalle in articulosSalida
                                                         select new AlmacenMovimientoDetalle
                                {
                                    ProductoID = detalle.ProductoID,
                                    Precio = detalle.Precio,
                                    Cantidad = Math.Abs(detalle.Cantidad),
                                    Importe =
                                        Math.Round(
                                            Convert.ToDecimal(
                                                Math.Abs(detalle.Cantidad)) *
                                            detalle.Precio, 2),
                                    UsuarioCreacionID =
                                        almacenMovimientoInfo.UsuarioModificacionID
                                }).ToList();

                                AlmacenCierreDiaInventarioInfo resultadoAlmacenMovimiento =
                                    cierreDiaInventarioDAL.GuardarAlmacenMovimiento(movimientoSalida);

                                almacenMovimientoDetalleDAL.GuardarAlmacenMovimientoDetalle(movimientosSalida,
                                                                                            resultadoAlmacenMovimiento.
                                                                                            AlmacenMovimientoID);
                            }

                            #endregion Movimientos Entrada
                        }
                        else
                        {
                            almacenMovimientoInfo.Status = (int)EstatusInventario.Cancelado;
                            var almacenBL = new AlmacenBL();
                            almacenBL.ActualizarAlmacenMovimiento(almacenMovimientoInfo);
                        }

                        #region POLIZA

                        #region PolizaSalida

                        MemoryStream stream;
                        if (articulosSalida.Any())
                        {
                            poliza = FabricaPoliza.ObtenerInstancia().ObtenerTipoPoliza(TipoPoliza.SalidaAjuste);

                            List <PolizaEntradaSalidaPorAjusteModel> salidasPorAjuste =
                                articulosSalida.Select(ajuste => new PolizaEntradaSalidaPorAjusteModel
                            {
                                Importe             = Math.Abs(ajuste.Importe),
                                Cantidad            = Math.Abs(ajuste.Cantidad),
                                TipoAjuste          = TipoAjusteEnum.Merma,
                                Precio              = ajuste.Precio,
                                AlmacenInventarioID =
                                    ajuste.AlmacenInventarioID,
                                AlmacenMovimientoDetalleID =
                                    ajuste.AlmacenMovimientoDetalleID,
                                ProductoID = ajuste.ProductoID,
                                CantidadInventarioFisico =
                                    ajuste.CantidadInventarioFisico,
                                CantidadInventarioTeorico =
                                    ajuste.CantidadInventarioTeorico,
                                Observaciones =
                                    almacenMovimientoInfo.Observaciones
                            }).ToList();
                            if (salidasPorAjuste.Any())
                            {
                                IList <PolizaInfo> polizasSalida = poliza.GeneraPoliza(salidasPorAjuste);
                                if (polizasSalida != null)
                                {
                                    stream = poliza.ImprimePoliza(salidasPorAjuste, polizasSalida);
                                    var polizaBL = new PolizaBL();
                                    polizasSalida.ToList().ForEach(datos =>
                                    {
                                        datos.UsuarioCreacionID =
                                            almacenMovimientoInfo.
                                            UsuarioModificacionID;
                                        datos.OrganizacionID =
                                            almacenMovimientoInfo.OrganizacionID;
                                        datos.ArchivoEnviadoServidor = 1;
                                    });
                                    polizaBL.GuardarServicioPI(polizasSalida, TipoPoliza.SalidaAjuste);
                                    var resultadoPolizaModel = new ResultadoPolizaModel
                                    {
                                        Polizas = polizasSalida,
                                        PDFs    =
                                            new Dictionary <TipoPoliza, MemoryStream>
                                        {
                                            { TipoPoliza.SalidaAjuste, stream }
                                        }
                                    };
                                    resultadosPolizaModel.Add(resultadoPolizaModel);
                                }
                            }
                        }

                        #endregion PolizaSalida

                        #region PolizaEntrada

                        if (articulosEntrada.Any())
                        {
                            poliza = FabricaPoliza.ObtenerInstancia().ObtenerTipoPoliza(TipoPoliza.EntradaAjuste);

                            List <PolizaEntradaSalidaPorAjusteModel> entradasPorAjuste =
                                articulosEntrada.Select(ajuste => new PolizaEntradaSalidaPorAjusteModel
                            {
                                Importe             = Math.Abs(ajuste.Importe),
                                Cantidad            = Math.Abs(ajuste.Cantidad),
                                TipoAjuste          = TipoAjusteEnum.Merma,
                                Precio              = ajuste.Precio,
                                AlmacenInventarioID =
                                    ajuste.AlmacenInventarioID,
                                AlmacenMovimientoDetalleID =
                                    ajuste.AlmacenMovimientoDetalleID,
                                ProductoID = ajuste.ProductoID,
                                CantidadInventarioFisico =
                                    ajuste.CantidadInventarioFisico,
                                CantidadInventarioTeorico =
                                    ajuste.CantidadInventarioTeorico,
                                Observaciones =
                                    almacenMovimientoInfo.Observaciones
                            }).ToList();
                            if (entradasPorAjuste.Any())
                            {
                                IList <PolizaInfo> polizasEntrada = poliza.GeneraPoliza(entradasPorAjuste);
                                if (polizasEntrada != null)
                                {
                                    stream = poliza.ImprimePoliza(entradasPorAjuste, polizasEntrada);
                                    var polizaBL = new PolizaBL();
                                    polizasEntrada.ToList().ForEach(datos =>
                                    {
                                        datos.UsuarioCreacionID =
                                            almacenMovimientoInfo.
                                            UsuarioModificacionID;
                                        datos.OrganizacionID =
                                            almacenMovimientoInfo.OrganizacionID;
                                        datos.ArchivoEnviadoServidor = 1;
                                    });
                                    polizaBL.GuardarServicioPI(polizasEntrada, TipoPoliza.EntradaAjuste);
                                    var resultadoPolizaModel = new ResultadoPolizaModel
                                    {
                                        Polizas = polizasEntrada,
                                        PDFs    =
                                            new Dictionary <TipoPoliza, MemoryStream>
                                        {
                                            { TipoPoliza.EntradaAjuste, stream }
                                        }
                                    };
                                    resultadosPolizaModel.Add(resultadoPolizaModel);
                                }
                            }
                        }

                        #endregion PolizaEntrada

                        #endregion POLIZA
                    }
                    else
                    {
                        almacenMovimientoInfo.Status = (int)EstatusInventario.Cancelado;
                        var almacenBL = new AlmacenBL();
                        almacenBL.ActualizarAlmacenMovimiento(almacenMovimientoInfo);
                    }
                    transaction.Complete();
                }
                return(resultadosPolizaModel);
            }
            catch (ExcepcionServicio ex)
            {
                Logger.Error(ex);
                throw;
            }
            catch (ExcepcionGenerica ex)
            {
                Logger.Error(ex);
                throw;
            }
            catch (Exception ex)
            {
                Logger.Error(ex);
                return(null);
            }
        }
예제 #3
0
        private IList <ResultadoPolizaModel> GenerarPolizaCierreDiaPA(CierreDiaInventarioPAInfo cierreDiaInventarioPA, List <EstatusInfo> listaEstatusInventario, bool imprimePoliza)
        {
            EstatusInfo estatusAplicado =
                listaEstatusInventario.FirstOrDefault(
                    esta => esta.DescripcionCorta.Trim().Equals(ConstantesBL.MovimientoAplicado.Trim()));

            if (estatusAplicado == null)
            {
                return(null);
            }
            var filtros = new FiltroAlmacenMovimientoInfo
            {
                AlmacenID        = cierreDiaInventarioPA.AlmacenID,
                OrganizacionID   = cierreDiaInventarioPA.OrganizacionID,
                TipoMovimientoID = TipoMovimiento.InventarioFisico.GetHashCode(),
                EstatusID        = estatusAplicado.EstatusId,
                FolioMovimiento  = cierreDiaInventarioPA.FolioMovimiento
            };

            var almacenMovimientoDAL = new AlmacenMovimientoDAL();
            List <ContenedorAlmacenMovimientoCierreDia> movimientos = almacenMovimientoDAL.ObtenerMovimientosInventarioFiltros(filtros);

            if (movimientos == null || !movimientos.Any())
            {
                return(null);
            }
            var resultadosPolizaModel   = new List <ResultadoPolizaModel>();
            var listaDatosPolizaEntrada = new List <PolizaEntradaSalidaPorAjusteModel>();
            var listaDatosPolizaSalida  = new List <PolizaEntradaSalidaPorAjusteModel>();

            foreach (var detalles in cierreDiaInventarioPA.ListaCierreDiaInventarioPADetalle.Where(det => (det.InventarioFisico - det.InventarioTeorico > 0)))
            {
                ContenedorAlmacenMovimientoCierreDia almacenMovimientoDetalle;
                if (detalles.ManejaLote)
                {
                    almacenMovimientoDetalle =
                        movimientos.FirstOrDefault(
                            mov => mov.Producto.ProductoId == detalles.ProductoID &&
                            mov.AlmacenMovimientoDetalle.AlmacenInventarioLoteId ==
                            detalles.AlmacenInventarioLoteID);
                }
                else
                {
                    almacenMovimientoDetalle =
                        movimientos.FirstOrDefault(
                            mov => mov.Producto.ProductoId == detalles.ProductoID);
                }
                if (almacenMovimientoDetalle == null)
                {
                    continue;
                }
                int cantidadEntrada = Math.Abs(detalles.InventarioFisico - detalles.InventarioTeorico);
                var polizaDetalle   = new PolizaEntradaSalidaPorAjusteModel
                {
                    Importe  = detalles.CostoUnitario * cantidadEntrada,
                    Cantidad = cantidadEntrada,
                    Precio   = almacenMovimientoDetalle.AlmacenMovimientoDetalle.Precio,
                    AlmacenMovimientoDetalleID =
                        almacenMovimientoDetalle.AlmacenMovimientoDetalle.AlmacenMovimientoDetalleID,
                    ProductoID = detalles.ProductoID,
                    CantidadInventarioFisico  = detalles.InventarioFisico,
                    CantidadInventarioTeorico = detalles.InventarioTeorico,
                    Observaciones             = almacenMovimientoDetalle.AlmacenMovimiento.Observaciones,
                    Lote = detalles.Lote
                };
                listaDatosPolizaEntrada.Add(polizaDetalle);
            }

            foreach (var detalles in cierreDiaInventarioPA.ListaCierreDiaInventarioPADetalle.Where(det => (det.InventarioFisico - det.InventarioTeorico < 0)))
            {
                ContenedorAlmacenMovimientoCierreDia almacenMovimientoDetalle;
                if (detalles.ManejaLote)
                {
                    almacenMovimientoDetalle =
                        movimientos.FirstOrDefault(
                            mov => mov.Producto.ProductoId == detalles.ProductoID &&
                            mov.AlmacenMovimientoDetalle.AlmacenInventarioLoteId ==
                            detalles.AlmacenInventarioLoteID);
                }
                else
                {
                    almacenMovimientoDetalle =
                        movimientos.FirstOrDefault(
                            mov => mov.Producto.ProductoId == detalles.ProductoID);
                }
                if (almacenMovimientoDetalle == null)
                {
                    continue;
                }
                int cantidadSalida = Math.Abs(detalles.InventarioFisico - detalles.InventarioTeorico);
                var polizaDetalle  = new PolizaEntradaSalidaPorAjusteModel
                {
                    Importe  = detalles.CostoUnitario * cantidadSalida,
                    Cantidad = cantidadSalida,
                    Precio   = almacenMovimientoDetalle.AlmacenMovimientoDetalle.Precio,
                    AlmacenMovimientoDetalleID =
                        almacenMovimientoDetalle.AlmacenMovimientoDetalle.AlmacenMovimientoDetalleID,
                    ProductoID = detalles.ProductoID,
                    CantidadInventarioFisico  = detalles.InventarioFisico,
                    CantidadInventarioTeorico = detalles.InventarioTeorico,
                    Observaciones             = almacenMovimientoDetalle.AlmacenMovimiento.Observaciones,
                    Lote = detalles.Lote
                };
                listaDatosPolizaSalida.Add(polizaDetalle);
            }
            if (listaDatosPolizaSalida.Any())
            {
                var poliza = FabricaPoliza.ObtenerInstancia().ObtenerTipoPoliza(TipoPoliza.SalidaAjuste);

                IList <PolizaInfo> polizas = poliza.GeneraPoliza(listaDatosPolizaSalida);
                if (polizas != null)
                {
                    MemoryStream stream = null;
                    if (imprimePoliza)
                    {
                        stream = poliza.ImprimePoliza(listaDatosPolizaSalida, polizas);
                    }
                    var polizaBL = new PolizaBL();
                    polizas.ToList().ForEach(datos =>
                    {
                        datos.UsuarioCreacionID =
                            cierreDiaInventarioPA.UsuarioCreacionID;
                        datos.OrganizacionID         = cierreDiaInventarioPA.OrganizacionID;
                        datos.ArchivoEnviadoServidor = 1;
                    });
                    polizaBL.GuardarServicioPI(polizas, TipoPoliza.SalidaAjuste);
                    var resultadoPolizaModel = new ResultadoPolizaModel
                    {
                        Polizas = polizas,
                        PDFs    =
                            new Dictionary <TipoPoliza, MemoryStream>
                        {
                            { TipoPoliza.SalidaAjuste, stream }
                        }
                    };
                    resultadosPolizaModel.Add(resultadoPolizaModel);
                }
            }
            if (listaDatosPolizaEntrada.Any())
            {
                var poliza = FabricaPoliza.ObtenerInstancia().ObtenerTipoPoliza(TipoPoliza.EntradaAjuste);

                IList <PolizaInfo> polizas = poliza.GeneraPoliza(listaDatosPolizaEntrada);
                if (polizas != null)
                {
                    MemoryStream stream = null;
                    if (imprimePoliza)
                    {
                        stream = poliza.ImprimePoliza(listaDatosPolizaEntrada, polizas);
                    }
                    var polizaBL = new PolizaBL();
                    polizas.ToList().ForEach(datos =>
                    {
                        datos.UsuarioCreacionID =
                            cierreDiaInventarioPA.UsuarioCreacionID;
                        datos.OrganizacionID         = cierreDiaInventarioPA.OrganizacionID;
                        datos.ArchivoEnviadoServidor = 1;
                    });
                    polizaBL.GuardarServicioPI(polizas, TipoPoliza.EntradaAjuste);
                    var resultadoPolizaModel = new ResultadoPolizaModel
                    {
                        Polizas = polizas,
                        PDFs    =
                            new Dictionary <TipoPoliza, MemoryStream> {
                            { TipoPoliza.EntradaAjuste, stream }
                        }
                    };
                    resultadosPolizaModel.Add(resultadoPolizaModel);
                }
            }
            return(resultadosPolizaModel);
        }
예제 #4
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);
        }