/// <summary>
        /// Guarda el cambio de un corral a otro en los corrales de recepcion
        /// </summary>
        /// <param name="corralInfoOrigen"></param>
        /// <param name="corralInfoDestino"></param>
        /// <param name="usuarioInfo"></param>
        /// <returns></returns>
        internal bool GuardarTraspasoGanadoCorralesRecepcion(CorralInfo corralInfoOrigen, CorralInfo corralInfoDestino, UsuarioInfo usuarioInfo)
        {
            try
            {
                using (var transaction = new TransactionScope())
                {
                    Logger.Info();
                    //Actualiza el corral al lote
                    var loteBl = new LotePL();
                    var lote   = loteBl.DeteccionObtenerPorCorral(corralInfoOrigen.OrganizacionId, corralInfoOrigen.CorralID);
                    loteBl.ActualizarCorral(lote, corralInfoDestino, usuarioInfo);

                    //Actualiza el corral a la entrada del lote
                    var entradaGanadoBl = new EntradaGanadoBL();
                    entradaGanadoBl.ActualizarCorral(lote, corralInfoDestino, usuarioInfo);
                    transaction.Complete();
                    return(true);
                }
            }
            catch (ExcepcionGenerica ex)
            {
                Logger.Error(ex);
                return(false);
            }
            catch (Exception ex)
            {
                Logger.Error(ex);
                return(false);
            }
        }
Esempio n. 2
0
        /// <summary>
        /// Metodo que obtiene las entradas de ganado por ID de Organizacion
        /// </summary>
        /// <param name="organizacionID"></param>
        /// <param name="corralTipoID"></param>
        /// <returns></returns>
        public List <EntradaGanadoInfo> TraerGanadoPorOrganizacionId(int organizacionID, int corralTipoID)
        {
            ResultadoInfo <EntradaGanadoInfo> entradaGanadoInfo;

            try
            {
                Logger.Info();
                var entradaGanadoBL = new EntradaGanadoBL();
                entradaGanadoInfo = entradaGanadoBL.ObtenerPorIDOrganizacion(organizacionID, corralTipoID);
                if (entradaGanadoInfo != null && entradaGanadoInfo.Lista != null &&
                    entradaGanadoInfo.Lista.Count > 0)
                {
                    var listaBusqueda = (from item in entradaGanadoInfo.Lista
                                         select new EntradaGanadoInfo
                    {
                        Horas = CalcularHorasTranscurridas(item.FechaEntrada, item.FechaSalida),
                        FolioEntrada = item.FolioEntrada,
                        CodigoCorral = item.CodigoCorral,
                        LoteID = item.Lote.LoteID,
                        CodigoLote = item.Lote.Lote,
                        CabezasOrigen = item.CabezasOrigen,
                        PesoTara = item.PesoTara,
                        FechaEntrada = item.FechaEntrada,
                        OrganizacionOrigen = item.OrganizacionOrigen,
                        FolioOrigen = item.FolioOrigen,
                        CorralID = item.CorralID,
                        PesoBruto = item.PesoBruto,
                        FechaSalida = item.FechaSalida,
                        CabezasRecibidas = item.CabezasRecibidas,
                        PesoOrigen = item.PesoOrigen
                    }).ToList();
                    return(listaBusqueda);
                }
                return(null);
            }
            catch (ExcepcionGenerica)
            {
                throw;
            }
            catch (Exception ex)
            {
                Logger.Error(ex);
                throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
            }
        }
Esempio n. 3
0
 /// <summary>
 ///   Metodo que crear una entrada de ganado
 /// </summary>
 /// <param name="entradaGanado"></param>
 public void GuardarEntradaCondicion(EntradaGanadoInfo entradaGanado)
 {
     try
     {
         Logger.Info();
         var entradaGanadoBL = new EntradaGanadoBL();
         entradaGanadoBL.GuardarEntradaCondicion(entradaGanado);
     }
     catch (ExcepcionGenerica)
     {
         throw;
     }
     catch (Exception ex)
     {
         Logger.Error(ex);
         throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
     }
 }
Esempio n. 4
0
 /// <summary>
 ///     Metodo que crear una entrada de ganado
 /// </summary>
 /// <param name="entradaGanado"></param>
 /// /// <param name="actualizarRecibido"></param>
 public int GuardarEntradaGanado(EntradaGanadoInfo entradaGanado, bool actualizarRecibido)
 {
     try
     {
         Logger.Info();
         var entradaGanadoBL = new EntradaGanadoBL();
         return(entradaGanadoBL.GuardarEntradaGanado(entradaGanado, actualizarRecibido));
     }
     catch (ExcepcionGenerica)
     {
         throw;
     }
     catch (Exception ex)
     {
         Logger.Error(ex);
         throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
     }
 }
Esempio n. 5
0
 /// <summary>
 ///     Metodo que crear una entrada de ganado
 /// </summary>
 /// <param name="listaAretes"></param>
 /// /// <param name="entradaGanado"></param>
 public int GuardarReemplazoAretes(List <FiltroAnimalesReemplazoArete> listaAretes, EntradaGanadoInfo entradaGanado)
 {
     try
     {
         Logger.Info();
         var entradaGanadoBL = new EntradaGanadoBL();
         return(entradaGanadoBL.GuardarReemplazoAretes(listaAretes, entradaGanado));
     }
     catch (ExcepcionGenerica)
     {
         throw;
     }
     catch (Exception ex)
     {
         Logger.Error(ex);
         throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
     }
 }
Esempio n. 6
0
 /// <summary>
 ///  Metodo que obtiene las entradas de ganado por Lote
 /// </summary>
 /// <param name="lote"></param>
 /// <returns></returns>
 public EntradaGanadoInfo ObtenerEntradaPorLote(LoteInfo lote)
 {
     try
     {
         Logger.Info();
         var entradaGanadoBl = new EntradaGanadoBL();
         var result          = entradaGanadoBl.ObtenerEntradaPorLote(lote);
         return(result);
     }
     catch (ExcepcionGenerica)
     {
         throw;
     }
     catch (Exception ex)
     {
         Logger.Error(ex);
         throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
     }
 }
Esempio n. 7
0
 /// <summary>
 /// Metodo que obtiene las entradas de ganado por Tipo de Corral
 /// </summary>
 /// <param name="organizacionID"></param>
 /// <param name="corralID"> </param>
 /// <param name="embarqueID"> </param>
 /// <returns></returns>
 public int ObtenerPorCorralDisponible(int organizacionID, int corralID, int embarqueID)
 {
     try
     {
         Logger.Info();
         var entradaGanadoBL = new EntradaGanadoBL();
         int result          = entradaGanadoBL.ObtenerPorCorralDisponible(organizacionID, corralID, embarqueID);
         return(result);
     }
     catch (ExcepcionGenerica)
     {
         throw;
     }
     catch (Exception ex)
     {
         Logger.Error(ex);
         throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
     }
 }
Esempio n. 8
0
        /// <summary>
        /// Metodo que obtiene entradas programadas.
        /// </summary>
        /// <param name="pagina"></param>
        /// <param name="folioEntrada"></param>
        /// <param name="organizacionID"></param>
        /// <returns></returns>
        public ResultadoInfo <EntradaGanadoInfo> ObtenerPartidasProgramadasPorPaginas(PaginacionInfo pagina, int folioEntrada, int organizacionID)
        {
            ResultadoInfo <EntradaGanadoInfo> listaEntradaGanado;

            try
            {
                Logger.Info();
                var entradaGanadoBL = new EntradaGanadoBL();
                listaEntradaGanado = entradaGanadoBL.ObtenerPartidasProgramadasPorPaginas(pagina, folioEntrada, organizacionID);
            }
            catch (ExcepcionGenerica)
            {
                throw;
            }
            catch (Exception ex)
            {
                Logger.Error(ex);
                throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
            }
            return(listaEntradaGanado);
        }
Esempio n. 9
0
        /// <summary>
        /// Metodo para consultar los datos de la entrada para la captura de Calidad de Ganado
        /// </summary>
        /// <param name="filtroCalificacionGanado"></param>
        public EntradaGanadoInfo ObtenerEntradaGanadoCapturaCalidad(FiltroCalificacionGanadoInfo filtroCalificacionGanado)
        {
            EntradaGanadoInfo entradaGanadoInfo;

            try
            {
                Logger.Info();
                var entradaGanadoBL = new EntradaGanadoBL();
                entradaGanadoInfo = entradaGanadoBL.ObtenerEntradaGanadoCapturaCalidad(filtroCalificacionGanado);
            }
            catch (ExcepcionGenerica)
            {
                throw;
            }
            catch (Exception ex)
            {
                Logger.Error(ex);
                throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
            }
            return(entradaGanadoInfo);
        }
Esempio n. 10
0
        /// <summary>
        /// Metodo que obtiene una entrada de ganado por ID
        /// </summary>
        /// <param name="entradaGanadoID"></param>
        /// <returns></returns>
        public EntradaGanadoInfo ObtenerPorID(int entradaGanadoID)
        {
            EntradaGanadoInfo entradaGanadoInfo;

            try
            {
                Logger.Info();
                var entradaGanadoBL = new EntradaGanadoBL();
                entradaGanadoInfo = entradaGanadoBL.ObtenerPorID(entradaGanadoID);
            }
            catch (ExcepcionGenerica)
            {
                throw;
            }
            catch (Exception ex)
            {
                Logger.Error(ex);
                throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
            }
            return(entradaGanadoInfo);
        }
Esempio n. 11
0
        /// <summary>
        /// Obtiene la Entrada de Ganado
        /// </summary>
        /// <param name="folioEntrada"></param>
        /// <param name="organizacionID"></param>
        /// <returns></returns>
        public EntradaGanadoInfo ObtenerEntradasGanadoCosteado(int folioEntrada, int organizacionID)
        {
            EntradaGanadoInfo resultado;

            try
            {
                Logger.Info();
                var entradaGanadoBL = new EntradaGanadoBL();
                resultado = entradaGanadoBL.ObtenerEntradasGanadoCosteado(folioEntrada, organizacionID);
            }
            catch (ExcepcionGenerica)
            {
                throw;
            }
            catch (Exception ex)
            {
                Logger.Error(ex);
                throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
            }
            return(resultado);
        }
Esempio n. 12
0
        /// <summary>
        /// Obtiene entradas de ganado por folio de origen
        /// </summary>
        /// <returns></returns>
        public List <EntradaGanadoInfo> ObtenerEntradasPorFolioOrigenXML(List <EntradaGanadoInfo> foliosOrigen)
        {
            List <EntradaGanadoInfo> resultado;

            try
            {
                Logger.Info();
                var entradaGanadoBL = new EntradaGanadoBL();
                resultado = entradaGanadoBL.ObtenerEntradasPorFolioOrigenXML(foliosOrigen);
            }
            catch (ExcepcionGenerica)
            {
                throw;
            }
            catch (Exception ex)
            {
                Logger.Error(ex);
                throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
            }
            return(resultado);
        }
Esempio n. 13
0
        /// <summary>
        /// Metodo que obtiene las entradas de ganado por ID de Organizacion
        /// </summary>
        /// <param name="organizacionID"></param>
        /// <param name="tipoCorralID"></param>
        /// <returns></returns>
        public ResultadoInfo <EntradaGanadoInfo> ObtenerPorIDOrganizacion(int organizacionID, int tipoCorralID)
        {
            ResultadoInfo <EntradaGanadoInfo> entradaGanadoInfo;

            try
            {
                Logger.Info();
                var entradaGanadoBL = new EntradaGanadoBL();
                entradaGanadoInfo = entradaGanadoBL.ObtenerPorIDOrganizacion(organizacionID, tipoCorralID);
            }
            catch (ExcepcionGenerica)
            {
                throw;
            }
            catch (Exception ex)
            {
                Logger.Error(ex);
                throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
            }
            return(entradaGanadoInfo);
        }
Esempio n. 14
0
        /// <summary>
        /// Metodo que obtiene el catalogo de clasificacion
        /// </summary>
        /// <returns></returns>
        public IList <ClasificacionGanadoInfo> ObtenerCatClasificacion()
        {
            IList <ClasificacionGanadoInfo> catClasificacionInfo;

            try
            {
                Logger.Info();
                var entradaGanadoBl = new EntradaGanadoBL();
                catClasificacionInfo = entradaGanadoBl.ObtenerCatClasificacion();
            }
            catch (ExcepcionGenerica)
            {
                throw;
            }
            catch (Exception ex)
            {
                Logger.Error(ex);
                throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
            }
            return(catClasificacionInfo);
        }
Esempio n. 15
0
        /// <summary>
        /// Metodo que obtiene una entrada De CalidadGanado por sexo
        /// </summary>
        /// <returns></returns>
        public IList <CalidadGanadoInfo> ObtenerCalidadPorSexo(string sexo)
        {
            IList <CalidadGanadoInfo> calidadGanadoInfo;

            try
            {
                Logger.Info();
                var entradaGanadoBL = new EntradaGanadoBL();
                calidadGanadoInfo = entradaGanadoBL.ObtenerCalidadPorSexo(sexo);
            }
            catch (ExcepcionGenerica)
            {
                throw;
            }
            catch (Exception ex)
            {
                Logger.Error(ex);
                throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
            }
            return(calidadGanadoInfo);
        }
Esempio n. 16
0
        ResultadoInfo <EntradaGanadoInfo> IAyudaDependencia <EntradaGanadoInfo> .ObtenerPorId(int Id, IList <IDictionary <IList <string>, object> > Dependencias)
        {
            ResultadoInfo <EntradaGanadoInfo> listaEntradaGanado;

            try
            {
                Logger.Info();
                var entradaGanadoBL = new EntradaGanadoBL();
                listaEntradaGanado = entradaGanadoBL.ObtenerPorId(Id, Dependencias);
            }
            catch (ExcepcionGenerica)
            {
                throw;
            }
            catch (Exception ex)
            {
                Logger.Error(ex);
                throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
            }
            return(listaEntradaGanado);
        }
Esempio n. 17
0
        /// <summary>
        ///     Obtiene un lista paginada de entradas
        /// </summary>
        /// <param name="pagina"></param>
        /// <param name="filtro"></param>
        /// <returns></returns>
        public ResultadoInfo <EntradaGanadoInfo> ObtenerPorPagina(PaginacionInfo pagina, EntradaGanadoInfo filtro)
        {
            ResultadoInfo <EntradaGanadoInfo> resultadoOrganizacion;

            try
            {
                Logger.Info();
                var entradaGanadoBL = new EntradaGanadoBL();
                resultadoOrganizacion = entradaGanadoBL.ObtenerPorPagina(pagina, filtro);
            }
            catch (ExcepcionGenerica)
            {
                throw;
            }
            catch (Exception ex)
            {
                Logger.Error(ex);
                throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
            }
            return(resultadoOrganizacion);
        }
Esempio n. 18
0
        /// <summary>
        /// Metodo que obtiene una entrada de ganado Folio de entrada y Organizacion
        /// </summary>
        /// <param name="filtro"></param>
        /// <returns></returns>
        public EntradaGanadoInfo ObtenerPorFolioEntradaCortadaIncompleta(EntradaGanadoInfo filtro)
        {
            EntradaGanadoInfo resultado;

            try
            {
                Logger.Info();
                var entradaGanadoBL = new EntradaGanadoBL();
                resultado = entradaGanadoBL.ObtenerPorFolioEntradaCortadaIncompleta(filtro);
            }
            catch (ExcepcionGenerica)
            {
                throw;
            }
            catch (Exception ex)
            {
                Logger.Error(ex);
                throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
            }
            return(resultado);
        }
Esempio n. 19
0
        /// <summary>
        /// Metodo que obtiene una entrada de ganado Folio de entrada y Organizacion
        /// </summary>
        /// <param name="filtro"></param>
        /// <returns></returns>
        public List <FiltroAnimalesReemplazoArete> ObtenerReemplazoAretes(EntradaGanadoInfo filtro)
        {
            List <FiltroAnimalesReemplazoArete> listaAretes;

            try
            {
                Logger.Info();
                var entradaGanadoBL = new EntradaGanadoBL();
                listaAretes = entradaGanadoBL.ObtenerReemplazoAretes(filtro);
            }
            catch (ExcepcionGenerica)
            {
                throw;
            }
            catch (Exception ex)
            {
                Logger.Error(ex);
                throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
            }
            return(listaAretes);
        }
Esempio n. 20
0
        /// <summary>
        /// Obtiene la Entrada de Ganado
        /// </summary>
        /// <param name="entradaInfo"></param>
        /// <param name="Dependencias"></param>
        /// <returns></returns>
        public EntradaGanadoInfo ObtenerEntradasGanadoCosteadoPorDependencias(EntradaGanadoInfo entradaInfo, IList <IDictionary <IList <string>, object> > Dependencias)
        {
            EntradaGanadoInfo resultado;

            try
            {
                Logger.Info();
                var entradaGanadoBL = new EntradaGanadoBL();
                resultado = entradaGanadoBL.ObtenerEntradasGanadoCosteadoPorDependencias(entradaInfo, Dependencias);
            }
            catch (ExcepcionGenerica)
            {
                throw;
            }
            catch (Exception ex)
            {
                Logger.Error(ex);
                throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
            }
            return(resultado);
        }
Esempio n. 21
0
        /// <summary>
        /// Obtiene las entradas para su impresion de tarjeta de recepcion
        /// </summary>
        /// <param name="filtro">filtros para obtener las entradas a imprimir</param>
        /// <returns></returns>
        public List <ImpresionTarjetaRecepcionModel> ObtenerEntradasImpresionTarjetaRecepcion(FiltroImpresionTarjetaRecepcion filtro)
        {
            List <ImpresionTarjetaRecepcionModel> resultado;

            try
            {
                Logger.Info();
                var entradaGanadoBL = new EntradaGanadoBL();
                resultado = entradaGanadoBL.ObtenerEntradasImpresionTarjetaRecepcion(filtro);
            }
            catch (ExcepcionGenerica)
            {
                throw;
            }
            catch (Exception ex)
            {
                Logger.Error(ex);
                throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
            }
            return(resultado);
        }
Esempio n. 22
0
        public ResultadoInfo <EntradaGanadoInfo> ObtenerEntradaGanadoCosteadoPaginaPorDependencias(PaginacionInfo Pagina, EntradaGanadoInfo entradaInfo, IList <IDictionary <IList <string>, object> > Dependencias)
        {
            ResultadoInfo <EntradaGanadoInfo> listaEntradaGanado;

            try
            {
                Logger.Info();
                var entradaGanadoBL = new EntradaGanadoBL();
                listaEntradaGanado = entradaGanadoBL.ObtenerEntradaGanadoCosteadoPaginaPorDependencias(Pagina, entradaInfo, Dependencias);
            }
            catch (ExcepcionGenerica)
            {
                throw;
            }
            catch (Exception ex)
            {
                Logger.Error(ex);
                throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
            }
            return(listaEntradaGanado);
        }
Esempio n. 23
0
        /// <summary>
        /// Obtiene entradas de ganado por EntradaGanadoID
        /// </summary>
        /// <param name="embarqueID"></param>
        /// <returns></returns>
        public List <EntradaGanadoInfo> ObtenerEntradasPorEmbarqueID(int embarqueID)
        {
            List <EntradaGanadoInfo> resultado;

            try
            {
                Logger.Info();
                var entradaGanadoBL = new EntradaGanadoBL();
                resultado = entradaGanadoBL.ObtenerEntradasPorEmbarqueID(embarqueID);
            }
            catch (ExcepcionGenerica)
            {
                throw;
            }
            catch (Exception ex)
            {
                Logger.Error(ex);
                throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
            }
            return(resultado);
        }
Esempio n. 24
0
        /// <summary>
        /// Metodo para obtener una partida de compra directa de una lista de partidas para un lote
        /// </summary>
        /// <param name="entradaSeleccionada"></param>
        /// <returns></returns>
        public int ObtenerPartidaCompraDirecta(EntradaGanadoInfo entradaSeleccionada)
        {
            int resultado;

            try
            {
                Logger.Info();
                var entradaGanadoBL = new EntradaGanadoBL();
                resultado = entradaGanadoBL.ObtenerPartidaCompraDirecta(entradaSeleccionada);
            }
            catch (ExcepcionGenerica)
            {
                throw;
            }
            catch (Exception ex)
            {
                Logger.Error(ex);
                throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
            }
            return(resultado);
        }
Esempio n. 25
0
        /// <summary>
        /// Obtiene la Entrada de Ganado
        /// </summary>
        /// <param name="entradaInfo"></param>
        /// <returns></returns>
        public EntradaGanadoInfo ObtenerEntradasGanadoRecibidas(EntradaGanadoInfo entradaInfo)
        {
            EntradaGanadoInfo resultado;

            try
            {
                Logger.Info();
                var entradaGanadoBL = new EntradaGanadoBL();
                resultado = entradaGanadoBL.ObtenerEntradasGanadoRecibidas(entradaInfo);
            }
            catch (ExcepcionGenerica)
            {
                throw;
            }
            catch (Exception ex)
            {
                Logger.Error(ex);
                throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
            }
            return(resultado);
        }
Esempio n. 26
0
        public ResultadoInfo <EntradaGanadoInfo> ObtenerEntradaPaginado(PaginacionInfo pagina, EntradaGanadoInfo entradaInfo)
        {
            ResultadoInfo <EntradaGanadoInfo> listaEntradaGanado;

            try
            {
                Logger.Info();
                var entradaGanadoBL = new EntradaGanadoBL();
                listaEntradaGanado = entradaGanadoBL.ObtenerEntradaPaginado(pagina, entradaInfo);
            }
            catch (ExcepcionGenerica)
            {
                throw;
            }
            catch (Exception ex)
            {
                Logger.Error(ex);
                throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
            }
            return(listaEntradaGanado);
        }
Esempio n. 27
0
 /// <summary>
 /// Obtener muerte de ganado intensivo
 /// </summary>
 /// <param name="corral"></param>
 /// <returns></returns>
 internal GanadoIntensivoInfo ObtenerMuerteGanadoIntensivo(CorralInfo corral)
 {
     try
     {
         Logger.Info();
         var muerteGanadoIntensivoDAL = new GanadoIntensivoDAL();
         GanadoIntensivoInfo muerteGanadoIntensivoInfo = new GanadoIntensivoInfo();
         var      loteBL                = new LoteBL();
         var      entradaGanadoBL       = new EntradaGanadoBL();
         var      entradaGanadoCosteoBL = new EntradaGanadoCosteoBL();
         LoteInfo lote = loteBL.ObtenerLotesActivos(corral.Organizacion.OrganizacionID, corral.CorralID);
         if (lote != null)
         {
             muerteGanadoIntensivoInfo.Lote         = lote;
             muerteGanadoIntensivoInfo.TotalCabezas = lote.Cabezas;
             var entrada = entradaGanadoBL.ObtenerEntradaGanadoLoteCorral(lote);
             if (entrada != null)
             {
                 muerteGanadoIntensivoInfo.EntradaGanado = entrada;
                 EntradaGanadoCosteoInfo entradaGanadoCosteo = entradaGanadoCosteoBL.ObtenerPorEntradaGanadoID(entrada.EntradaGanadoID);
                 if (entradaGanadoCosteo != null)
                 {
                     muerteGanadoIntensivoInfo.EntradaGanadoCosteo = entradaGanadoCosteo;
                 }
             }
         }
         return(muerteGanadoIntensivoInfo);
     }
     catch (ExcepcionGenerica)
     {
         throw;
     }
     catch (Exception ex)
     {
         Logger.Error(ex);
         throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
     }
 }
Esempio n. 28
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);
        }
Esempio n. 29
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);
            }
        }