private void GenerarMovimientosAnimalesVendidosIntensivo(List <AnimalInfo> animalesMuertos, SalidaIndividualInfo salidaIndividualInfo)
{
var animalMovimientoBL = new AnimalMovimientoBL();
var operadorBL = new OperadorBL();
var animalBL = new AnimalBL();
var listaAnimalesMuertos = new List <AnimalInfo>();
int pesoPromedio = (int)(salidaIndividualInfo.PesoBruto - salidaIndividualInfo.Peso) /
salidaIndividualInfo.NumeroDeCabezas;
foreach (var animalMuerto in animalesMuertos)
{
var animalInfo = animalBL.ObtenerAnimalAnimalID(animalMuerto.AnimalID);
AnimalMovimientoInfo ultimoMovimientoAnimal = null;
List <AnimalMovimientoInfo> ultimosMovimiento = animalMovimientoBL.ObtenerUltimoMovimientoAnimal(new List <AnimalInfo> {
animalInfo
});
if (ultimosMovimiento != null && ultimosMovimiento.Any())
{
ultimoMovimientoAnimal =
ultimosMovimiento.OrderByDescending(ani => ani.AnimalMovimientoID).FirstOrDefault();
}
/* Insertamos el movimiento de Muerte */
/* Se genera el animal Movimiento para almacenarlo*/
if (ultimoMovimientoAnimal != null)
{
OperadorInfo operador = operadorBL.ObtenerPorUsuarioId(salidaIndividualInfo.Usuario, salidaIndividualInfo.Organizacion);
var animalMovimientoInfo = new AnimalMovimientoInfo
{
AnimalID = animalInfo.AnimalID,
OrganizacionID = ultimoMovimientoAnimal.OrganizacionID,
CorralID = ultimoMovimientoAnimal.CorralID,
LoteID = ultimoMovimientoAnimal.LoteID,
Peso = pesoPromedio,
Temperatura = 0,
TipoMovimientoID = (int)TipoMovimiento.SalidaPorVenta,
TrampaID = ultimoMovimientoAnimal.TrampaID,
OperadorID = operador != null ? operador.OperadorID : 0,
Observaciones = string.Empty,
Activo = EstatusEnum.Activo,
UsuarioCreacionID = salidaIndividualInfo.Usuario
};
/* Se almacena el animalMovimiento */
animalMovimientoBL.GuardarAnimalMovimiento(animalMovimientoInfo);
animalInfo.UsuarioModificacionID = salidaIndividualInfo.Usuario;
/* Se da de baja el animal */
animalBL.InactivarAnimal(animalInfo);
/* Enviar al historico el animal inactivo */
listaAnimalesMuertos.Add(animalInfo);
}
}
if (listaAnimalesMuertos.Any())
{
animalBL.EnviarAHistorico(listaAnimalesMuertos);
}
}
internal int GuardarDetalle(GrupoVentaGanadoInfo venta)
{
var animalBL = new AnimalBL();
var corralBl = new CorralBL();
var loteBl = new LoteBL();
try
{
Logger.Info();
int retorno;
using (var transaccion = new TransactionScope())
{
var ventaGanadoDetalleDAL = new VentaGanadoDetalleDAL();
//Obtener Corral y Lote
var corral = corralBl.ObtenerCorralPorCodigo(venta.OrganizacionId, venta.CodigoCorral);
var lote = loteBl.ObtenerPorCorralCerrado(venta.OrganizacionId, corral.CorralID);
if (venta.TipoVenta == Info.Enums.TipoVentaEnum.Propio)
{
//Validar si tenemos animales que pertenezcan a la carga inicial
var listaCargaInicial = venta.VentaGandadoDetalle.Where(animal => animal.Animal.CargaInicial).ToList();
if (listaCargaInicial != null && listaCargaInicial.Any())
{
foreach (var animal in listaCargaInicial)
{
var animalInventario = animalBL.ObtenerAnimalPorArete(animal.Arete, venta.OrganizacionId);
var deteccionGrabar = new DeteccionInfo
{
CorralID = corral.CorralID,
LoteID = lote.LoteID,
UsuarioCreacionID = venta.VentaGanado.UsuarioModificacionID
};
// Se intercambian aretes por encontrarse el animal en un corral distinto y ser carga inicial
animalBL.ReemplazarAretes(animalInventario, deteccionGrabar);
}
}
}
retorno = ventaGanadoDetalleDAL.GuardarDetalle(venta);
// Se cierral la transaccion
transaccion.Complete();
}
return(retorno);
}
catch (ExcepcionGenerica)
{
throw;
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
}
/// <summary>
/// Guarda la informacion de un arete muerto
/// </summary>
/// <param name="muerte"></param>
/// <param name="esCargaInicial"></param>
/// <param name="animal"></param>
/// <returns></returns>
internal int GuardarMuerte(MuerteInfo muerte, FlagCargaInicial esCargaInicial, AnimalInfo animal)
{
try
{
Logger.Info();
int resultado;
using (var transaccion = new TransactionScope())
{
if (animal != null)
{
var animalBL = new AnimalBL();
// Se valida el flag de EsCargaInicial
switch (esCargaInicial)
{
case FlagCargaInicial.EsCargaInicial:
var deteccionGrabar = new DeteccionInfo
{
CorralID = muerte.CorralId,
LoteID = muerte.LoteId,
UsuarioCreacionID = muerte.UsuarioCreacionID
};
// Se intercambian aretes por encontrarse el animal en un corral distinto y ser carga inicial
animalBL.ReemplazarAretes(animal, deteccionGrabar);
break;
case FlagCargaInicial.EsAreteNuevo:
// Se Reemplaza arete nuevo sobre uno existente del lote
animalBL.ReemplazarAreteMismoCorral(animal);
break;
}
}
if (muerte.Corral.GrupoCorral != GrupoCorralEnum.Recepcion.GetHashCode() &&
string.IsNullOrWhiteSpace(muerte.Arete))
{
muerte.Arete = GenerarAreteGenerico(muerte);
}
var muerteDal = new MuerteDAL();
resultado = muerteDal.GuardarMuerte(muerte);
// Se cierral la transaccion
transaccion.Complete();
}
return(resultado);
}
catch (ExcepcionGenerica)
{
throw;
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
}
/// <summary>
/// The validar agregar arete.
/// </summary>
/// <param name="animal">
/// The animal.
/// </param>
/// <param name="corral">
/// The corral.
/// </param>
/// <returns>
/// The <see cref="ResultadoValidacion"/>.
/// </returns>
/// <exception cref="ExcepcionDesconocida">
/// </exception>
internal ResultadoValidacion ValidarAgregarArete(AnimalInfo animal, CorralInfo corral)
{
try
{
var resultado = new ResultadoValidacion();
var animalBl = new AnimalBL();
if (corral == null)
{
resultado.Resultado = false;
resultado.Mensaje = ResourceServices.RevisionImplante_msgFaltaCorral;
return(resultado);
}
AnimalInfo animalResultado = animalBl.ObtenerAnimalPorArete(animal.Arete, animal.OrganizacionIDEntrada);
if (animalResultado == null)
{
resultado.Resultado = false;
resultado.Mensaje = ResourceServices.RevisionImplante_msgAreteInvalido;
return(resultado);
}
AnimalMovimientoInfo movimientos = animalBl.ObtenerUltimoMovimientoAnimal(animalResultado);
if (movimientos == null)
{
resultado.Resultado = false;
resultado.Mensaje = ResourceServices.RevisionImplante_msgSinMovimientos;
return(resultado);
}
if (movimientos.CorralID != corral.CorralID)
{
resultado.Resultado = false;
resultado.Mensaje = ResourceServices.RevisionImplante_msgFaltaCorral;
return(resultado);
}
resultado.Resultado = true;
resultado.Control = animalResultado;
return(resultado);
}
catch (ExcepcionGenerica)
{
throw;
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
}
/// <summary>
/// Obtiene el animal que este muerto
/// </summary>
/// <param name="animal"></param>
/// <param name="deteccionGrabar"></param>
/// <returns></returns>
public void ReemplazarAretes(AnimalInfo animal, DeteccionInfo deteccionGrabar)
{
try
{
Logger.Info();
var animalBL = new AnimalBL();
animalBL.ReemplazarAretes(animal, deteccionGrabar);
}
catch (ExcepcionGenerica)
{
throw;
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
}
/// <summary>
/// Metodo para actualizar los aretes en el animal
/// </summary>
/// <param name="animal"></param>
public void ActializaAretesEnAnimal(AnimalInfo animal)
{
try
{
Logger.Info();
var animalBL = new AnimalBL();
animalBL.ActializaAretesEnAnimal(animal);
}
catch (ExcepcionGenerica)
{
throw;
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
}
/// <summary>
/// Se actualiza clasificacion del animal
/// </summary>
/// <param name="animalInfo"></param>
public void ActualizaClasificacionGanado(AnimalInfo animalInfo)
{
try
{
Logger.Info();
var animalBL = new AnimalBL();
animalBL.ActualizaClasificacionGanado(animalInfo);
}
catch (ExcepcionGenerica)
{
throw;
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
}
/// <summary>
/// Planchar arete a un animal que no esta programado en la orden de sacrificio
/// </summary>
/// <param name="Planchado_Arete_Lote_Request">Relacion de aretes/loteId´s en los cuales se realizara la operacion</param>
/// <param name="usuarioId">Usaurio que realizo la operacion</param>
/// <param name="organizacionId">determina bajo que contexto de planta se realizara el planchado</param>
/// <returns>el numero del animal Id al cual se le realizo el planchado</returns>
public List <ControlSacrificioInfo.SincronizacionSIAP> PlancharAretes(ControlSacrificioInfo.Planchado_AreteLote_Request planchadoAretes, int usuarioID, int organizacionId)
{
try
{
Logger.Info();
var animalBL = new AnimalBL();
return(animalBL.PlancharAretes(planchadoAretes, usuarioID, organizacionId));
}
catch (ExcepcionGenerica)
{
throw;
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
}
/// <summary>
/// Metodo para obtener la trazabilidad del animal
/// </summary>
/// <param name="trazabilidadInfo"></param>
/// <param name="busquedaDuplicado"></param>
/// <returns></returns>
public TrazabilidadAnimalInfo ObtenerTrazabilidadAnimal(TrazabilidadAnimalInfo trazabilidadInfo, bool busquedaDuplicado)
{
try
{
Logger.Info();
var animalBL = new AnimalBL();
return(animalBL.ObtenerTrazabilidadAnimal(trazabilidadInfo, busquedaDuplicado));
}
catch (ExcepcionGenerica)
{
throw;
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
}
internal int GuardarAnimalSalida(List <AnimalInfo> listaAnimales, ProgramacionSacrificioGuardadoInfo programacionSacrificioGuardadoInfo)
{
int result;
try
{
Logger.Info();
var loteBL = new LoteBL();
using (var transaccion = new TransactionScope())
{
var loteInfo = loteBL.ObtenerPorID(programacionSacrificioGuardadoInfo.LoteID);
var deteccionGrabar = new DeteccionInfo
{
CorralID = loteInfo.CorralID,
LoteID = loteInfo.LoteID,
UsuarioCreacionID = programacionSacrificioGuardadoInfo.UsuarioID
};
foreach (var animal in listaAnimales)
{
if (animal != null && animal.CargaInicial)
{
// Se intercambian aretes por encontrarse el animal en un corral distinto y ser carga inicial
var animalBL = new AnimalBL();
animalBL.ReemplazarAretes(animal, deteccionGrabar);
}
}
var programacionSacrificio = new ProgramacionSacrificioDAL();
result = programacionSacrificio.GuardarAnimalSalida(listaAnimales, programacionSacrificioGuardadoInfo);
transaccion.Complete();
}
}
catch (ExcepcionGenerica)
{
throw;
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
return(result);
}
internal int Guardar(DeteccionInfo deteccionGrabar, FlagCargaInicial esCargaInicial, AnimalInfo animal)
{
try
{
Logger.Info();
int resultado;
var transactionOption = new TransactionOptions();
transactionOption.IsolationLevel = System.Transactions.IsolationLevel.ReadCommitted;
using (var transaction = new TransactionScope(TransactionScopeOption.Required, transactionOption))
{
if (animal != null)
{
var animalBL = new AnimalBL();
// Se valida el flag de EsCargaInicial
switch (esCargaInicial)
{
case FlagCargaInicial.EsCargaInicial:
// Se intercambian aretes por encontrarse el animal en un corral distinto y ser carga inicial
animalBL.ReemplazarAretes(animal, deteccionGrabar);
break;
case FlagCargaInicial.EsAreteNuevo:
// Se Reemplaza arete nuevo sobre uno existente del lote
animalBL.ReemplazarAreteMismoCorral(animal);
break;
}
}
var deteccionDAL = new DeteccionDAL();
resultado = deteccionDAL.Guardar(deteccionGrabar);
// Se cierral la transaccion
transaction.Complete();
}
return(resultado);
}
catch (ExcepcionGenerica)
{
throw;
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
}
public int ObtenerLoteSalidaAnimal(string arete, string areteTestigo, int organizacionID)
{
try
{
Logger.Info();
var animalBl = new AnimalBL();
int lote = animalBl.ObtenerLoteSalidaAnimal(arete, areteTestigo, organizacionID);
return(lote);
}
catch (ExcepcionGenerica)
{
throw;
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
}
/// <summary>
/// Guardar animal salida lista
/// </summary>
/// <param name="animalSalida"></param>
/// <returns></returns>
public int GuardarCorralAnimalSalidaLista(List <AnimalSalidaInfo> animalSalida)
{
try
{
Logger.Info();
var animalBl = new AnimalBL();
var animalInfo = animalBl.GuardarCorralAnimalSalidaLista(animalSalida);
return(animalInfo);
}
catch (ExcepcionGenerica)
{
throw;
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
}
public string obtenerExisteMuerteTestigo(string areteTestigo)
{
try
{
Logger.Info();
var animalBl = new AnimalBL();
string areteMuerte = animalBl.obtenerExisteMuerteTestigo(areteTestigo);
return(areteMuerte);
}
catch (ExcepcionGenerica)
{
throw;
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
}
public string ObtenerExisteVentaDetalle(string arete, string areteMetalico)
{
try
{
Logger.Info();
var animalBl = new AnimalBL();
string areteVentaDetalle = animalBl.ObtenerExisteVentaDetalle(arete, areteMetalico);
return(areteVentaDetalle);
}
catch (ExcepcionGenerica)
{
throw;
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
}
public void ActualizarArete(long animalId, string arete, int usuario)
{
try
{
Logger.Info();
var animalBl = new AnimalBL();
animalBl.ActualizarArete(animalId, arete, usuario);
}
catch (ExcepcionGenerica ex)
{
Logger.Error(ex);
throw;
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
}
public void InactivarAnimal(AnimalInfo animalInfo)
{
try
{
Logger.Info();
var animalBl = new AnimalBL();
animalBl.InactivarAnimal(animalInfo);
}
catch (ExcepcionGenerica ex)
{
Logger.Error(ex);
throw;
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
}
/// <summary>
/// Metrodo Para obtener los aretes del corral a detectar
/// </summary>
public List <AnimalInfo> ObtenerAnimalesPorCorralDeteccion(int corralID, bool esPartida)
{
List <AnimalInfo> result;
try
{
Logger.Info();
var animalBL = new AnimalBL();
result = animalBL.ObtenerAnimalesPorCorralDeteccion(corralID, esPartida);
}
catch (ExcepcionGenerica)
{
throw;
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
return(result);
}
/// <summary>
/// Existe arete salida
/// </summary>
/// <param name="salida"></param>
/// <param name="arete"></param>
/// <returns></returns>
public string ObtenerExisteAreteSalida(int salida, string arete)
{
string result;
try
{
Logger.Info();
var animalBL = new AnimalBL();
result = animalBL.ObtenerExisteAreteSalida(salida, arete);
}
catch (ExcepcionGenerica)
{
throw;
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
return(result);
}
/// <summary>
/// Metrodo Para obtener el peso
/// </summary>
public TrampaInfo ObtenerPeso(int organizacionID, int folioEntrada)
{
TrampaInfo result;
try
{
Logger.Info();
var animalBL = new AnimalBL();
result = animalBL.ObtenerPeso(organizacionID, folioEntrada);
}
catch (ExcepcionGenerica)
{
throw;
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
return(result);
}
/// <summary>
/// Metrodo que verifica si existe el nuevo arete, dejar en blanco el arete que no se requiera validar
/// </summary>
/// <param name="Arete">Arete capturado</param>
/// <param name="AreteMetalico">Arete RFID</param>
/// <returns>Verdadero en caso de que se encuentre el arete registro</returns>
public Boolean VerificarExistenciaArete(string Arete, string AreteMetalico, int Organizacion)
{
Boolean result;
try
{
Logger.Info();
var animalBL = new AnimalBL();
result = animalBL.VerificarExistenciaArete(Arete, AreteMetalico, Organizacion);
}
catch (ExcepcionGenerica)
{
throw;
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
return(result);
}
public AnimalInfo ObtenerAnimalPorAreteTestigo(string areteTestigo, int organizacionID)
{
AnimalInfo result;
try
{
Logger.Info();
var animalBL = new AnimalBL();
result = animalBL.ObtenerAnimalPorAreteTestigo(areteTestigo, organizacionID);
}
catch (ExcepcionGenerica)
{
throw;
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
return(result);
}
/// <summary>
/// Obtiene la cantidad de dias despues de la primera entrada a enfermeria de la ultima deteccion para saber cuantos dias tiene en enfermeria
/// </summary>
/// <param name="animal"></param>
/// <returns></returns>
public int ObtenerDiasUltimaDeteccion(AnimalInfo animal)
{
int dias = 0;
try
{
var animalBl = new AnimalBL();
dias = animalBl.ObtenerDiasUltimaDeteccion(animal);
}
catch (ExcepcionGenerica)
{
throw;
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
return(dias);
}
public List <AnimalInfo> ObtenerAnimalesPorLoteID(LoteInfo loteInfo)
{
List <AnimalInfo> result;
try
{
Logger.Info();
var animalBL = new AnimalBL();
result = animalBL.ObtenerAnimalesPorLoteID(loteInfo);
}
catch (ExcepcionGenerica)
{
throw;
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
return(result);
}
public List <AnimalInfo> ObtenerAnimalesPorCorral(CorralInfo corralInfo, int organizacionId)
{
List <AnimalInfo> result;
try
{
Logger.Info();
var animalBL = new AnimalBL();
result = animalBL.ObtenerAnimalesPorCorral(corralInfo, organizacionId);
}
catch (ExcepcionGenerica)
{
throw;
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
return(result);
}
/// <summary>
/// Obtiene los animales que han tenido
/// salida por muerte
/// </summary>
/// <param name="pagina"></param>
/// <param name="animal"></param>
/// <returns></returns>
public ResultadoInfo <AnimalInfo> ObtenerAnimalesMuertosPorPagina(PaginacionInfo pagina, AnimalInfo animal)
{
ResultadoInfo <AnimalInfo> result;
try
{
Logger.Info();
var animalBL = new AnimalBL();
result = animalBL.ObtenerAnimalesMuertosPorPagina(pagina, animal);
}
catch (ExcepcionGenerica)
{
throw;
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
return(result);
}
/// <summary>
/// Metodo para obtener el Animal mas antiguo del corral
/// </summary>
public AnimalInfo ObtenerAnimalAntiguoCorral(int corralID)
{
AnimalInfo result;
try
{
Logger.Info();
var animalBL = new AnimalBL();
result = animalBL.ObtenerAnimalAntiguoCorral(corralID);
}
catch (ExcepcionGenerica)
{
throw;
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
return(result);
}
/// <summary>
/// Obtiene si el animal se encuentra en AnimalSalida
/// </summary>
/// <param name="animalID"></param>
/// <returns></returns>
public int ObtenerExisteSalida(long animalID)
{
int resultado = 0;
try
{
Logger.Info();
var animalBL = new AnimalBL();
resultado = animalBL.ObtenerExisteSalida(animalID);
}
catch (ExcepcionGenerica)
{
throw;
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
return(resultado);
}
/// <summary>
/// Obtiene el animal que este muerto
/// </summary>
/// <param name="animal"></param>
/// <returns></returns>
public AnimalInfo ObtenerAnimalesMuertosPorAnimal(AnimalInfo animal)
{
AnimalInfo result;
try
{
Logger.Info();
var animalBL = new AnimalBL();
result = animalBL.ObtenerAnimalesMuertosPorAnimal(animal);
}
catch (ExcepcionGenerica)
{
throw;
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
return(result);
}
/// <summary>
/// Obtiene el peso proyectado de un animal desde su ultimo movimiento
/// </summary>
/// <param name="arete"></param>
/// <param name="organizacionId"></param>
/// <returns></returns>
public int ObtenerPesoProyectado(string arete, int organizacionId)
{
int resultado = 0;
try
{
Logger.Info();
var animalBL = new AnimalBL();
resultado = animalBL.ObtenerPesoProyectado(arete, organizacionId);
}
catch (ExcepcionGenerica)
{
throw;
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
return(resultado);
}
