/// <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>
        /// 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);
            }
        }