Exemplo n.º 1
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);
            }
        }
Exemplo n.º 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);
        }
Exemplo n.º 3
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);
            }
        }