Пример #1
0
        /// <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);
        }
Пример #2
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);
        }
Пример #3
0
        /// <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);
        }
Пример #4
0
        /// <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);
            }
        }