/// <summary>
        /// Obtiene un flujo de datos
        /// con la poliza de compra
        /// </summary>
        /// <param name="contenedorEntradaMateriaPrima"></param>
        /// <param name="polizaClave"></param>
        /// <returns></returns>
        private MemoryStream ReimpresionPolizaCompra(ContenedorEntradaMateriaPrimaInfo contenedorEntradaMateriaPrima
                                                     , TipoPolizaInfo polizaClave)
        {
            var polizaBL = new PolizaBL();
            IList <PolizaInfo> polizasVenta = polizaBL.ObtenerPoliza(TipoPoliza.EntradaCompra,
                                                                     contenedorEntradaMateriaPrima.Contrato.Organizacion.
                                                                     OrganizacionID,
                                                                     contenedorEntradaMateriaPrima.Contrato.Fecha
                                                                     ,
                                                                     contenedorEntradaMateriaPrima.Contrato.Folio.
                                                                     ToString(),
                                                                     polizaClave.ClavePoliza, 1);
            MemoryStream stream = null;

            if (polizasVenta != null)
            {
                var entradaProductoBL = new EntradaProductoBL();
                contenedorEntradaMateriaPrima =
                    entradaProductoBL.ObtenerPorFolioEntradaContrato(contenedorEntradaMateriaPrima.Contrato.Folio,
                                                                     contenedorEntradaMateriaPrima.Contrato.ContratoId,
                                                                     contenedorEntradaMateriaPrima.Contrato.Organizacion.OrganizacionID);
                var poliza = FabricaPoliza.ObtenerInstancia().ObtenerTipoPoliza(TipoPoliza.EntradaCompra);
                polizasVenta = poliza.GeneraPoliza(contenedorEntradaMateriaPrima);
                stream       = poliza.ImprimePoliza(contenedorEntradaMateriaPrima, polizasVenta);
            }
            return(stream);
        }
        /// <summary>
        /// Obtiene un flujo de datos
        /// para la generacion de la reimpresion
        /// de la poliza de Salida de Traspaso
        /// </summary>
        /// <param name="produccionFormula"></param>
        /// <param name="polizaClave"></param>
        /// <returns></returns>
        private MemoryStream ReimpresionPolizaProduccionAlimento(ProduccionFormulaInfo produccionFormula, TipoPolizaInfo polizaClave)
        {
            var polizaBL = new PolizaBL();
            IList <PolizaInfo> polizasProduccionAlimento = polizaBL.ObtenerPoliza(TipoPoliza.ProduccionAlimento,
                                                                                  produccionFormula.Organizacion.OrganizacionID,
                                                                                  produccionFormula.FechaProduccion,
                                                                                  produccionFormula.FolioFormula.ToString(CultureInfo.InvariantCulture),
                                                                                  polizaClave.ClavePoliza, 1);
            MemoryStream stream = null;

            if (polizasProduccionAlimento != null)
            {
                var poliza = FabricaPoliza.ObtenerInstancia().ObtenerTipoPoliza(TipoPoliza.ProduccionAlimento);
                var produccionFormulaBL = new ProduccionFormulaBL();
                using (var almacenDAL = new AlmacenDAL())
                {
                    var almacenMovimientoBL          = new AlmacenMovimientoBL();
                    ProduccionFormulaInfo produccion = produccionFormulaBL.ObtenerPorIDCompleto(produccionFormula.ProduccionFormulaId);


                    if (produccion != null)
                    {
                        AlmacenInfo almacenPlantaAlimento =
                            almacenDAL.ObtenerAlmacenOrganizacionTipo(produccionFormula.Organizacion.OrganizacionID, TipoAlmacenEnum.PlantaDeAlimentos);

                        AlmacenMovimientoInfo almacenMovimiento =
                            almacenMovimientoBL.ObtenerPorIDCompleto(produccion.AlmacenMovimientoSalidaID);

                        var produccionFormulaDetalles = new List <ProduccionFormulaDetalleInfo>();
                        if (almacenMovimiento != null)
                        {
                            foreach (var detalle in produccion.ProduccionFormulaDetalle)
                            {
                                var movimiento = almacenMovimiento.ListaAlmacenMovimientoDetalle.FirstOrDefault(
                                    alm => alm.Producto.ProductoId == detalle.Producto.ProductoId &&
                                    alm.AlmacenInventarioLoteId == detalle.AlmacenInventarioLoteID);

                                if (movimiento == null)
                                {
                                    continue;
                                }
                                detalle.CantidadProducto = movimiento.Cantidad;
                                detalle.PrecioPromedio   = movimiento.Precio;
                                produccionFormulaDetalles.Add(detalle);
                            }
                        }

                        if (almacenPlantaAlimento == null)
                        {
                            return(null);
                        }
                        produccion.ProduccionFormulaDetalle = produccionFormulaDetalles;
                        produccion.Almacen        = almacenPlantaAlimento;
                        polizasProduccionAlimento = poliza.GeneraPoliza(produccion);
                        stream = poliza.ImprimePoliza(produccion, polizasProduccionAlimento);
                    }
                }
            }
            return(stream);
        }
        /// <summary>
        /// Obtiene un flujo de datos
        /// para la generacion de la reimpresion
        /// de la poliza de Salida de Traspaso
        /// </summary>
        /// <param name="folioSolicitud"></param>
        /// <param name="polizaClave"></param>
        /// <returns></returns>
        private MemoryStream ReimpresionPolizaSalidaConsumo(FolioSolicitudInfo folioSolicitud, TipoPolizaInfo polizaClave)
        {
            var polizaBL = new PolizaBL();
            IList <PolizaInfo> polizasSalidaConsumo = polizaBL.ObtenerPoliza(TipoPoliza.SalidaConsumo,
                                                                             folioSolicitud.OrganizacionID,
                                                                             folioSolicitud.FechaEntrega.HasValue ? folioSolicitud.FechaEntrega.Value : DateTime.MinValue,
                                                                             folioSolicitud.FolioSolicitud.ToString(CultureInfo.InvariantCulture),
                                                                             polizaClave.ClavePoliza, 1);
            MemoryStream stream = null;

            if (polizasSalidaConsumo != null)
            {
                var poliza = FabricaPoliza.ObtenerInstancia().ObtenerTipoPoliza(TipoPoliza.SalidaConsumo);
                var solicitudProductoDAL = new SolicitudProductoDAL();
                using (var almacenDAL = new AlmacenDAL())
                {
                    var almacenMovimientoBL         = new AlmacenMovimientoBL();
                    SolicitudProductoInfo solicitud = solicitudProductoDAL.ObtenerPorID(folioSolicitud.FolioID);


                    if (solicitud != null)
                    {
                        AlmacenInfo almacenGeneral =
                            almacenDAL.ObtenerAlmacenGeneralOrganizacion(folioSolicitud.OrganizacionID);

                        AlmacenMovimientoInfo almacenMovimiento =
                            almacenMovimientoBL.ObtenerPorIDCompleto(solicitud.AlmacenMovimientoID.HasValue
                                                                 ? solicitud.AlmacenMovimientoID.Value
                                                                 : 0);

                        if (almacenMovimiento != null)
                        {
                            foreach (var detalle in solicitud.Detalle)
                            {
                                var movimiento = almacenMovimiento.ListaAlmacenMovimientoDetalle.FirstOrDefault(
                                    alm => alm.Producto.ProductoId == detalle.Producto.ProductoId);

                                if (movimiento == null)
                                {
                                    continue;
                                }
                                detalle.PrecioPromedio = movimiento.Precio;
                            }
                        }

                        if (almacenGeneral == null)
                        {
                            return(null);
                        }
                        solicitud.AlmacenGeneralID = almacenGeneral.AlmacenID;
                        polizasSalidaConsumo       = poliza.GeneraPoliza(solicitud);
                        stream = poliza.ImprimePoliza(solicitud, polizasSalidaConsumo);
                    }
                }
            }
            return(stream);
        }
        /// <summary>
        /// Obtiene los valores para la reimpresion de
        /// la poliza de salida por venta
        /// </summary>
        /// <param name="ventaGanado"></param>
        /// <param name="polizaClave"> </param>
        private MemoryStream ReimprimirPolizaVenta(VentaGanadoInfo ventaGanado, TipoPolizaInfo polizaClave)
        {
            var polizaBL       = new PolizaBL();
            int organizacionID = ventaGanado.Lote.OrganizacionID;
            var ventaGanadoBL  = new VentaGanadoBL();
            List <ContenedorVentaGanado> ventasGanado =
                ventaGanadoBL.ObtenerVentaGanadoPorTicketPoliza(ventaGanado.FolioTicket, organizacionID);
            MemoryStream pdf = null;

            var tipoPoliza = TipoPoliza.SalidaVenta;

            IList <PolizaInfo> polizasVenta = polizaBL.ObtenerPoliza(tipoPoliza, organizacionID,
                                                                     ventaGanado.FechaVenta
                                                                     , ventaGanado.FolioTicket.ToString(),
                                                                     polizaClave.ClavePoliza, 1);
            var poliza = FabricaPoliza.ObtenerInstancia().ObtenerTipoPoliza(tipoPoliza);

            var polizaGenerada = false;

            if (polizasVenta == null)
            {
                if (ventasGanado != null && ventasGanado.Any())
                {
                    var animalCostoBL = new AnimalCostoBL();
                    var detalleVentas = new List <VentaGanadoDetalleInfo>();
                    ventasGanado.ForEach(det => detalleVentas.Add(det.VentaGanadoDetalle));

                    List <AnimalInfo> animalesGenerarPoliza = detalleVentas.Select(ani => new AnimalInfo
                    {
                        AnimalID = ani.Animal.AnimalID,
                        OrganizacionIDEntrada = organizacionID
                    }).ToList();
                    List <AnimalCostoInfo> animalCosto = animalCostoBL.ObtenerCostosAnimal(animalesGenerarPoliza);
                    if (animalCosto != null &&
                        !animalCosto.Any(id => id.CostoID == 1 && id.Importe == 0))
                    {
                        polizasVenta = poliza.GeneraPoliza(ventasGanado);
                        polizasVenta.ToList().ForEach(org => org.OrganizacionID = organizacionID);
                        polizaBL.GuardarServicioPI(polizasVenta, tipoPoliza);
                        polizaGenerada = true;
                    }
                }
            }
            if (polizasVenta != null && polizasVenta.Any())
            {
                if (ventasGanado != null && ventasGanado.Any())
                {
                    if (!polizaGenerada)
                    {
                        polizasVenta = poliza.GeneraPoliza(ventasGanado);
                    }
                    pdf = poliza.ImprimePoliza(ventasGanado, polizasVenta);
                }
            }
            return(pdf);
        }
        /// <summary>
        /// Obtiene un flujo de datos
        /// para la generacion de la reimpresion
        /// de la poliza de venta de producto
        /// </summary>
        /// <param name="salidaProductoInfo"></param>
        /// <param name="polizaClave"></param>
        /// <returns></returns>
        private MemoryStream ReimpresionSalidaVentaProducto(SalidaProductoInfo salidaProductoInfo, TipoPolizaInfo polizaClave)
        {
            MemoryStream pdf = null;

            var polizaBL = new PolizaBL();
            IList <PolizaInfo> polizasSalidaProducto = polizaBL.ObtenerPoliza(TipoPoliza.SalidaVentaProducto,
                                                                              salidaProductoInfo.Organizacion.OrganizacionID
                                                                              , salidaProductoInfo.FechaSalida,
                                                                              salidaProductoInfo.FolioSalida.ToString(),
                                                                              polizaClave.ClavePoliza, 1);

            if (polizasSalidaProducto != null && polizasSalidaProducto.Any())
            {
                var poliza = FabricaPoliza.ObtenerInstancia().ObtenerTipoPoliza(TipoPoliza.SalidaVentaProducto);
                polizasSalidaProducto = poliza.GeneraPoliza(salidaProductoInfo);
                if (polizasSalidaProducto != null && polizasSalidaProducto.Any())
                {
                    pdf = poliza.ImprimePoliza(salidaProductoInfo, polizasSalidaProducto);
                }
            }
            return(pdf);
        }
Beispiel #6
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);
        }
Beispiel #7
0
        /// <summary>
        /// Se guardan las respuesta a las solicitudes de materia prima
        /// </summary>
        /// <param name="respuestaSolicitudes"></param>
        /// <param name="organizacionID"></param>
        /// <param name="tipoAutorizacionID"></param>
        /// <param name="usuarioID"></param>
        /// <returns></returns>
        public ResultadoValidacion GuardarRespuestasSolicitudes(List <AutorizacionMovimientosInfo> respuestaSolicitudes, int organizacionID, int tipoAutorizacionID, int usuarioID)
        {
            var result  = new ResultadoValidacion();
            var mensaje = new StringBuilder();

            try
            {
                Logger.Info();
                var solicitudDAL        = new SolicitudAutorizacionDAL();
                var almacenMovimientoBl = new AlmacenMovimientoBL();

                using (var transaction = new TransactionScope())
                {
                    List <DiferenciasDeInventariosInfo> listaMovimientosPendientes =
                        solicitudDAL.ObtenerMovimientosAutorizacion(respuestaSolicitudes);

                    if (listaMovimientosPendientes != null && listaMovimientosPendientes.Any())
                    {
                        foreach (var movimiento in listaMovimientosPendientes)
                        {
                            if (movimiento.AlmacenMovimiento.TipoMovimientoID == TipoMovimiento.SalidaPorAjuste.GetHashCode())
                            {
                                if (movimiento.AlmacenMovimientoDetalle.Cantidad >
                                    movimiento.AlmacenInventarioLote.Cantidad)
                                {
                                    AutorizacionMovimientosInfo autorizacionCancelar =
                                        respuestaSolicitudes.FirstOrDefault(
                                            aut =>
                                            aut.AlmacenMovimientoID == movimiento.AlmacenMovimiento.AlmacenMovimientoID);

                                    if (autorizacionCancelar != null)
                                    {
                                        autorizacionCancelar.EstatusID     = Estatus.AMPRechaza.GetHashCode();
                                        autorizacionCancelar.Observaciones =
                                            ResourceServices.SolicitudAutorizacionBL_RechazoAutomatico;
                                        mensaje.Append(string.Format(", {0}:{1}",
                                                                     movimiento.Producto.ProductoDescripcion,
                                                                     movimiento.AlmacenMovimientoDetalle.Cantidad));
                                    }
                                }
                            }
                        }
                    }

                    bool guardado = solicitudDAL.GuardarRespuestasSolicitudes(respuestaSolicitudes, organizacionID, tipoAutorizacionID, usuarioID);

                    if (guardado && tipoAutorizacionID == (int)TipoAutorizacionEnum.AjustedeInventario)
                    {
                        for (int i = 0; i < respuestaSolicitudes.Count; i++)
                        {
                            if (respuestaSolicitudes[i].EstatusID == (int)Estatus.AMPAutoriz)
                            {
                                respuestaSolicitudes[i].EstatusInventarioID = (int)Estatus.DifInvAutorizado;
                            }
                            else
                            {
                                respuestaSolicitudes[i].EstatusInventarioID = (int)Estatus.DifInvRechazado;
                            }
                        }
                        // Se realiza el proceso de afectar el inventario para los movimientos autorizados
                        List <DiferenciasDeInventariosInfo> listaAjustesPendientes;
                        var diferenciasDeInventarioBl = new DiferenciasDeInventarioBL();

                        listaAjustesPendientes = solicitudDAL.GuardarAjusteInventario(respuestaSolicitudes, organizacionID);

                        if (listaAjustesPendientes != null)
                        {
                            foreach (var diferenciasDeInventariosInfoPar in listaAjustesPendientes)
                            {
                                diferenciasDeInventariosInfoPar.DescripcionAjuste =
                                    diferenciasDeInventariosInfoPar.AlmacenMovimiento.TipoMovimientoID ==
                                    TipoMovimiento.SalidaPorAjuste.GetHashCode()
                                        ? TipoAjusteEnum.Merma.ToString()
                                        : TipoAjusteEnum.Superávit.ToString();
                                diferenciasDeInventariosInfoPar.DiferenciaInventario =
                                    diferenciasDeInventariosInfoPar.AlmacenMovimientoDetalle.Cantidad;

                                diferenciasDeInventariosInfoPar.AlmacenMovimiento.UsuarioModificacionID        = usuarioID;
                                diferenciasDeInventariosInfoPar.AlmacenMovimientoDetalle.UsuarioModificacionID = usuarioID;
                                diferenciasDeInventariosInfoPar.AlmacenInventarioLote.UsuarioModificacionId    = usuarioID;

                                diferenciasDeInventariosInfoPar.AlmacenMovimiento.Status =
                                    Estatus.DifInvAplicado.GetHashCode();
                                diferenciasDeInventariosInfoPar.TieneConfiguracion = true;

                                //Se cambia el status por aplicado
                                almacenMovimientoBl.ActualizarEstatus(diferenciasDeInventariosInfoPar.AlmacenMovimiento);
                                //Actualiza inventario y lote
                                diferenciasDeInventarioBl.ActualizarInventarioYLote(diferenciasDeInventariosInfoPar, usuarioID);
                            }

                            #region POLIZA

                            List <PolizaEntradaSalidaPorAjusteModel> salidasPorAjuste =
                                listaAjustesPendientes.Where(dif => !dif.DescripcionAjuste.Trim().Equals(TipoAjusteEnum.CerrarLote.ToString().Trim(), StringComparison.InvariantCultureIgnoreCase)).Select(ajuste => new PolizaEntradaSalidaPorAjusteModel
                            {
                                Importe =
                                    ajuste.DiferenciaInventario *
                                    ajuste.AlmacenInventarioLote.
                                    PrecioPromedio,
                                Cantidad   = ajuste.DiferenciaInventario,
                                TipoAjuste =
                                    ajuste.DescripcionAjuste.Equals(
                                        TipoAjusteEnum.Merma.ToString(),
                                        StringComparison.
                                        CurrentCultureIgnoreCase)
                                            ? TipoAjusteEnum.Merma
                                            : TipoAjusteEnum.Superávit,
                                Precio = ajuste.AlmacenInventarioLote.
                                         PrecioPromedio,
                                AlmacenInventarioID =
                                    ajuste.AlmacenInventarioLote.
                                    AlmacenInventario.AlmacenInventarioID,
                                AlmacenMovimientoDetalleID =
                                    ajuste.AlmacenMovimientoDetalle.
                                    AlmacenMovimientoDetalleID,
                                ProductoID = ajuste.Producto.ProductoId,
                                CantidadInventarioFisico =
                                    ajuste.KilogramosFisicos,
                                CantidadInventarioTeorico =
                                    ajuste.KilogramosTeoricos,
                                Observaciones =
                                    ajuste.AlmacenMovimiento.Observaciones
                            }).ToList();
                            var agrupado =
                                salidasPorAjuste.GroupBy(tipo => new { tipo.TipoAjuste, tipo.AlmacenMovimientoDetalleID }).Select(
                                    ajuste => new PolizaEntradaSalidaPorAjusteModel
                            {
                                TipoAjuste                 = ajuste.Key.TipoAjuste,
                                AlmacenInventarioID        = ajuste.First().AlmacenInventarioID,
                                AlmacenMovimientoDetalleID = ajuste.Key.AlmacenMovimientoDetalleID,
                                Cantidad = ajuste.First().Cantidad,
                                CantidadInventarioFisico  = ajuste.First().CantidadInventarioFisico,
                                CantidadInventarioTeorico = ajuste.First().CantidadInventarioTeorico,
                                Importe                 = ajuste.First().Importe,
                                Observaciones           = ajuste.First().Observaciones,
                                Precio                  = ajuste.First().Precio,
                                PrecioInventarioFisico  = ajuste.First().PrecioInventarioFisico,
                                PrecioInventarioTeorico = ajuste.First().PrecioInventarioTeorico,
                                ProductoID              = ajuste.First().ProductoID
                            }).ToList();
                            if (agrupado != null && agrupado.Any())
                            {
                                var streams = new List <MemoryStream>();
                                for (int indexAjustes = 0; indexAjustes < agrupado.Count; indexAjustes++)
                                {
                                    var tipoPoliza = TipoPoliza.SalidaAjuste;
                                    switch (agrupado[indexAjustes].TipoAjuste)
                                    {
                                    case TipoAjusteEnum.Superávit:
                                        tipoPoliza = TipoPoliza.EntradaAjuste;
                                        break;
                                    }
                                    var poliza = FabricaPoliza.ObtenerInstancia().ObtenerTipoPoliza(tipoPoliza);
                                    var grupo  = new List <PolizaEntradaSalidaPorAjusteModel>
                                    {
                                        agrupado[indexAjustes]
                                    };
                                    var polizas = poliza.GeneraPoliza(grupo);
                                    if (polizas != null && polizas.Any())
                                    {
                                        MemoryStream stream = poliza.ImprimePoliza(grupo, polizas);
                                        if (stream != null)
                                        {
                                            streams.Add(stream);
                                        }
                                        var polizaBL = new PolizaBL();
                                        polizas.ToList().ForEach(datos =>
                                        {
                                            datos.OrganizacionID         = organizacionID;
                                            datos.UsuarioCreacionID      = usuarioID;
                                            datos.ArchivoEnviadoServidor = 1;
                                        });
                                        polizaBL.GuardarServicioPI(polizas, tipoPoliza);
                                    }
                                }
                            }

                            #endregion POLIZA
                        }
                    }
                    transaction.Complete();
                }
            }
            catch (ExcepcionServicio ex)
            {
                result.Mensaje       = ex.Message;
                result.Resultado     = false;
                result.CodigoMensaje = 2;
                return(result);
            }
            catch (ExcepcionGenerica)
            {
                throw;
            }
            catch (Exception ex)
            {
                Logger.Error(ex);
                throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
            }
            if (mensaje.Length == 0)
            {
                result.Resultado = true;
            }
            else
            {
                result.Mensaje       = String.Format(ResourceServices.SolicitudAutorizacionBL_AutorizacionRechazadas, mensaje);
                result.Resultado     = false;
                result.CodigoMensaje = 1;
            }
            return(result);
        }
        /// <summary>
        /// Obtiene los valores para la reimpresion de
        /// la poliza de entrada de ganado
        /// </summary>
        /// <param name="entradaGanado"></param>
        /// <param name="polizaClave"> </param>
        private MemoryStream ReimprimirPolizaEntrada(EntradaGanadoInfo entradaGanado, TipoPolizaInfo polizaClave)
        {
            EntradaGanadoCosteoInfo entradaGanadoCosteo;
            var esGanadera            = false;
            var entradaGanadoCosteoBL = new EntradaGanadoCosteoBL();

            if (entradaGanado.TipoOrigen == TipoOrganizacion.Ganadera.GetHashCode())
            {
                var interfaceSalidaTraspasoBL = new InterfaceSalidaTraspasoBL();
                entradaGanadoCosteo =
                    interfaceSalidaTraspasoBL.ObtenerDatosInterfaceSalidaTraspaso(entradaGanado.OrganizacionID, entradaGanado.FolioOrigen);
                esGanadera = true;

                EntradaGanadoCosteoInfo entradaGanadoCosteoComplementoCostos
                    = entradaGanadoCosteoBL.ObtenerPorEntradaGanadoID(entradaGanado.EntradaGanadoID);
                entradaGanadoCosteo.ListaCostoEntrada.AddRange(entradaGanadoCosteoComplementoCostos.ListaCostoEntrada.Where(id => id.Costo.CostoID != 1));
            }
            else
            {
                entradaGanadoCosteo = entradaGanadoCosteoBL.ObtenerPorEntradaGanadoID(entradaGanado.EntradaGanadoID);
            }

            MemoryStream pdf = null;

            if (entradaGanadoCosteo != null)
            {
                if (!esGanadera)
                {
                    var          cuentaPL          = new CuentaBL();
                    const string CUENTA_INVENTARIO = "CTAINVTRAN";
                    entradaGanadoCosteo.ListaCostoEntrada.ForEach(costo =>
                    {
                        if (!string.IsNullOrWhiteSpace(costo.DescripcionCuenta))
                        {
                            return;
                        }
                        var claveContable = cuentaPL.ObtenerPorClaveCuentaOrganizacion(CUENTA_INVENTARIO,
                                                                                       entradaGanado.OrganizacionOrigenID);
                        if (claveContable != null)
                        {
                            costo.DescripcionCuenta = claveContable.Descripcion;
                        }
                    });
                }
                var contenedorCosteoEntrada = new ContenedorCosteoEntradaGanadoInfo
                {
                    EntradaGanado       = entradaGanado,
                    EntradaGanadoCosteo = entradaGanadoCosteo
                };
                PolizaAbstract poliza;
                var            tipoPoliza = esGanadera ? TipoPoliza.EntradaGanadoDurango : TipoPoliza.EntradaGanado;
                if (esGanadera)
                {
                    poliza = FabricaPoliza.ObtenerInstancia().ObtenerTipoPoliza(tipoPoliza);
                }
                else
                {
                    poliza = FabricaPoliza.ObtenerInstancia().ObtenerTipoPoliza(tipoPoliza);
                }
                var polizaBL       = new PolizaBL();
                int organizacionID = entradaGanado.OrganizacionID;

                IList <PolizaInfo> polizasEntrada = polizaBL.ObtenerPoliza(tipoPoliza, organizacionID,
                                                                           entradaGanado.FechaEntrada,
                                                                           entradaGanado.FolioEntrada.ToString(),
                                                                           polizaClave.ClavePoliza, 1);
                if (polizasEntrada != null)
                {
                    polizasEntrada = poliza.GeneraPoliza(contenedorCosteoEntrada);
                    pdf            = poliza.ImprimePoliza(contenedorCosteoEntrada, polizasEntrada);
                }
            }
            return(pdf);
        }
        /// <summary>
        /// Obtiene los valores para la reimpresion de
        /// la poliza de Salida por Muerte
        /// </summary>
        /// <param name="animal"></param>
        /// <param name="fecha"></param>
        /// <param name="polizaClave"> </param>
        private MemoryStream ReimprimirPolizaMuerte(AnimalInfo animal, DateTime fecha
                                                    , TipoPolizaInfo polizaClave)
        {
            MemoryStream pdf                   = null;
            var          animalCostoBL         = new AnimalCostoBL();
            var          animalesGenerarPoliza = new List <AnimalInfo> {
                animal
            };
            List <AnimalCostoInfo> animalCosto = animalCostoBL.ObtenerCostosAnimal(animalesGenerarPoliza);

            var animalCostoAgrupado = (from costo in animalCosto
                                       group costo by new { costo.AnimalID, costo.CostoID }
                                       into agrupado
                                       select new AnimalCostoInfo
            {
                AnimalID = agrupado.Key.AnimalID,
                CostoID = agrupado.Key.CostoID,
                Importe = agrupado.Sum(cos => cos.Importe),
                FolioReferencia =
                    agrupado.Select(cos => cos.FolioReferencia).FirstOrDefault(),
                FechaCosto = agrupado.Select(cos => cos.FechaCosto).FirstOrDefault()
            }).ToList();

            animalCosto = animalCostoAgrupado;
            if (animalCosto.Any())
            {
                int organizacionID = animal.OrganizacionIDEntrada;
                int usuarioID      = animal.UsuarioCreacionID;
                animalCosto.ForEach(org =>
                {
                    org.OrganizacionID    = organizacionID;
                    org.UsuarioCreacionID = usuarioID;
                });
                var poliza   = FabricaPoliza.ObtenerInstancia().ObtenerTipoPoliza(TipoPoliza.SalidaMuerte);
                var polizaBL = new PolizaBL();
                for (int indexAnimal = 0; indexAnimal < animalesGenerarPoliza.Count; indexAnimal++)
                {
                    IList <PolizaInfo> polizaSalidaMuerte = polizaBL.ObtenerPoliza(TipoPoliza.SalidaMuerte,
                                                                                   organizacionID,
                                                                                   fecha,
                                                                                   animalesGenerarPoliza[indexAnimal].
                                                                                   AnimalID.ToString(),
                                                                                   polizaClave.ClavePoliza, 1);
                    animalCosto =
                        animalCosto.Where(id => id.AnimalID == animalesGenerarPoliza[indexAnimal].AnimalID).ToList();
                    if (animalCosto.Any())
                    {
                        animalCosto.ForEach(ani => ani.Arete = animalesGenerarPoliza[indexAnimal].Arete);
                    }
                    if (polizaSalidaMuerte == null)
                    {
                        if (animalCosto.Any(id => id.CostoID == 1))
                        {
                            organizacionID     = animal.OrganizacionIDEntrada;
                            polizaSalidaMuerte = poliza.GeneraPoliza(animalCosto);
                            polizaSalidaMuerte.ToList().ForEach(datos =>
                            {
                                datos.OrganizacionID         = organizacionID;
                                datos.UsuarioCreacionID      = usuarioID;
                                datos.ArchivoEnviadoServidor = 1;
                            });
                            polizaBL.GuardarServicioPI(polizaSalidaMuerte, TipoPoliza.SalidaMuerte);
                        }
                    }
                    else
                    {
                        polizaSalidaMuerte = poliza.GeneraPoliza(animalCosto);
                    }
                    if ((polizaSalidaMuerte != null && polizaSalidaMuerte.Any()) &&
                        animalCosto.Any(id => id.CostoID == 1))
                    {
                        pdf = poliza.ImprimePoliza(animalCosto, polizaSalidaMuerte);
                    }
                }
            }
            return(pdf);
        }
Beispiel #10
0
        internal MemoryStream Guardar(MuertesEnTransitoInfo muerteEnTransito, List <AnimalInfo> animales)
        {
            MemoryStream retorno = null;

            try
            {
                Logger.Info();
                PolizaAbstract     poliza;
                IList <PolizaInfo> polizaMuerteEnTransito;
                var entradaGanadoMuerteLista = new List <EntradaGanadoMuerteInfo>();

                using (var transaction = new TransactionScope())
                {
                    var fecha             = DateTime.Now;
                    int organizacionID    = muerteEnTransito.OrganizacionID;
                    int usuarioCreacionID = muerteEnTransito.UsuarioCreacionID;
                    int pesoAnimal        = 0;
                    int corralID          = 0;
                    int loteID            = 0;

                    var datosInterface = false;
                    List <InterfaceSalidaAnimalInfo> interfaceSalidaAnimal = null;
                    var entradaGanadoBL             = new EntradaGanadoBL();
                    EntradaGanadoInfo entradaGanado = entradaGanadoBL.ObtenerPorID(muerteEnTransito.EntradaGanadoID);
                    if (entradaGanado != null)
                    {
                        loteID   = entradaGanado.LoteID;
                        corralID = entradaGanado.CorralID;
                        if (entradaGanado.FolioOrigen > 0)
                        {
                            var interfaceSalidaBL = new InterfaceSalidaAnimalBL();
                            interfaceSalidaAnimal =
                                interfaceSalidaBL.ObtenerInterfazSalidaAnimal(entradaGanado.FolioOrigen,
                                                                              entradaGanado.OrganizacionOrigenID);
                            if (interfaceSalidaAnimal == null || interfaceSalidaAnimal.Count <= 0)
                            {
                                fecha      = entradaGanado.FechaEntrada;
                                pesoAnimal = Convert.ToInt32((entradaGanado.PesoBruto - entradaGanado.PesoTara) /
                                                             entradaGanado.CabezasRecibidas);
                            }
                            else
                            {
                                datosInterface = true;
                            }
                        }
                        else
                        {
                            pesoAnimal = Convert.ToInt32((entradaGanado.PesoBruto - entradaGanado.PesoTara) /
                                                         entradaGanado.CabezasRecibidas);
                        }
                    }
                    // Generamos el Folio

                    FolioBL folioBL     = new FolioBL();
                    var     folioMuerte = folioBL.ObtenerFolio(organizacionID, TipoFolio.MuertesEnTransito);

                    foreach (var animal in animales)
                    {
                        if (datosInterface)
                        {
                            pesoAnimal = interfaceSalidaAnimal.Where(
                                are => are.Arete.Equals(animal.Arete)).Select(
                                peso => Convert.ToInt32(peso.PesoCompra)).FirstOrDefault();
                        }

                        if (datosInterface)
                        {
                            fecha =
                                interfaceSalidaAnimal.Where(arete => arete.Arete.Equals(animal.Arete)).Select(
                                    fechaItz => fechaItz.FechaCompra).FirstOrDefault();
                        }

                        if (fecha == new DateTime(1, 1, 1))
                        {
                            fecha = DateTime.Now;
                        }

                        animal.OrganizacionIDEntrada = organizacionID;
                        animal.FolioEntrada          = muerteEnTransito.FolioEntrada;
                        animal.UsuarioCreacionID     = usuarioCreacionID;
                        animal.ClasificacionGanadoID = 1;
                        animal.CalidadGanadoID       = 1;
                        animal.TipoGanadoID          = 1;
                        animal.FechaCompra           = fecha;
                        animal.PesoCompra            = pesoAnimal;
                        animal.Activo = false;
                    }

                    //Guardamos los Animales
                    var animalBL = new AnimalBL();
                    animalBL.GuardarAnimal(animales);

                    //Obtenemos los animales almacenados con su
                    animales = animalBL.ObtenerPorArete(animales);

                    foreach (AnimalInfo animal in animales)
                    {
                        animal.UsuarioCreacionID = usuarioCreacionID;
                    }

                    //Genera los costos por animal
                    animales = animalBL.ProcesoGenerarCostos(animales);

                    foreach (AnimalInfo animal in animales)
                    {
                        var entradaGanadoMuerte = new EntradaGanadoMuerteInfo
                        {
                            EntradaGanado =
                                new EntradaGanadoInfo
                            {
                                EntradaGanadoID =
                                    muerteEnTransito.EntradaGanadoID,
                            },
                            Animal = new AnimalInfo {
                                Arete = animal.Arete
                            },
                            FolioMuerte       = folioMuerte,
                            Activo            = EstatusEnum.Activo,
                            UsuarioCreacionID = usuarioCreacionID,
                            Peso = animal.PesoCompra,
                            EntradaGanadMuerteDetalle = new List <EntradaGanadoMuerteDetalleInfo>(),
                            ProveedorFletes           = new ProveedorInfo()
                            {
                                CodigoSAP = muerteEnTransito.CodigoProveedor
                            },
                            Cliente = new ClienteInfo()
                            {
                                CodigoSAP = muerteEnTransito.Cliente.CodigoSAP, Descripcion = muerteEnTransito.Cliente.Descripcion
                            },
                            OrganizacionDestinoID = entradaGanado.OrganizacionID
                        };

                        if (animal.ListaCostosAnimal != null)
                        {
                            entradaGanadoMuerte.EntradaGanadMuerteDetalle =
                                animal.ListaCostosAnimal.Select(im => new EntradaGanadoMuerteDetalleInfo
                            {
                                Costo = new CostoInfo
                                {
                                    CostoID = im.CostoID
                                },
                                Importe             = im.Importe,
                                EntradaGanadoMuerte = entradaGanadoMuerte
                            }).ToList();
                        }
                        entradaGanadoMuerteLista.Add(entradaGanadoMuerte);
                    }

                    if (interfaceSalidaAnimal != null && interfaceSalidaAnimal.Count > 0 && animales != null && animales.Count > 0)
                    {
                        var interfaceSalidaBL = new InterfaceSalidaAnimalBL();
                        foreach (AnimalInfo animal in animales)
                        {
                            InterfaceSalidaAnimalInfo interfaceSalidaAnimalIndividual = interfaceSalidaAnimal.FirstOrDefault(animalInfo => animalInfo.Arete.Equals(animal.Arete));
                            interfaceSalidaBL.GuardarAnimalID(interfaceSalidaAnimalIndividual, animal.AnimalID);
                        }
                    }

                    //Asignamos el AnimalID en la lista de muertes ante sde guardar.
                    foreach (EntradaGanadoMuerteInfo muerte in entradaGanadoMuerteLista)
                    {
                        muerte.Animal.AnimalID = animales.Where(animal => animal.Arete.Equals(muerte.Animal.Arete))
                                                 .Select(animal => animal.AnimalID).FirstOrDefault();
                        muerte.Peso = animales.Where(animal => animal.Arete.Equals(muerte.Animal.Arete))
                                      .Select(animal => animal.PesoCompra).FirstOrDefault();
                    }
                    //Guardamos las muertes en transito
                    var muertesEnTransitoDal = new MuertesEnTransitoDAL();
                    muertesEnTransitoDal.Guardar(entradaGanadoMuerteLista, muerteEnTransito.Cliente);


                    //Creamos los movimientos para el animal
                    if (animales != null && animales.Any())
                    {
                        fecha = DateTime.Now;
                        var animalMovimientoBL = new AnimalMovimientoBL();
                        List <AnimalMovimientoInfo> movimientosAnimal = animales.Select(ani =>
                                                                                        new AnimalMovimientoInfo
                        {
                            AnimalID          = ani.AnimalID,
                            Activo            = EstatusEnum.Activo,
                            CorralID          = corralID,
                            LoteID            = loteID,
                            FechaMovimiento   = fecha,
                            OrganizacionID    = organizacionID,
                            TipoMovimientoID  = TipoMovimiento.MuerteTransito.GetHashCode(),
                            OperadorID        = 1,
                            TrampaID          = 1,
                            Peso              = ani.PesoCompra,
                            UsuarioCreacionID = usuarioCreacionID,
                        }).ToList();
                        animalMovimientoBL.GuardarAnimalMovimientoXML(movimientosAnimal);
                    }
                    //Afectamos el lote correspondiente.
                    var loteBl   = new LoteBL();
                    var loteInfo = loteBl.ObtenerPorID(muerteEnTransito.LoteID);
                    loteInfo.UsuarioModificacionID = muerteEnTransito.UsuarioCreacionID;
                    loteInfo.Cabezas -= muerteEnTransito.MuertesTransito;

                    var filtro = new FiltroActualizarCabezasLote
                    {
                        CabezasProcesadas     = muerteEnTransito.MuertesTransito,
                        LoteIDDestino         = 0,
                        LoteIDOrigen          = loteInfo.LoteID,
                        UsuarioModificacionID = usuarioCreacionID
                    };

                    var cabezasActualizadas = loteBl.ActualizarCabezasProcesadas(filtro);

                    //Executamos el SP CorteGanado_CierrePartidaPesoOrigenLLegada(Antes-->CorteGanado_PesoCompraDirecta), si se inactiva el lote.
                    if (cabezasActualizadas.CabezasOrigen <= 0)
                    {
                        //muertesEnTransitoDal.CorteGanado_PesoCompraDirecta(muerteEnTransito.OrganizacionID, muerteEnTransito.CorralID, muerteEnTransito.LoteID);
                        var corteGanadoBl = new CorteGanadoBL();
                        corteGanadoBl.ObtenerPesosOrigenLlegada(muerteEnTransito.OrganizacionID,
                                                                muerteEnTransito.CorralID,
                                                                muerteEnTransito.LoteID);
                    }

                    #region Poliza
                    //VentaGanadoBL ventaGanadoBL = new VentaGanadoBL();
                    //List<EntradaGanadoMuerteInfo> ventasGanado = ventaGanadoBL.ObtenerVentaGanadoPorTicketPoliza(folio, organizacionID);
                    //if (ventasGanado != null && ventasGanado.Any())

                    if (entradaGanadoMuerteLista != null && entradaGanadoMuerteLista.Any())
                    {
                        poliza = FabricaPoliza.ObtenerInstancia().ObtenerTipoPoliza(TipoPoliza.PolizaMuerteTransito);
                        polizaMuerteEnTransito = poliza.GeneraPoliza(entradaGanadoMuerteLista);
                        if (polizaMuerteEnTransito != null && polizaMuerteEnTransito.Any())
                        {
                            polizaMuerteEnTransito.ToList().ForEach(
                                org =>
                            {
                                org.OrganizacionID         = organizacionID;
                                org.UsuarioCreacionID      = usuarioCreacionID;
                                org.ArchivoEnviadoServidor = 1;
                            });

                            entradaGanadoMuerteLista.ToList().ForEach(org =>
                            {
                                org.EntradaGanado.Lote         = entradaGanado.Lote;
                                org.EntradaGanado.CodigoCorral = entradaGanado.CodigoCorral;
                            });
                            retorno = poliza.ImprimePoliza(entradaGanadoMuerteLista, polizaMuerteEnTransito);
                            var polizaBL = new PolizaBL();
                            polizaBL.GuardarServicioPI(polizaMuerteEnTransito, TipoPoliza.PolizaMuerteTransito);
                        }
                    }

                    // Genera el xml y lo guarda en la ruta especificada en la configuración
                    var facturaBl = new FacturaBL();
                    facturaBl.GenerarDatosFacturaMuertesEnTransito(folioMuerte, organizacionID);

                    #endregion Poliza

                    animalBL.EnviarAHistorico(animales);

                    transaction.Complete();
                }
                return(retorno);
            }
            catch (ExcepcionGenerica)
            {
                throw;
            }
            catch (Exception ex)
            {
                Logger.Error(ex);
                throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
            }
        }
        /// <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);
            }
        }
        /// <summary>
        /// Guarda los ajustes
        /// </summary>
        /// <param name="listaDiferenciasInventario"></param>
        /// <param name="usuarioInfo"></param>
        internal IList <MemoryStream> Guardar(List <DiferenciasDeInventariosInfo> listaDiferenciasInventario, UsuarioInfo usuarioInfo)
        {
            int                usuarioId = usuarioInfo.UsuarioID;
            PolizaAbstract     poliza    = null;
            IList <PolizaInfo> polizas   = null;
            int                organizacionID;
            //var contratoCreado = new ContratoInfo();
            IList <MemoryStream> streams = null;

            try
            {
                using (var transaction = new TransactionScope())
                {
                    var almacenMovimientoBl        = new AlmacenMovimientoBL();
                    var almacenMovimientoDetalleBl = new AlmacenMovimientoDetalleBL();
                    organizacionID = usuarioInfo.OrganizacionID;
                    foreach (var diferenciasDeInventariosInfo in listaDiferenciasInventario)
                    {
                        if (diferenciasDeInventariosInfo.DescripcionAjuste.Equals(TipoAjusteEnum.CerrarLote.ToString(), StringComparison.InvariantCultureIgnoreCase))
                        {
                            var almacenInventarioLoteBl   = new AlmacenInventarioLoteBL();
                            var almacenInventarioLoteInfo = almacenInventarioLoteBl.ObtenerAlmacenInventarioLotePorId(
                                diferenciasDeInventariosInfo.AlmacenInventarioLote.AlmacenInventarioLoteId);
                            if (almacenInventarioLoteInfo != null)
                            {
                                almacenInventarioLoteInfo.UsuarioModificacionId = usuarioInfo.UsuarioID;
                                //Kilogramos teoricos en 0 se desactiva el lote
                                if (diferenciasDeInventariosInfo.KilogramosFisicos == 0)
                                {
                                    //Desactivar lote
                                    almacenInventarioLoteBl.DesactivarLote(almacenInventarioLoteInfo);
                                }
                            }
                            continue;
                        }

                        diferenciasDeInventariosInfo.DiferenciaInventario =
                            Math.Abs(diferenciasDeInventariosInfo.KilogramosFisicos -
                                     diferenciasDeInventariosInfo.KilogramosTeoricos);
                        ////Se le quita el signo para que no guarde en negativos
                        //diferenciasDeInventariosInfo.KilogramosTeoricos =
                        //    Math.Abs(diferenciasDeInventariosInfo.KilogramosTeoricos);
                        //organizacionID = diferenciasDeInventariosInfo.AlmacenMovimiento.OrganizacionID;
                        //Si no esta guardado se actualiza
                        if (!diferenciasDeInventariosInfo.Guardado)
                        {
                            AlmacenMovimientoInfo almacen = new AlmacenMovimientoInfo();
                            //Estatus aplicado guarda y actualiza inventario
                            if (diferenciasDeInventariosInfo.AlmacenMovimiento.Status ==
                                Estatus.DifInvAplicado.GetHashCode())
                            {
                                //Insertar movimiento
                                diferenciasDeInventariosInfo.AlmacenMovimiento.AlmacenID =
                                    diferenciasDeInventariosInfo.Almacen.AlmacenID;
                                var almacenMovimientoId =
                                    almacenMovimientoBl.Crear(diferenciasDeInventariosInfo.AlmacenMovimiento);

                                //Insertar detalle
                                var almacenMovimientoDetalleInfo = new AlmacenMovimientoDetalle
                                {
                                    AlmacenMovimientoID     = almacenMovimientoId,
                                    AlmacenInventarioLoteId =
                                        diferenciasDeInventariosInfo.
                                        AlmacenInventarioLote.
                                        AlmacenInventarioLoteId,
                                    Piezas     = 0,
                                    ProductoID =
                                        diferenciasDeInventariosInfo.Producto.
                                        ProductoId,
                                    Precio =
                                        diferenciasDeInventariosInfo.
                                        AlmacenInventarioLote.PrecioPromedio,
                                    Cantidad =
                                        diferenciasDeInventariosInfo.
                                        DiferenciaInventario,
                                    Importe =
                                        diferenciasDeInventariosInfo.
                                        DiferenciaInventario *
                                        diferenciasDeInventariosInfo.
                                        AlmacenInventarioLote.PrecioPromedio,
                                    UsuarioCreacionID = usuarioInfo.UsuarioID
                                };
                                long almacenMovimientoDetalleID =
                                    almacenMovimientoDetalleBl.Crear(almacenMovimientoDetalleInfo);


                                //SE AGREGA DETALLE
                                almacenMovimientoDetalleInfo.AlmacenMovimientoDetalleID = almacenMovimientoDetalleID;



                                //var almacenmovimientoBl1 = new AlmacenMovimientoDetalleBL();

                                //var d =
                                //    almacenmovimientoBl1.ObtenerPorAlmacenMovimientoDetalleId(almacenMovimientoDetalleInfo);


                                diferenciasDeInventariosInfo.AlmacenMovimientoDetalle = almacenMovimientoDetalleInfo;
                                //SE AGREGA DETALLE
                                //Actualizamos inventario y lote
                                ActualizarInventarioYLote(diferenciasDeInventariosInfo, usuarioInfo.UsuarioID);
                            }

                            //Si es pendiente solo guarda el movimiento y detalle
                            if (diferenciasDeInventariosInfo.AlmacenMovimiento.Status ==
                                Estatus.DifInvPendiente.GetHashCode())
                            {
                                //Insertar movimiento
                                diferenciasDeInventariosInfo.AlmacenMovimiento.AlmacenID =
                                    diferenciasDeInventariosInfo.Almacen.AlmacenID;
                                var almacenMovimientoId =
                                    almacenMovimientoBl.Crear(diferenciasDeInventariosInfo.AlmacenMovimiento);

                                //Insertar detalle
                                var almacenMovimientoDetalleInfo = new AlmacenMovimientoDetalle()
                                {
                                    AlmacenMovimientoID     = almacenMovimientoId,
                                    AlmacenInventarioLoteId =
                                        diferenciasDeInventariosInfo.
                                        AlmacenInventarioLote.
                                        AlmacenInventarioLoteId,
                                    Piezas     = 0,
                                    ProductoID =
                                        diferenciasDeInventariosInfo.Producto.
                                        ProductoId,
                                    Precio =
                                        diferenciasDeInventariosInfo.
                                        AlmacenInventarioLote.PrecioPromedio,
                                    Cantidad =
                                        diferenciasDeInventariosInfo.
                                        DiferenciaInventario,
                                    Importe =
                                        diferenciasDeInventariosInfo.
                                        DiferenciaInventario *
                                        diferenciasDeInventariosInfo.
                                        AlmacenInventarioLote.PrecioPromedio,
                                    UsuarioCreacionID = usuarioInfo.UsuarioID
                                };
                                long almacenMovimientoDetalleID =
                                    almacenMovimientoDetalleBl.Crear(almacenMovimientoDetalleInfo);


                                //Se valida si requiere autorizacion
                                if (diferenciasDeInventariosInfo.RequiereAutorizacion)
                                {
                                    var almacenBl = new AlmacenBL();
                                    AlmacenMovimientoInfo almacenMovimientoInfo = new AlmacenMovimientoInfo
                                    {
                                        AlmacenID           = diferenciasDeInventariosInfo.Almacen.AlmacenID,
                                        AlmacenMovimientoID = almacenMovimientoId
                                    };
                                    almacen = almacenBl.ObtenerAlmacenMovimiento(almacenMovimientoInfo);

                                    var autorizacionMateriaPrimaInfo = new AutorizacionMateriaPrimaInfo
                                    {
                                        OrganizacionID     = usuarioInfo.OrganizacionID,
                                        TipoAutorizacionID = TipoAutorizacionEnum.AjustedeInventario.GetHashCode(),
                                        Folio           = almacen.FolioMovimiento,
                                        Justificacion   = almacen.Observaciones,
                                        Lote            = diferenciasDeInventariosInfo.AlmacenInventarioLote.Lote,
                                        Precio          = almacenMovimientoDetalleInfo.Precio,
                                        Cantidad        = almacenMovimientoDetalleInfo.Cantidad,
                                        ProductoID      = almacenMovimientoDetalleInfo.ProductoID,
                                        AlmacenID       = almacen.AlmacenID,
                                        EstatusID       = Estatus.AMPPendien.GetHashCode(),
                                        UsuarioCreacion = usuarioInfo.UsuarioID,
                                        Activo          = EstatusEnum.Activo.GetHashCode()
                                    };

                                    var almacenInventarioLoteBL = new AlmacenInventarioLoteBL();
                                    almacenInventarioLoteBL.GuardarAutorizacionMateriaPrima(
                                        autorizacionMateriaPrimaInfo);
                                }
                                //SE AGREGA DETALLE
                                almacenMovimientoDetalleInfo.AlmacenMovimientoDetalleID = almacenMovimientoDetalleID;
                                diferenciasDeInventariosInfo.AlmacenMovimientoDetalle   = almacenMovimientoDetalleInfo;
                                //SE AGREGA DETALLE
                            }
                        }
                        else
                        {
                            if (diferenciasDeInventariosInfo.AlmacenMovimiento.Status ==
                                Estatus.DifInvAplicado.GetHashCode())
                            {
                                //Actualizar estatus a regitro
                                //Agregar observaciones
                                almacenMovimientoBl.ActualizarEstatus(diferenciasDeInventariosInfo.AlmacenMovimiento);

                                //Actualizar detalle movimiento
                                var almacenMovimientoDetalleInfo =
                                    almacenMovimientoDetalleBl.ObtenerPorAlmacenMovimientoDetalleId(
                                        diferenciasDeInventariosInfo.AlmacenMovimientoDetalle);
                                almacenMovimientoDetalleInfo.Cantidad =
                                    diferenciasDeInventariosInfo.DiferenciaInventario;
                                almacenMovimientoDetalleInfo.Importe = almacenMovimientoDetalleInfo.Cantidad *
                                                                       almacenMovimientoDetalleInfo.Precio;
                                almacenMovimientoDetalleInfo.UsuarioModificacionID = usuarioInfo.UsuarioID;
                                almacenMovimientoDetalleBl.ActualizarAlmacenMovimientoDetalle(
                                    almacenMovimientoDetalleInfo);
                                //Actualizamos inventario y lote
                                ActualizarInventarioYLote(diferenciasDeInventariosInfo, usuarioInfo.UsuarioID);
                                //SE AGREGA DETALLE
                                diferenciasDeInventariosInfo.AlmacenMovimientoDetalle = almacenMovimientoDetalleInfo;
                                //SE AGREGA DETALLE
                            }

                            //Guardado con estatus pendiente se actualiza almacen movimiento y almacen movimiento detalle
                            if (diferenciasDeInventariosInfo.AlmacenMovimiento.Status ==
                                Estatus.DifInvPendiente.GetHashCode())
                            {
                                //Actualizar almacen movimiento
                                almacenMovimientoBl.ActualizarEstatus(diferenciasDeInventariosInfo.AlmacenMovimiento);

                                //Actualizar movimiento detalle
                                //Verificar si se ocupa obtenerlo
                                var almacenMovimientoDetalleInfo =
                                    almacenMovimientoDetalleBl.ObtenerPorAlmacenMovimientoDetalleId(
                                        diferenciasDeInventariosInfo.AlmacenMovimientoDetalle);
                                almacenMovimientoDetalleInfo.Cantidad =
                                    diferenciasDeInventariosInfo.DiferenciaInventario;
                                almacenMovimientoDetalleInfo.Importe = almacenMovimientoDetalleInfo.Cantidad *
                                                                       almacenMovimientoDetalleInfo.Precio;
                                //Pendiente usuario modificacion
                                almacenMovimientoDetalleInfo.UsuarioModificacionID = usuarioInfo.UsuarioID;
                                almacenMovimientoDetalleBl.ActualizarAlmacenMovimientoDetalle(
                                    almacenMovimientoDetalleInfo);
                                //SE AGREGA DETALLE
                                diferenciasDeInventariosInfo.AlmacenMovimientoDetalle = almacenMovimientoDetalleInfo;
                                //SE AGREGA DETALLE
                            }
                        }
                    }

                    #region POLIZA

                    var listaDiferenciasInventarioAplicados =
                        listaDiferenciasInventario.Where(dif => dif.AlmacenMovimiento.Status == Estatus.DifInvAplicado.GetHashCode()).ToList();

                    List <PolizaEntradaSalidaPorAjusteModel> salidasPorAjuste =
                        listaDiferenciasInventarioAplicados.Where(dif => !dif.DescripcionAjuste.Trim().Equals(TipoAjusteEnum.CerrarLote.ToString().Trim(), StringComparison.InvariantCultureIgnoreCase)).Select(ajuste => new PolizaEntradaSalidaPorAjusteModel
                    {
                        Importe =
                            ajuste.DiferenciaInventario *
                            ajuste.AlmacenInventarioLote.
                            PrecioPromedio,
                        Cantidad   = ajuste.DiferenciaInventario,
                        TipoAjuste =
                            ajuste.DescripcionAjuste.Equals(
                                TipoAjusteEnum.Merma.ToString(),
                                StringComparison.
                                CurrentCultureIgnoreCase)
                                    ? TipoAjusteEnum.Merma
                                    : TipoAjusteEnum.Superávit,
                        Precio = ajuste.AlmacenInventarioLote.
                                 PrecioPromedio,
                        AlmacenInventarioID =
                            ajuste.AlmacenInventarioLote.
                            AlmacenInventario.AlmacenInventarioID,
                        AlmacenMovimientoDetalleID =
                            ajuste.AlmacenMovimientoDetalle.
                            AlmacenMovimientoDetalleID,
                        ProductoID = ajuste.Producto.ProductoId,
                        CantidadInventarioFisico =
                            ajuste.KilogramosFisicos,
                        CantidadInventarioTeorico =
                            ajuste.KilogramosTeoricos,
                        Observaciones =
                            ajuste.AlmacenMovimiento.Observaciones
                    }).ToList();
                    var agrupado =
                        salidasPorAjuste.GroupBy(tipo => new { tipo.TipoAjuste, tipo.AlmacenMovimientoDetalleID }).Select(
                            ajuste => new PolizaEntradaSalidaPorAjusteModel
                    {
                        TipoAjuste                 = ajuste.Key.TipoAjuste,
                        AlmacenInventarioID        = ajuste.First().AlmacenInventarioID,
                        AlmacenMovimientoDetalleID = ajuste.Key.AlmacenMovimientoDetalleID,
                        Cantidad = ajuste.First().Cantidad,
                        CantidadInventarioFisico  = ajuste.First().CantidadInventarioFisico,
                        CantidadInventarioTeorico = ajuste.First().CantidadInventarioTeorico,
                        Importe                 = ajuste.First().Importe,
                        Observaciones           = ajuste.First().Observaciones,
                        Precio                  = ajuste.First().Precio,
                        PrecioInventarioFisico  = ajuste.First().PrecioInventarioFisico,
                        PrecioInventarioTeorico = ajuste.First().PrecioInventarioTeorico,
                        ProductoID              = ajuste.First().ProductoID
                    }).ToList();
                    if (agrupado != null && agrupado.Any())
                    {
                        streams = new List <MemoryStream>();
                        for (int indexAjustes = 0; indexAjustes < agrupado.Count; indexAjustes++)
                        {
                            var tipoPoliza = TipoPoliza.SalidaAjuste;
                            switch (agrupado[indexAjustes].TipoAjuste)
                            {
                            case TipoAjusteEnum.Superávit:
                                tipoPoliza = TipoPoliza.EntradaAjuste;
                                break;
                            }
                            poliza = FabricaPoliza.ObtenerInstancia().ObtenerTipoPoliza(tipoPoliza);
                            var grupo = new List <PolizaEntradaSalidaPorAjusteModel>
                            {
                                agrupado[indexAjustes]
                            };
                            polizas = poliza.GeneraPoliza(grupo);
                            if (polizas != null && polizas.Any())
                            {
                                MemoryStream stream = poliza.ImprimePoliza(grupo, polizas);
                                if (stream != null)
                                {
                                    streams.Add(stream);
                                }
                                var polizaBL = new PolizaBL();
                                polizas.ToList().ForEach(datos =>
                                {
                                    datos.OrganizacionID         = organizacionID;
                                    datos.UsuarioCreacionID      = usuarioId;
                                    datos.ArchivoEnviadoServidor = 1;
                                });
                                polizaBL.GuardarServicioPI(polizas, tipoPoliza);
                            }
                        }
                    }

                    #endregion POLIZA


                    transaction.Complete();
                }
            }
            catch (ExcepcionServicio ex)
            {
                Logger.Error(ex);
                throw;
            }
            catch (ExcepcionGenerica)
            {
                throw;
            }
            catch (Exception ex)
            {
                Logger.Error(ex);
                throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
            }
            return(streams);
        }
        /// <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);
        }
Beispiel #14
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);
            }
        }
Beispiel #15
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);
            }
        }
        /// <summary>
        /// guardar cierre dia inventario
        /// </summary>
        /// <param name="datosGrid"></param>
        /// <param name="almacenCierreDiaInventario"></param>
        /// <returns></returns>
        public int GuardarCierreDiaInventario(IList <AlmacenCierreDiaInventarioInfo> datosGrid, AlmacenCierreDiaInventarioInfo almacenCierreDiaInventario)
        {
            try
            {
                int result = 0;

                int usuarioCreacionID  = almacenCierreDiaInventario.UsuarioCreacionId;
                var almacenCierreFolio = new AlmacenCierreDiaInventarioInfo
                {
                    Almacen           = almacenCierreDiaInventario.Almacen,
                    TipoMovimiento    = TipoMovimiento.InventarioFisico.GetHashCode(),
                    FolioAlmacen      = almacenCierreDiaInventario.FolioAlmacen,
                    Observaciones     = almacenCierreDiaInventario.Observaciones,
                    Estatus           = EstatusInventario.Pendiente.GetHashCode(),
                    UsuarioCreacionId = usuarioCreacionID,
                };

                int organizacionID = almacenCierreDiaInventario.OrganizacionId;

                List <AnimalMovimientoInfo>       animalesNoReimplantados = null;
                List <ProgramacionReinplanteInfo> corralesProgramados     = null;
                List <LoteInfo> lotesDestino = null;
                List <LoteInfo> lotesOrigen  = null;

                var animalMovimientoBL = new AnimalMovimientoBL();
                var loteBL             = new LoteBL();
                if (almacenCierreFolio.Almacen != null &&
                    almacenCierreFolio.Almacen.TipoAlmacen.TipoAlmacenID == TipoAlmacenEnum.ReimplanteGanado.GetHashCode())
                {
                    var reimplanteBL = new ReimplanteBL();
                    corralesProgramados = reimplanteBL.ObtenerCorralesParaAjuste(organizacionID);
                    if (corralesProgramados != null && corralesProgramados.Any())
                    {
                        corralesProgramados.ForEach(dato =>
                        {
                            dato.OrganizacionID        = organizacionID;
                            dato.UsuarioModificacionID = usuarioCreacionID;
                        });
                        List <LoteInfo> lotes = corralesProgramados.Select(id => new LoteInfo
                        {
                            LoteID = id.LoteID
                        }).ToList();
                        animalesNoReimplantados =
                            animalMovimientoBL.ObtenerAnimalesNoReimplantadosXML(organizacionID, lotes);
                        if (animalesNoReimplantados != null && animalesNoReimplantados.Any())
                        {
                            animalesNoReimplantados.ForEach(dato =>
                            {
                                dato.TipoMovimientoID  = TipoMovimiento.EntradaPorAjusteAnimal.GetHashCode();
                                dato.UsuarioCreacionID = usuarioCreacionID;
                            });
                            lotesDestino = animalesNoReimplantados.Select(lote => new LoteInfo
                            {
                                LoteID = lote.LoteID
                            }).ToList();
                            lotesOrigen = animalesNoReimplantados.Select(lote => new LoteInfo
                            {
                                LoteID = lote.LoteIDOrigen
                            }).ToList();
                            IEnumerable <LoteInfo> lotesEnumerable = loteBL.ObtenerPorLoteXML(lotesDestino);
                            if (lotesEnumerable != null)
                            {
                                lotesDestino = lotesEnumerable.ToList();
                            }
                            lotesEnumerable = loteBL.ObtenerPorLoteXML(lotesOrigen);
                            if (lotesEnumerable != null)
                            {
                                lotesOrigen = lotesEnumerable.ToList();
                            }
                            List <AnimalMovimientoInfo> animalesPorLoteDestino = animalesNoReimplantados
                                                                                 .Select(ani => new AnimalMovimientoInfo
                            {
                                LoteID = ani.LoteID
                            }).ToList();
                            List <AnimalMovimientoInfo> animalesPorLoteOrigen = animalesNoReimplantados
                                                                                .Select(ani => new AnimalMovimientoInfo
                            {
                                LoteID = ani.LoteID
                            }).ToList();
                            lotesDestino.ForEach(id =>
                            {
                                int cabezas              = animalesPorLoteDestino.Count(loteID => loteID.LoteID == id.LoteID);
                                id.Cabezas              += cabezas;
                                id.CabezasInicio        += cabezas;
                                id.UsuarioModificacionID = usuarioCreacionID;
                            });
                            lotesOrigen.ForEach(id =>
                            {
                                int cabezas = animalesPorLoteOrigen.Count(loteID => loteID.LoteID == id.LoteID);
                                id.Cabezas -= cabezas;
                                id.UsuarioModificacionID = usuarioCreacionID;
                            });
                        }
                    }
                }

                var transactionOption = new TransactionOptions();
                transactionOption.IsolationLevel = IsolationLevel.ReadUncommitted;
                using (var transaction = new TransactionScope(TransactionScopeOption.Required, transactionOption))
                {
                    Logger.Info();
                    var cierreDiaInventarioDAL   = new CierreDiaInventarioDAL();
                    var programacionReimplanteBl = new ProgramacionReimplanteBL();
                    #region AjusteDeCorralesReimplante

                    if (animalesNoReimplantados != null && animalesNoReimplantados.Any())
                    {
                        animalMovimientoBL.GuardarAnimalMovimientoXML(animalesNoReimplantados);
                        ////Se actualizan las cabezas que tiene el lote
                        loteBL.ActualizaNoCabezasEnLoteXML(lotesDestino, lotesOrigen);

                        //Se elimina la programacin reimplante del lote

                        programacionReimplanteBl.EliminarProgramacionReimplanteXML(corralesProgramados);
                    }

                    if (almacenCierreFolio.Almacen != null &&
                        almacenCierreFolio.Almacen.TipoAlmacen.TipoAlmacenID == TipoAlmacenEnum.ReimplanteGanado.GetHashCode())
                    {
                        programacionReimplanteBl.CerrarProgramacionReimplante(organizacionID, usuarioCreacionID);
                    }

                    #endregion AjusteDeCorralesReimplante

                    #region GuardarCierreDeDia

                    AlmacenCierreDiaInventarioInfo resultadoAlmacenMovimiento =
                        cierreDiaInventarioDAL.GuardarAlmacenMovimiento(almacenCierreFolio);

                    almacenCierreFolio.UsuarioCreacionId   = resultadoAlmacenMovimiento.UsuarioCreacionId;
                    almacenCierreFolio.AlmacenMovimientoID = resultadoAlmacenMovimiento.AlmacenMovimientoID;

                    result = cierreDiaInventarioDAL.GuardarProductosCierreDiaInventario(datosGrid,
                                                                                        almacenCierreFolio);

                    #endregion GuardarCierreDeDia

                    #region POLIZA
                    var almacenMovimientoInventarioBL = new AlmacenMovimientoBL();
                    List <ContenedorAlmacenMovimientoCierreDia> contenedorMovimientoCierreDia =
                        almacenMovimientoInventarioBL.ObtenerMovimientosInventario(almacenCierreDiaInventario.Almacen.AlmacenID,
                                                                                   almacenCierreDiaInventario.OrganizacionId);
                    if (contenedorMovimientoCierreDia != null && contenedorMovimientoCierreDia.Any())
                    {
                        contenedorMovimientoCierreDia.ForEach(
                            x => x.FolioAlmacen       = almacenCierreDiaInventario.FolioAlmacen);
                        contenedorMovimientoCierreDia =
                            contenedorMovimientoCierreDia.Join(datosGrid, contenedor => contenedor.Producto.ProductoId,
                                                               grid => grid.ProductoID, (con, grd) => con).ToList();
                        var             poliza       = FabricaPoliza.ObtenerInstancia().ObtenerTipoPoliza(TipoPoliza.ConsumoProducto);
                        List <DateTime> foliosFechas =
                            contenedorMovimientoCierreDia.Select(
                                x => Convert.ToDateTime(x.AlmacenMovimiento.FechaMovimiento.ToShortDateString())).
                            Distinct().OrderBy(
                                fecha => fecha).ToList();
                        List <ContenedorAlmacenMovimientoCierreDia> movimientosPorDia;
                        var cierreDiaFechas = new List <ContenedorAlmacenMovimientoCierreDia>();
                        for (var indexFecha = 0; indexFecha < foliosFechas.Count; indexFecha++)
                        {
                            movimientosPorDia =
                                contenedorMovimientoCierreDia.Where(
                                    x =>
                                    Convert.ToDateTime(x.AlmacenMovimiento.FechaMovimiento.ToShortDateString()).Equals(
                                        foliosFechas[indexFecha])).ToList();
                            IList <PolizaInfo> polizaConsumo = poliza.GeneraPoliza(movimientosPorDia);
                            if (polizaConsumo != null && polizaConsumo.Any())
                            {
                                var polizaBL = new PolizaBL();
                                polizaConsumo.ToList().ForEach(datos =>
                                {
                                    datos.UsuarioCreacionID =
                                        almacenCierreDiaInventario.UsuarioCreacionId;
                                    datos.OrganizacionID =
                                        almacenCierreDiaInventario.OrganizacionId;
                                    datos.ArchivoEnviadoServidor = 1;
                                });
                                polizaBL.GuardarServicioPI(polizaConsumo, TipoPoliza.ConsumoProducto);
                                cierreDiaFechas.AddRange(movimientosPorDia);
                            }
                        }
                        var almacenMovimientoBL = new AlmacenMovimientoBL();
                        cierreDiaFechas.ForEach(
                            datos => datos.Almacen.UsuarioModificacionID = almacenCierreDiaInventario.UsuarioCreacionId);
                        almacenMovimientoBL.ActualizarGeneracionPoliza(cierreDiaFechas);
                    }
                    #endregion POLIZA

                    transaction.Complete();
                }
                return(result);
            }
            catch (ExcepcionServicio ex)
            {
                Logger.Error(ex);
                throw;
            }
            catch (ExcepcionGenerica)
            {
                throw;
            }
            catch (Exception ex)
            {
                Logger.Error(ex);
                throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
            }
        }
        /// <summary>
        /// Metodo que da salida por venta al ganado intensivo cuano se selcciona tipoventa Externo
        /// </summary>
        /// <param name="salidaIndividual"></param>
        /// <returns></returns>
        internal MemoryStream GuardarSalidaGanadoVentaIntensiva(SalidaIndividualInfo salidaIndividual)
        {
            MemoryStream retorno = null;

            try
            {
                PolizaAbstract      poliza;
                IList <PolizaInfo>  polizaSalidaVenta;
                TicketInfo          Ticket            = new TicketInfo();
                CorralInfo          corralInfo        = new CorralInfo();
                CorralBL            corralB           = new CorralBL();
                GanadoIntensivoBL   salidaGanadoCosto = new GanadoIntensivoBL();
                GanadoIntensivoInfo salidaGanadoInfo  = new GanadoIntensivoInfo();


                corralInfo = corralB.ObtenerCorralActivoPorCodigo(salidaIndividual.Organizacion, salidaIndividual.Corral);
                corralInfo.Organizacion = new OrganizacionInfo();
                corralInfo.Organizacion.OrganizacionID = salidaIndividual.Organizacion;
                salidaGanadoInfo = salidaGanadoCosto.ObtenerMuerteGanadoIntensivo(corralInfo);
                salidaGanadoInfo.Organizacion = new OrganizacionInfo();
                salidaGanadoInfo.Organizacion.OrganizacionID = salidaIndividual.Organizacion;
                salidaGanadoInfo.Observaciones = "";



                Ticket.FolioTicket  = salidaIndividual.FolioTicket;
                Ticket.Organizacion = salidaIndividual.Organizacion;

                var ventaGanadoBL = new VentaGanadoBL();

                VentaGanadoInfo salidaPorVentaGanado = ventaGanadoBL.ObtenerVentaGanadoPorTicket(Ticket);

                var      loteBL            = new LoteBL();
                CorralBL corralBl          = new CorralBL();
                LoteInfo lote              = loteBL.ObtenerPorID(salidaPorVentaGanado.LoteID);
                int      iCabezasTotalLote = lote.Cabezas;

                lote.Cabezas -= salidaIndividual.NumeroDeCabezas;
                //lote.Corral = corralBl.ObtenerCorralPorLoteID(lote.LoteID, salidaIndividual.Organizacion);
                //lote.Corral = corralBl.ObtenerCorralPorCodigo()

                using (var scope = new TransactionScope())
                {
                    Logger.Info();
                    var salidaIndividualDAL = new SalidaIndividualDAL();

                    var filtroActualizaCabezas = new FiltroActualizarCabezasLote
                    {
                        LoteIDOrigen          = lote.LoteID,
                        LoteIDDestino         = 0,
                        CabezasProcesadas     = salidaIndividual.NumeroDeCabezas,
                        UsuarioModificacionID = salidaIndividual.Usuario
                    };
                    loteBL.ActualizarCabezasProcesadas(filtroActualizaCabezas);

                    salidaGanadoInfo.ListaGanadoIntensivoCosto = new List <GanadoIntensivoCostoInfo>();
                    foreach (
                        var entradaCosteo in
                        salidaGanadoInfo.EntradaGanadoCosteo.ListaCostoEntrada.OrderBy(id => id.Costo.CostoID))
                    {
                        var costoInt = new GanadoIntensivoCostoInfo();
                        costoInt.Costos = new CostoInfo();
                        costoInt.Costos = entradaCosteo.Costo;
                        costoInt.Costos.ImporteCosto = (entradaCosteo.Importe /
                                                        salidaGanadoInfo.EntradaGanado.CabezasRecibidas) *
                                                       salidaIndividual.NumeroDeCabezas;
                        costoInt.Importe = costoInt.Costos.ImporteCosto;
                        salidaGanadoInfo.ListaGanadoIntensivoCosto.Add(costoInt);
                    }
                    salidaGanadoInfo.TipoMovimientoID = TipoMovimiento.SalidaVentaIntensivo;
                    //salidaIndividualDAL.GuardarSalidaIndividualGanadoVenta(salidaIndividual);
                    salidaGanadoInfo.TotalCabezas                = salidaIndividual.NumeroDeCabezas;
                    salidaGanadoInfo.FolioTicket                 = salidaIndividual.FolioTicket;
                    salidaGanadoInfo.TipoFolio                   = TipoFolio.VentaGanadoIntensivo;
                    salidaGanadoInfo.PesoBruto                   = salidaIndividual.PesoBruto;
                    salidaGanadoInfo.UsuarioCreacionID           = salidaIndividual.Usuario;
                    salidaGanadoInfo.Organizacion.OrganizacionID = salidaIndividual.Organizacion;
                    salidaGanadoInfo.CabezasText                 = salidaIndividual.NumeroDeCabezas.ToString();
                    salidaGanadoCosto.Guardar(salidaGanadoInfo);

                    #region Poliza

                    List <ContenedorVentaGanado> ventasGanado =
                        ventaGanadoBL.ObtenerVentaGanadoIntensivoPorTicketPoliza(Ticket);

                    if (ventasGanado != null && ventasGanado.Any())
                    {
                        poliza = FabricaPoliza.ObtenerInstancia().ObtenerTipoPoliza(TipoPoliza.SalidaVentaIntensiva);
                        for (int i = 0; i < ventasGanado.Count; i++)
                        {
                            ventasGanado[i].EntradaGandoId = salidaGanadoInfo.EntradaGanado.EntradaGanadoID;
                            ventasGanado[i].OrganizacionId = Ticket.Organizacion;
                            ventasGanado[i].Lote           = lote;
                        }

                        polizaSalidaVenta = poliza.GeneraPoliza(ventasGanado);
                        if (polizaSalidaVenta != null && polizaSalidaVenta.Any())
                        {
                            polizaSalidaVenta.ToList().ForEach(
                                org =>
                            {
                                org.OrganizacionID         = Ticket.Organizacion;
                                org.UsuarioCreacionID      = salidaIndividual.Usuario;
                                org.ArchivoEnviadoServidor = 1;
                            });
                            retorno = poliza.ImprimePoliza(ventasGanado, polizaSalidaVenta);
                            var polizaBL = new PolizaBL();
                            polizaBL.GuardarServicioPI(polizaSalidaVenta, TipoPoliza.SalidaVentaIntensiva);
                        }
                    }

                    // Genera el xml y lo guarda en la ruta especificada en la configuración
                    var facturaBl = new FacturaBL();
                    facturaBl.GenerarDatosFacturaVentaDeGanadoIntensivo(Ticket.FolioTicket, Ticket.Organizacion);

                    #endregion Poliza

                    scope.Complete();
                }

                return(retorno);
            }
            catch (ExcepcionServicio ex)
            {
                Logger.Error(ex);
                throw;
            }
            catch (ExcepcionGenerica)
            {
                throw;
            }
            catch (Exception ex)
            {
                Logger.Error(ex);
                throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
            }
        }
        /// <summary>
        /// Metodo que le da salida por venta al ganado
        /// </summary>
        /// <param name="salidaIndividual"></param>
        /// <returns></returns>
        internal MemoryStream GuardarSalidaIndividualGanadoVenta(SalidaIndividualInfo salidaIndividual)
        {
            MemoryStream retorno = null;

            try
            {
                PolizaAbstract     poliza;
                IList <PolizaInfo> polizaSalidaVenta;
                TicketInfo         Ticket = new TicketInfo();

                Ticket.FolioTicket  = salidaIndividual.FolioTicket;
                Ticket.Organizacion = salidaIndividual.Organizacion;
                Ticket.TipoVenta    = salidaIndividual.TipoVenta;

                var ventaGanadoBL = new VentaGanadoBL();

                VentaGanadoInfo salidaPorVentaGanado = ventaGanadoBL.ObtenerVentaGanadoPorTicket(Ticket);


                var      loteBL = new LoteBL();
                LoteInfo lote   = loteBL.ObtenerPorID(salidaPorVentaGanado.LoteID);
                lote.Cabezas -= salidaIndividual.NumeroDeCabezas;

                AnimalBL animalBl = new AnimalBL();

                using (var scope = new TransactionScope())
                {
                    Logger.Info();
                    var salidaIndividualDAL = new SalidaIndividualDAL();

                    VentaGanadoDetalleBL          ventaGanadoDetalleBl    = new VentaGanadoDetalleBL();
                    List <VentaGanadoDetalleInfo> listaVentaGanadoDetalle = ventaGanadoDetalleBl.ObtenerVentaGanadoPorTicket(salidaPorVentaGanado.VentaGanadoID);
                    List <AnimalCostoInfo>        animalCosto             = new List <AnimalCostoInfo>();
                    AnimalCostoBL     animalCostoBl    = new AnimalCostoBL();
                    List <AnimalInfo> animalesConsulta = new List <AnimalInfo>();
                    List <AnimalInfo> animalesProcesar = new List <AnimalInfo>();
                    foreach (VentaGanadoDetalleInfo ventaGanado in listaVentaGanadoDetalle)
                    {
                        animalesConsulta   = new List <AnimalInfo>();
                        ventaGanado.Animal = animalBl.ObtenerAnimalPorArete(ventaGanado.Arete, Ticket.Organizacion);

                        if (ventaGanado.Animal == null)
                        {
                            ventaGanado.Animal = animalBl.ObtenerAnimalPorAreteTestigo(ventaGanado.AreteMetalico, Ticket.Organizacion);
                        }
                        animalesConsulta.Add(ventaGanado.Animal);
                        animalCosto = animalCostoBl.ObtenerCostosAnimal(animalesConsulta);

                        if (!animalCosto.Any(registro => registro.CostoID == Costo.CostoGanado.GetHashCode()))
                        {
                            animalesProcesar.Add(ventaGanado.Animal);
                        }
                    }

                    if (animalesProcesar != null && animalesProcesar.Count > 0)
                    {
                        animalBl.ProcesoGenerarCostos(animalesProcesar);
                    }

                    salidaIndividualDAL.GuardarSalidaIndividualGanadoVenta(salidaIndividual);
                    salidaIndividualDAL.GuardarCostosHistoricos(salidaIndividual);
                    salidaIndividualDAL.GuardarConsumoHistoricos(salidaIndividual);
                    salidaIndividualDAL.GuardarAnimalHistoricos(salidaIndividual);

                    var filtroActualizaCabezas = new FiltroActualizarCabezasLote
                    {
                        LoteIDOrigen          = lote.LoteID,
                        LoteIDDestino         = 0,
                        CabezasProcesadas     = salidaIndividual.NumeroDeCabezas,
                        UsuarioModificacionID = salidaIndividual.Usuario
                    };
                    loteBL.ActualizarCabezasProcesadas(filtroActualizaCabezas);

                    //loteBL.ActualizaNoCabezasEnLote(lote, lote);

                    #region Poliza

                    List <ContenedorVentaGanado> ventasGanado =
                        ventaGanadoBL.ObtenerVentaGanadoPorTicketPoliza(Ticket.FolioTicket, Ticket.Organizacion);


                    if (ventasGanado != null && ventasGanado.Any())
                    {
                        poliza            = FabricaPoliza.ObtenerInstancia().ObtenerTipoPoliza(TipoPoliza.SalidaVenta);
                        polizaSalidaVenta = poliza.GeneraPoliza(ventasGanado);
                        if (polizaSalidaVenta != null && polizaSalidaVenta.Any())
                        {
                            polizaSalidaVenta.ToList().ForEach(
                                org =>
                            {
                                org.OrganizacionID         = Ticket.Organizacion;
                                org.UsuarioCreacionID      = salidaIndividual.Usuario;
                                org.ArchivoEnviadoServidor = 1;
                            });
                            retorno = poliza.ImprimePoliza(ventasGanado, polizaSalidaVenta);
                            var polizaBL = new PolizaBL();
                            polizaBL.GuardarServicioPI(polizaSalidaVenta, TipoPoliza.SalidaVenta);
                        }
                    }

                    // Genera el xml y lo guarda en la ruta especificada en la configuración
                    var facturaBl = new FacturaBL();
                    facturaBl.GenerarDatosFacturaVentaDeGanado(Ticket.FolioTicket, Ticket.Organizacion);

                    #endregion Poliza

                    scope.Complete();
                }
                return(retorno);
            }
            catch (ExcepcionServicio ex)
            {
                Logger.Error(ex);
                throw;
            }
            catch (ExcepcionGenerica)
            {
                throw;
            }
            catch (Exception ex)
            {
                Logger.Error(ex);
                throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
            }
        }
        internal PremezclaDistribucionInfo GuardarPremezclaDistribucion(DistribucionDeIngredientesInfo distribucionIngredientes)
        {
            PremezclaDistribucionInfo distribucion = null;

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

                    distribucionIngredientes.PremezclaDistribucionID = distribucion.PremezclaDistribucionId;

                    distribucion.ListaPremezclaDistribucionCosto =
                        premezclaDistribucionCostoDal.GuardarPremezclaDistribucionCosto(distribucionIngredientes);

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

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

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

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

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

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

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



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

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

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

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


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

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

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

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

                    #region POLIZA

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

                    #endregion POLIZA
                    transaction.Complete();
                }

                return(distribucion);
            }
            catch (ExcepcionServicio ex)
            {
                Logger.Error(ex);
                throw;
            }
            catch (Exception ex)
            {
                Logger.Error(ex);
                throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
            }
        }
Beispiel #20
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);
        }
        /// <summary>
        /// Guarda una lista de interface salida traspaso.
        /// </summary>
        /// <param name="interfaceSalidaTraspaso"></param>
        internal Dictionary <long, decimal> CrearLista(InterfaceSalidaTraspasoInfo interfaceSalidaTraspaso)
        {
            decimal costoGanado = 0;

            try
            {
                var interfaceSalidaTraspasoDal = new InterfaceSalidaTraspasoDAL();
                using (var scope = new TransactionScope())
                {
                    interfaceSalidaTraspaso.TraspasoGanado =
                        interfaceSalidaTraspaso.ListaInterfaceSalidaTraspasoDetalle.Select(det => det.TraspasoGanado).
                        FirstOrDefault();
                    interfaceSalidaTraspaso.SacrificioGanado =
                        interfaceSalidaTraspaso.ListaInterfaceSalidaTraspasoDetalle.Select(det => det.SacrificioGanado).
                        FirstOrDefault();

                    InterfaceSalidaTraspasoInfo interfaceSalidaTraspasoGuardado;

                    if (interfaceSalidaTraspaso.InterfaceSalidaTraspasoId > 0)
                    {
                        Actualizar(interfaceSalidaTraspaso);
                        interfaceSalidaTraspasoGuardado = interfaceSalidaTraspaso;
                    }
                    else
                    {
                        var folioBL = new FolioBL();
                        interfaceSalidaTraspaso.FolioTraspaso = folioBL.ObtenerFolio(interfaceSalidaTraspaso.OrganizacionId
                                                                                     , TipoFolio.TraspasoGanado);
                        interfaceSalidaTraspasoGuardado = Crear(interfaceSalidaTraspaso);
                    }
                    var loteBL = new LoteBL();
                    if (interfaceSalidaTraspaso.ListaInterfaceSalidaTraspasoDetalle.Any())
                    {
                        interfaceSalidaTraspaso.ListaInterfaceSalidaTraspasoDetalle.ForEach(
                            det =>
                            det.InterfaceSalidaTraspasoID = interfaceSalidaTraspasoGuardado.InterfaceSalidaTraspasoId);

                        interfaceSalidaTraspasoDal.CrearLista(interfaceSalidaTraspaso.ListaInterfaceSalidaTraspasoDetalle);
                        List <LoteInfo> lotes = interfaceSalidaTraspaso.ListaInterfaceSalidaTraspasoDetalle
                                                .Select(lote => new LoteInfo
                        {
                            LoteID  = lote.Lote.LoteID,
                            Cabezas = lote.Cabezas,
                            UsuarioModificacionID = lote.UsuarioCreacionID
                        }).ToList();
                        loteBL.AcutalizaCabezasLoteXML(lotes);
                        List <LoteInfo> lotesCabezas = lotes.GroupBy(lote => lote.LoteID).Select(x => new LoteInfo
                        {
                            LoteID  = x.Key,
                            Cabezas = x.Sum(cab => cab.Cabezas),
                            UsuarioModificacionID = x.Select(usu => usu.UsuarioModificacionID).FirstOrDefault()
                        }).ToList();
                        List <LoteInfo> lotesDesactivar =
                            (from ist in interfaceSalidaTraspaso.ListaInterfaceSalidaTraspasoDetalle
                             from lote in lotesCabezas
                             where ist.Lote.Cabezas - lote.Cabezas == 0
                             select lote).ToList();
                        if (lotesDesactivar.Any())
                        {
                            loteBL.DesactivarLoteXML(lotesDesactivar);
                        }
                    }
                    #region POLIZA
                    if (interfaceSalidaTraspasoGuardado.PesoBruto > 0 && interfaceSalidaTraspasoGuardado.PesoTara > 0)
                    {
                        var      polizaBL       = new PolizaBL();
                        int      organizacionID = interfaceSalidaTraspasoGuardado.OrganizacionId;
                        DateTime fechaEnvio     = interfaceSalidaTraspasoGuardado.FechaEnvio;
                        long     folio          = interfaceSalidaTraspasoGuardado.FolioTraspaso;

                        IList <PolizaInfo> polizasGanado =
                            polizaBL.ObtenerPolizaConDocumentoSAPPendientes(TipoPoliza.SalidaGanado, organizacionID, fechaEnvio);
                        if (polizasGanado != null)
                        {
                            polizasGanado = polizasGanado.Where(con => con.Concepto.StartsWith(string.Format("ST-{0} ", folio))).ToList();
                        }
                        if (polizasGanado == null || !polizasGanado.Any())
                        {
                            InterfaceSalidaTraspasoInfo interfaceSalidaTraspasoSacarDetalle =
                                ObtenerInterfaceSalidaTraspasoPorFolioOrganizacion(interfaceSalidaTraspasoGuardado);
                            if (interfaceSalidaTraspasoSacarDetalle != null)
                            {
                                interfaceSalidaTraspasoGuardado.ListaInterfaceSalidaTraspasoDetalle =
                                    interfaceSalidaTraspasoSacarDetalle.ListaInterfaceSalidaTraspasoDetalle;
                            }
                            List <LoteInfo> lotesAnimal = interfaceSalidaTraspasoGuardado.ListaInterfaceSalidaTraspasoDetalle
                                                          .Select(lote => new LoteInfo
                            {
                                LoteID = lote.Lote.LoteID
                            }).ToList();
                            var animalBL = new AnimalBL();
                            List <AnimalInfo> animales
                                = animalBL.ObtenerAnimalesPorLoteXML(lotesAnimal, interfaceSalidaTraspaso.OrganizacionId);
                            int cabezas = interfaceSalidaTraspasoGuardado.ListaInterfaceSalidaTraspasoDetalle
                                          .Sum(cab => cab.Cabezas);
                            if (cabezas > animales.Count)
                            {
                                throw new ExcepcionServicio("No existe suficiente inventario para realizar el traspaso.");
                            }

                            var polizaSalidaGanado =
                                FabricaPoliza.ObtenerInstancia().ObtenerTipoPoliza(TipoPoliza.SalidaGanado);
                            polizasGanado = polizaSalidaGanado.GeneraPoliza(interfaceSalidaTraspasoGuardado);
                            if (polizasGanado != null && polizasGanado.Any())
                            {
                                polizasGanado.ToList().ForEach(datos =>
                                {
                                    datos.OrganizacionID =
                                        interfaceSalidaTraspaso.OrganizacionId;
                                    datos.UsuarioCreacionID =
                                        interfaceSalidaTraspaso.UsuarioModificacionID ??
                                        0;
                                    datos.ArchivoEnviadoServidor = 1;
                                });
                                polizaBL.GuardarServicioPI(polizasGanado, TipoPoliza.SalidaGanado);
                            }
                        }
                        if (polizasGanado != null)
                        {
                            costoGanado =
                                polizasGanado.Where(imp => imp.Importe.IndexOf('-') < 0).Sum(
                                    imp => Convert.ToDecimal(imp.Importe));
                        }
                    }

                    #endregion POLIZA
                    scope.Complete();
                }
            }
            catch (ExcepcionServicio ex)
            {
                Logger.Error(ex);
                throw new ExcepcionServicio(MethodBase.GetCurrentMethod(), ex);
            }
            catch (Exception ex)
            {
                Logger.Error(ex);
                throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
            }
            return(new Dictionary <long, decimal> {
                { interfaceSalidaTraspaso.FolioTraspaso, costoGanado }
            });
        }
Beispiel #22
0
        /// <summary>
        /// Guardar muerte de ganado intenvio
        /// </summary>
        /// <param name="ganadoIntensivo"></param>
        /// <returns></returns>
        public GanadoIntensivoInfo MuerteGanadoIntensivo_Guardar(GanadoIntensivoInfo ganadoIntensivo)
        {
            try
            {
                int result;
                Logger.Info();
                MemoryStream        polizaPDF = null;
                GanadoIntensivoInfo resultado = new GanadoIntensivoInfo();
                using (var transaction = new TransactionScope())
                {
                    var                loteBL = new LoteBL();
                    PolizaAbstract     poliza;
                    IList <PolizaInfo> polizaSalidaMuerteIntensiva;
                    result = Guardar(ganadoIntensivo);
                    resultado.FolioTicket       = result;
                    ganadoIntensivo.FolioTicket = result;
                    var filtroActualizarCabezasLote = new FiltroActualizarCabezasLote
                    {
                        CabezasProcesadas     = ganadoIntensivo.Cabezas,
                        LoteIDOrigen          = ganadoIntensivo.Lote.LoteID,
                        UsuarioModificacionID = ganadoIntensivo.UsuarioCreacionID,
                        LoteIDDestino         = 0
                    };
                    loteBL.ActualizarCabezasProcesadas(filtroActualizarCabezasLote);

                    #region Poliza


                    if (ganadoIntensivo != null)
                    {
                        if (ganadoIntensivo.ListaGanadoIntensivoCosto != null &&
                            ganadoIntensivo.ListaGanadoIntensivoCosto.Any())
                        {
                            poliza = FabricaPoliza.ObtenerInstancia().ObtenerTipoPoliza(TipoPoliza.SalidaMuerteIntensiva);
                            polizaSalidaMuerteIntensiva = poliza.GeneraPoliza(ganadoIntensivo);
                            if (polizaSalidaMuerteIntensiva != null && polizaSalidaMuerteIntensiva.Any())
                            {
                                polizaSalidaMuerteIntensiva.ToList().ForEach(
                                    org =>
                                {
                                    org.OrganizacionID         = ganadoIntensivo.Organizacion.OrganizacionID;
                                    org.UsuarioCreacionID      = ganadoIntensivo.UsuarioCreacionID;
                                    org.ArchivoEnviadoServidor = 1;
                                });
                                polizaPDF = poliza.ImprimePoliza(ganadoIntensivo, polizaSalidaMuerteIntensiva);
                                var polizaBL = new PolizaBL();
                                polizaBL.GuardarServicioPI(polizaSalidaMuerteIntensiva, TipoPoliza.SalidaMuerteIntensiva);
                                resultado.stream = polizaPDF;
                            }
                        }
                    }
                    #endregion Poliza
                    transaction.Complete();
                }

                return(resultado);
            }
            catch (ExcepcionGenerica)
            {
                throw;
            }
            catch (Exception ex)
            {
                Logger.Error(ex);
                throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
            }
        }
Beispiel #23
0
        /// <summary>
        /// Guarda la salida por muerte en necropsia
        /// </summary>
        /// <param name="muerte"></param>
        /// <returns></returns>
        internal int GuardarSalidaPorMuerteNecropsia(MuerteInfo muerte)
        {
            int retValue;

            try
            {
                Logger.Info();
                var                animalBL             = new AnimalBL();
                var                animalMovimientoBL   = new AnimalMovimientoBL();
                var                corralBL             = new CorralBL();
                var                loteBL               = new LoteBL();
                var                trampaBL             = new TrampaBL();
                var                entradaGanadoBL      = new EntradaGanadoBL();
                var                animalMovimientoInfo = new AnimalMovimientoInfo();
                var                corralInfo           = new CorralInfo();
                var                muerteDAL            = new MuerteDAL();
                PolizaAbstract     poliza;
                IList <PolizaInfo> polizaSalidaMuerte;

                AnimalInfo animalInfo = null;
                using (var transaccion = new TransactionScope())
                {
                    //Se obtiene la info del Corral
                    if (muerte.CorralId > 0)
                    {
                        corralInfo = corralBL.ObtenerPorId(muerte.CorralId);
                    }
                    else if (muerte.CorralCodigo != "")
                    {
                        corralInfo = corralBL.ObtenerCorralPorCodigo(muerte.OrganizacionId,
                                                                     muerte.CorralCodigo);
                    }
                    //Se obtiene la info del Lote
                    LoteInfo loteInfo;
                    if (muerte.LoteId > 0)
                    {
                        loteInfo = loteBL.ObtenerPorID(muerte.LoteId);
                    }
                    else
                    {
                        loteInfo = loteBL.DeteccionObtenerPorCorral(muerte.OrganizacionId, corralInfo.CorralID);
                    }
                    /* Se valida el Grupo del corral */
                    switch (corralInfo.GrupoCorral)
                    {
                    case (int)GrupoCorralEnum.Recepcion:
                        /* almacena el animal en el Inventario   */
                        animalInfo = new AnimalInfo
                        {
                            Arete                 = muerte.Arete,
                            AreteMetalico         = muerte.AreteMetalico,
                            FechaCompra           = DateTime.Now,
                            TipoGanadoID          = 1,
                            CalidadGanadoID       = 1, //***
                            ClasificacionGanadoID = 1, //***
                            PesoCompra            = 0,
                            PesoLlegada           = 0, //***
                            FolioEntrada          = 1,
                            OrganizacionIDEntrada = muerte.OrganizacionId,
                            Paletas               = 0,
                            Venta                 = false,
                            Cronico               = false,
                            Activo                = true,
                            UsuarioCreacionID     = muerte.UsuarioCreacionID
                        };

                        var interfazAnimalBl          = new InterfaceSalidaAnimalBL();
                        var interfaceSalidoAnimalInfo =
                            interfazAnimalBl.ObtenerNumeroAreteIndividual(muerte.Arete, muerte.OrganizacionId);
                        int folioEntradaInterfaz = 0;
                        if (interfaceSalidoAnimalInfo != null)
                        {
                            animalInfo.FechaCompra  = interfaceSalidoAnimalInfo.FechaCompra;
                            animalInfo.PesoCompra   = (int)interfaceSalidoAnimalInfo.PesoCompra;
                            animalInfo.TipoGanadoID = interfaceSalidoAnimalInfo.TipoGanado.TipoGanadoID;
                            folioEntradaInterfaz    = interfaceSalidoAnimalInfo.Partida;
                        }

                        EntradaGanadoInfo entradaGanadoInterfaz =
                            entradaGanadoBL.ObtenerEntradasGanadoCosteado(folioEntradaInterfaz, muerte.OrganizacionId);

                        /* Obtener la entrada de ganado del Corral-Lote para conocer el origen */
                        EntradaGanadoInfo entradaGanadoInfo = entradaGanadoBL.ObtenerEntradaPorLote(loteInfo);
                        if (entradaGanadoInfo != null)
                        {
                            if (entradaGanadoInterfaz != null)
                            {
                                if (entradaGanadoInfo.EmbarqueID == entradaGanadoInterfaz.EmbarqueID)
                                {
                                    animalInfo.FolioEntrada = entradaGanadoInterfaz.FolioEntrada;
                                }
                            }
                            if (animalInfo.FolioEntrada == 1)
                            {
                                if (!entradaGanadoInfo.EsRuteo)
                                {
                                    animalInfo.FolioEntrada = entradaGanadoInfo.FolioEntrada;
                                }
                                else
                                {
                                    List <CabezasPartidasModel> partidasRuteo =
                                        entradaGanadoBL.ObtenerCabezasEntradasRuteo(entradaGanadoInfo.EmbarqueID);
                                    if (partidasRuteo != null && partidasRuteo.Any())
                                    {
                                        CabezasPartidasModel partidaConPendientes =
                                            partidasRuteo.OrderByDescending(part => part.CabezasPendientes).
                                            FirstOrDefault();
                                        if (partidaConPendientes != null)
                                        {
                                            animalInfo.FolioEntrada = partidaConPendientes.FolioEntrada;
                                        }
                                    }
                                }
                            }
                            //if (entradaGanadoInfo.TipoOrganizacionOrigenId != (int)TipoOrganizacion.CompraDirecta)
                            //{

                            //}
                            //animalInfo.FolioEntrada = entradaGanadoInfo.FolioEntrada;
                        }
                        /* Se almacena el animalMovimiento */
                        animalInfo = animalBL.GuardarAnimal(animalInfo);
                        break;

                    default:
                        if (muerte.AnimalId > 0)
                        {
                            animalInfo = animalBL.ObtenerAnimalAnimalID(muerte.AnimalId);
                            /* Se busca el animal En Salida Animal */
                            AnimalSalidaInfo animalSalidaInfo =
                                animalBL.ObtenerAnimalSalidaAnimalID(animalInfo.AnimalID);
                            if (animalSalidaInfo != null)
                            {
                                /* Se valida si no esta en una corraleta de sacrificio */
                                CorralInfo corraleta = corralBL.ObtenerPorId(animalSalidaInfo.CorraletaId);
                                if (corraleta != null &&
                                    corraleta.TipoCorral.TipoCorralID == (int)TipoCorral.CorraletaSacrificio)
                                {
                                    /* Se disminuyen las cabezas del lote en todas las ordenes de sacrificio   */
                                    var ordenSacrificioBL = new OrdenSacrificioBL();
                                    ordenSacrificioBL.DecrementarAnimalMuerto(muerte.AnimalId);
                                    /* Eliminar AnimalSalida */
                                    animalBL.EliminarAnimalSalida(animalInfo.AnimalID, loteInfo.LoteID);
                                }
                            }
                        }
                        else
                        {
                            var listaAnimales = animalBL.ObtenerAnimalesPorCorral(corralInfo, muerte.OrganizacionId);
                            if (listaAnimales != null)     //&& listaAnimales.Any())
                            {
                                //animalInfo = listaAnimales.FirstOrDefault(registro => registro.UsuarioCreacionID == 1);
                                animalInfo = listaAnimales.FirstOrDefault(registro => registro.UsuarioCreacionID == 1);
                                if (animalInfo == null)
                                {
                                    animalInfo = listaAnimales.OrderBy(ani => ani.AnimalID).FirstOrDefault();
                                }
                            }
                        }
                        break;
                    }

                    if (animalInfo != null)
                    {
                        animalInfo.UsuarioCreacionID     = muerte.UsuarioCreacionID;
                        animalInfo.UsuarioModificacionID = muerte.UsuarioCreacionID;
                        if (muerte.AnimalId == 0)
                        {
                            muerte.AnimalId = animalInfo.AnimalID;
                        }
                    }

                    /* Se actualiza la muerte con salida por necropsia */
                    muerteDAL.GuardarSalidaPorMuerteNecropsia(muerte);
                    if (animalInfo != null)
                    {
                        if (muerte.Peso == 0)
                        {
                            List <AnimalMovimientoInfo> ultimosMovimiento = animalMovimientoBL.ObtenerUltimoMovimientoAnimal(new List <AnimalInfo> {
                                animalInfo
                            });
                            if (ultimosMovimiento != null && ultimosMovimiento.Any())
                            {
                                AnimalMovimientoInfo ultimoMovimientoAnimal =
                                    ultimosMovimiento.OrderByDescending(ani => ani.AnimalMovimientoID).FirstOrDefault();

                                if (ultimoMovimientoAnimal != null)
                                {
                                    muerte.Peso = ultimoMovimientoAnimal.Peso;
                                }
                            }
                        }
                        /* Insertamos el movimiento de Muerte */
                        var trampaInfo = trampaBL.ObtenerPorHostName(TrampaGlobal.TrampaNecropsia.ToString());
                        if (trampaInfo != null)
                        {
                            animalMovimientoInfo.TrampaID = trampaInfo.TrampaID;
                        }
                        /* Se genera el animal Movimiento para almacenarlo*/
                        animalMovimientoInfo = new AnimalMovimientoInfo
                        {
                            AnimalID          = animalInfo.AnimalID,
                            OrganizacionID    = muerte.OrganizacionId,
                            CorralID          = loteInfo.CorralID,
                            LoteID            = loteInfo.LoteID,
                            Peso              = muerte.Peso,
                            Temperatura       = 0,
                            TipoMovimientoID  = (int)TipoMovimiento.Muerte,
                            TrampaID          = trampaInfo != null ? trampaInfo.TrampaID : 1,
                            OperadorID        = muerte.OperadorNecropsiaId,
                            Observaciones     = muerte.Observaciones,
                            Activo            = EstatusEnum.Activo,
                            UsuarioCreacionID = muerte.UsuarioCreacionID
                        };

                        //Proceso para Guardar Costos
                        AnimalCostoBL     animalCostoBl = new AnimalCostoBL();
                        List <AnimalInfo> animales      = new List <AnimalInfo>();
                        animales.Add(animalInfo);
                        List <AnimalCostoInfo> listaCostos = animalCostoBl.ObtenerCostosAnimal(animales);

                        if (listaCostos == null || listaCostos.Count <= 0)
                        {
                            animales = animalBL.ProcesoGenerarCostos(animales);
                        }
                        else
                        {
                            if (!listaCostos.Any(registro => registro.CostoID == Costo.CostoGanado.GetHashCode()))
                            {
                                animales = animalBL.ProcesoGenerarCostos(animales);
                            }
                        }

                        //Proceso Armar Poliza
                        if (animales != null && animales.Count > 0)
                        {
                            if (animales.FirstOrDefault().ListaCostosAnimal != null && animales.FirstOrDefault().ListaCostosAnimal.Count > 0)
                            {
                                poliza = FabricaPoliza.ObtenerInstancia().ObtenerTipoPoliza(TipoPoliza.SalidaMuerte);
                                List <AnimalCostoInfo> listaCostosAnimal = animales.FirstOrDefault().ListaCostosAnimal;
                                foreach (AnimalCostoInfo animalCosto in listaCostosAnimal)
                                {
                                    animalCosto.OrganizacionID = muerte.OrganizacionId;
                                }
                                polizaSalidaMuerte = poliza.GeneraPoliza(listaCostosAnimal);
                                if (polizaSalidaMuerte != null && polizaSalidaMuerte.Any())
                                {
                                    polizaSalidaMuerte.ToList().ForEach(
                                        org =>
                                    {
                                        org.OrganizacionID         = muerte.OrganizacionId;
                                        org.UsuarioCreacionID      = muerte.UsuarioCreacionID;
                                        org.ArchivoEnviadoServidor = 1;
                                    });
                                    //retorno = poliza.ImprimePoliza(ventasGanado, polizaSalidaMuerte);
                                    var polizaBL = new PolizaBL();
                                    polizaBL.GuardarServicioPI(polizaSalidaMuerte, TipoPoliza.SalidaMuerte);
                                }
                            }
                        }

                        /* Se almacena el animalMovimiento */
                        animalMovimientoBL.GuardarAnimalMovimiento(animalMovimientoInfo);

                        /*  Se da de baja el animal */
                        animalBL.InactivarAnimal(animalInfo);

                        /* Enviar al historico el animal inactivo */
                        var animalMuerto = new List <AnimalInfo> {
                            animalInfo
                        };
                        animalBL.EnviarAHistorico(animalMuerto);
                    }
                    /* Decrementar la cabeza del lote */
                    loteInfo.Cabezas = loteInfo.Cabezas - 1;
                    loteInfo.UsuarioModificacionID = muerte.UsuarioCreacionID;
                    var filtro = new FiltroActualizarCabezasLote
                    {
                        CabezasProcesadas     = 1,
                        LoteIDDestino         = 0,
                        LoteIDOrigen          = loteInfo.LoteID,
                        UsuarioModificacionID = muerte.UsuarioCreacionID
                    };

                    CabezasActualizadasInfo resultadoCabezas = loteBL.ActualizarCabezasProcesadas(filtro);


                    //Si ya no tenemos cabezas en el lote se actualizanb los pesos llegada
                    if (resultadoCabezas.CabezasOrigen <= 0)
                    {
                        if (corralInfo.GrupoCorral == (int)GrupoCorralEnum.Recepcion)
                        {
                            /* Si el corral es de Recepcion */
                            var corteGanadoPl = new CorteGanadoBL();
                            corteGanadoPl.ObtenerPesosOrigenLlegada(muerte.OrganizacionId,
                                                                    loteInfo.CorralID,
                                                                    loteInfo.LoteID);
                        }
                    }

                    transaccion.Complete();
                    retValue = 1;
                }
            }
            catch (ExcepcionGenerica)
            {
                throw;
            }
            catch (Exception ex)
            {
                Logger.Error(ex);
                throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
            }

            return(retValue);
        }
Beispiel #24
0
        /// <summary>
        /// Guarda una recepcion de producto
        /// </summary>
        /// <param name="recepcionProducto"></param>
        /// <returns></returns>
        internal MemoryStream Guardar(RecepcionProductoInfo recepcionProducto)
        {
            try
            {
                MemoryStream       pdf     = null;
                PolizaAbstract     poliza  = null;
                IList <PolizaInfo> polizas = null;
                int organizacionID         = 0;
                var recepcionProductoDal   = new RecepcionProductoDAL();
                using (var transaction = new TransactionScope())
                {
                    int usuarioID = 0;
                    if (GuardarInventario(recepcionProducto))
                    {
                        long almacenMovimiento = GuardarMovimientos(recepcionProducto);

                        recepcionProducto.AlmacenMovimientoId = almacenMovimiento;
                        var recepcionGuardada = recepcionProductoDal.Guardar(recepcionProducto);
                        if (recepcionGuardada != null)
                        {
                            foreach (var recepcionProductoDetalleInfo in recepcionProducto.ListaRecepcionProductoDetalle
                                     )
                            {
                                recepcionProductoDetalleInfo.RecepcionProductoId = recepcionGuardada.RecepcionProductoId;
                                recepcionProductoDetalleInfo.UsuarioCreacion     = new UsuarioInfo()
                                {
                                    UsuarioID =
                                        recepcionProducto.
                                        UsuarioCreacion.UsuarioID
                                };
                                usuarioID      = recepcionProducto.UsuarioCreacion.UsuarioID;
                                organizacionID = recepcionProducto.Proveedor.OrganizacionID;
                                recepcionProductoDetalleInfo.Activo = EstatusEnum.Activo;
                            }

                            var recepcionProductoDetalleBl = new RecepcionProductoDetalleBL();
                            recepcionProductoDetalleBl.Guardar(recepcionProducto.ListaRecepcionProductoDetalle);

                            #region POLIZA

                            poliza =
                                FabricaPoliza.ObtenerInstancia().ObtenerTipoPoliza(TipoPoliza.EntradaCompraMateriaPrima);
                            recepcionProducto.FolioRecepcion = recepcionGuardada.FolioRecepcion;
                            recepcionProducto.FechaRecepcion = recepcionGuardada.FechaRecepcion;
                            polizas = poliza.GeneraPoliza(recepcionProducto);
                            if (polizas != null)
                            {
                                if (organizacionID == 0)
                                {
                                    organizacionID = recepcionProducto.Almacen.Organizacion.OrganizacionID;
                                }
                                var polizaBL = new PolizaBL();
                                polizas.ToList().ForEach(datos =>
                                {
                                    datos.OrganizacionID         = organizacionID;
                                    datos.UsuarioCreacionID      = usuarioID;
                                    datos.ArchivoEnviadoServidor = 1;
                                });
                                polizaBL.GuardarServicioPI(polizas, TipoPoliza.EntradaCompraMateriaPrima);
                                pdf = poliza.ImprimePoliza(recepcionProducto, polizas);
                            }

                            #endregion POLIZA

                            transaction.Complete();
                        }
                    }
                }
                return(pdf);
            }
            catch (ExcepcionServicio ex)
            {
                Logger.Error(ex);
                throw;
            }
            catch (Exception ex)
            {
                Logger.Error(ex);
                throw;
            }
        }