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