public static CorralInfo ObtenerCorral(string arete)
{
AnimalInfo animal = null;
AnimalMovimientoInfo animalMovimiento = null;
CorralInfo corral = null;
int respuesta = 0;
try
{
var animalPL = new AnimalPL();
var corralPL = new CorralPL();
var seguridad = (SeguridadInfo)HttpContext.Current.Session["Seguridad"];
int organizacionId = seguridad.Usuario.Organizacion.OrganizacionID;
animal = animalPL.ObtenerAnimalPorArete(arete, organizacionId);
animalMovimiento = animalPL.ObtenerUltimoMovimientoAnimal(animal);
corral = corralPL.ObtenerPorId(animalMovimiento.CorralID);
}
catch (Exception ex)
{
Logger.Error(ex);
}
return(corral);
}
/// <summary>
/// Metrodo Para Guardar en en la tabla AnimalMovimiento
/// </summary>
internal AnimalMovimientoInfo GuardarAnimalMovimiento(AnimalMovimientoInfo animalMovimientoInfo)
{
try
{
Logger.Info();
var parameters = AuxAnimalMovimientoDAL.ObtenerParametrosCrearAnimalMovimiento(animalMovimientoInfo);
var ds = Retrieve("AnimalMovimiento_Guardar", parameters);
AnimalMovimientoInfo result = null;
if (ValidateDataSet(ds))
{
result = MapAnimalMovimientosDAL.ObtenerAnimalMovimiento(ds);
}
return(result);
}
catch (SqlException ex)
{
Logger.Error(ex);
throw new ExcepcionServicio(MethodBase.GetCurrentMethod(), ex);
}
catch (DataException ex)
{
Logger.Error(ex);
throw new ExcepcionServicio(MethodBase.GetCurrentMethod(), ex);
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
}
/// <summary>
/// Obtener totales
/// </summary>
/// <param name="animalInfo"></param>
/// <returns></returns>
internal CorteTransferenciaTotalCabezasInfo ObtenerTotales(AnimalMovimientoInfo animalInfo)
{
try
{
Logger.Info();
var result = new CorteTransferenciaTotalCabezasInfo();
var parameters = AuxCorteTransferenciaGanado.ObtenerParametrosTotales(animalInfo);
var ds = Retrieve("CorteGanado_ObtenerTotalCabezasRecuperacion", parameters);
if (ValidateDataSet(ds))
{
result = MapCorteTransferenciaGanadoDAL.ObtenerCabezasCortadas(ds);
}
return(result);
}
catch (SqlException ex)
{
Logger.Error(ex);
throw new ExcepcionServicio(MethodBase.GetCurrentMethod(), ex);
}
catch (DataException ex)
{
Logger.Error(ex);
throw new ExcepcionServicio(MethodBase.GetCurrentMethod(), ex);
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
}
/// <summary>
/// OObtiene el costo de un producto de un tratamiento en un movimiento
/// </summary>
/// <param name="movimiento">se debe de proporcionar Organizacion y animalmovimiento</param>
/// <param name="tratamiento">Identificador del producto</param>
/// <returns></returns>
internal decimal ObtenerCostoPorMovimientoProducto(AnimalMovimientoInfo movimiento, TratamientoProductoInfo tratamiento)
{
try
{
Logger.Info();
Dictionary <string, object> parameters = AuxTratamientoDAL.ObtenerParametrosCostoPorMovimientoProducto(movimiento, tratamiento);
var result = RetrieveValue <decimal>("TratamientoGanado_ObtenerCostoTratamientoPorMovimientoProducto", parameters);
return(result);
}
catch (SqlException ex)
{
Logger.Error(ex);
throw new ExcepcionServicio(MethodBase.GetCurrentMethod(), ex);
}
catch (DataException ex)
{
Logger.Error(ex);
throw new ExcepcionServicio(MethodBase.GetCurrentMethod(), ex);
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
}
internal static AnimalMovimientoInfo ObtenerAnimalMovimiento(DataSet ds)
{
AnimalMovimientoInfo animalMovimientoInfo;
try
{
Logger.Info();
var dt = ds.Tables[ConstantesDAL.DtDatos];
animalMovimientoInfo = new AnimalMovimientoInfo();
foreach (DataRow dr in dt.Rows)
{
animalMovimientoInfo.AnimalID = Convert.ToInt32(dr["AnimalID"]);
animalMovimientoInfo.AnimalMovimientoID = Convert.ToInt64(dr["AnimalMovimientoID"]);
animalMovimientoInfo.OrganizacionID = Convert.ToInt32(dr["OrganizacionID"]);
animalMovimientoInfo.CorralID = Convert.ToInt32(dr["CorralID"]);
animalMovimientoInfo.LoteID = Convert.ToInt32(dr["LoteID"]);
animalMovimientoInfo.FechaMovimiento = Convert.ToDateTime(dr["FechaMovimiento"]);
animalMovimientoInfo.Peso = Convert.ToInt32(dr["Peso"]);
animalMovimientoInfo.Temperatura = Convert.ToDouble(dr["Temperatura"]);
animalMovimientoInfo.TipoMovimientoID = Convert.ToInt32(dr["TipoMovimientoID"]);
animalMovimientoInfo.TrampaID = Convert.ToInt32(dr["TrampaID"]);
animalMovimientoInfo.OperadorID = Convert.ToInt32(dr["OperadorID"]);
animalMovimientoInfo.Observaciones = Convert.ToString(dr["Observaciones"]);
animalMovimientoInfo.Activo = Convert.ToInt32(dr["Activo"]) == 0 ? EstatusEnum.Inactivo : EstatusEnum.Activo;
animalMovimientoInfo.FechaCreacion = Convert.ToDateTime(dr["FechaCreacion"]);
animalMovimientoInfo.UsuarioCreacionID = Convert.ToInt32(dr["UsuarioCreacionID"]);
}
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
return(animalMovimientoInfo);
}
/// <summary>
/// OObtiene el costo de un tratamiento en un movimiento
/// </summary>
/// <param name="movimiento">se debe de proporcionar Organizacion y animalmovimiento</param>
/// <param name="tratamientoID">Identificador del producto</param>
/// <returns></returns>
internal decimal ObtenerCostoPorMovimiento(AnimalMovimientoInfo movimiento, int tratamientoID)
{
try
{
Logger.Info();
Dictionary <string, object> parameters = AuxTratamientoDAL.ObtenerParametrosCostoPorMovimiento(movimiento, tratamientoID);
DataSet ds = Retrieve("TratamientoGanado_ObtenerCostoTratamientoPorMovimiento", parameters);
decimal result = 0;
if (ValidateDataSet(ds))
{
result = MapTratamientoDAL.ObtenerCosto(ds);
}
return(result);
}
catch (SqlException ex)
{
Logger.Error(ex);
throw new ExcepcionServicio(MethodBase.GetCurrentMethod(), ex);
}
catch (DataException ex)
{
Logger.Error(ex);
throw new ExcepcionServicio(MethodBase.GetCurrentMethod(), ex);
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
}
/// <summary>
/// Se obtiene el ultimo movimiento por tipo
/// </summary>
/// <param name="animal"></param>
/// <returns></returns>
internal AnimalMovimientoInfo ObtenerUltimoMovimientoEnfermeria(AnimalInfo animal)
{
try
{
Logger.Info();
Dictionary <string, object> parametros = AuxEnfermeriaDAL.ObtenerParametrosUltimoMovimientoEnfermeria(animal);
DataSet ds = Retrieve("Movimientos_ObtenerUltimoMovimientoPorTipo", parametros);
AnimalMovimientoInfo animalMovimiento = null;
if (ValidateDataSet(ds))
{
animalMovimiento = MapAnimalMovimientosDAL.ObtenerAnimalMovimiento(ds);
}
return(animalMovimiento);
}
catch (SqlException ex)
{
Logger.Error(ex);
throw new ExcepcionServicio(MethodBase.GetCurrentMethod(), ex);
}
catch (DataException ex)
{
Logger.Error(ex);
throw new ExcepcionServicio(MethodBase.GetCurrentMethod(), ex);
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
}
/// <summary>
/// Obtener el utimo movimiento de recuperacion
/// </summary>
/// <param name="animalInfo"></param>
/// <returns></returns>
internal AnimalMovimientoInfo ObtenerUltimoMovimientoRecuperacion(AnimalInfo animalInfo)
{
try
{
Logger.Info();
var parametros =
AuxEnfermeriaDAL.ObtenerParametrosUltimoMovimientoRecuperacion(animalInfo);
DataSet ds = Retrieve("AnimalMovimiento_ObtenerUltimoMovimientoAnimal", parametros);
AnimalMovimientoInfo animalMovimiento = null;
if (ValidateDataSet(ds))
{
animalMovimiento = MapAnimalMovimientosDAL.ObtenerAnimalMovimiento(ds);
}
return(animalMovimiento);
}
catch (SqlException ex)
{
Logger.Error(ex);
throw new ExcepcionServicio(MethodBase.GetCurrentMethod(), ex);
}
catch (DataException ex)
{
Logger.Error(ex);
throw new ExcepcionServicio(MethodBase.GetCurrentMethod(), ex);
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
}
/// <summary>
/// Metodo que obtiene si existen La info del animal
/// </summary>
/// <param name="ds"></param>
/// <returns></returns>
internal static AnimalInfo ObtenerExistenciaAnimal(DataSet ds)
{
AnimalInfo animalInfo = null;
try
{
Logger.Info();
DataTable dt = ds.Tables[ConstantesDAL.DtDatos];
animalInfo = new AnimalInfo();
var listaMovimiento = new List <AnimalMovimientoInfo>();
foreach (DataRow dr in ds.Tables[0].Rows)
{
var animmalMovimientoInfo = new AnimalMovimientoInfo();
animmalMovimientoInfo.TipoMovimientoID = Convert.ToInt32(dr["TipoMovimientoID"]);
listaMovimiento.Add(animmalMovimientoInfo);
animalInfo.AnimalID = Convert.ToInt32(dr["AnimalID"]);
animalInfo.Arete = Convert.ToString(dr["Arete"]);
animalInfo.AreteMetalico = Convert.ToString(dr["AreteMetalico"]);
animalInfo.FechaCompra = Convert.ToDateTime(dr["FechaCompra"]);
animalInfo.TipoGanadoID = Convert.ToInt32(dr["TipoGanadoID"]);
animalInfo.CalidadGanadoID = Convert.ToInt32(dr["CalidadGanadoID"]);
animalInfo.ClasificacionGanadoID = Convert.ToInt32(dr["ClasificacionGanadoID"]);
animalInfo.PesoCompra = Convert.ToInt32(dr["PesoCompra"]);
animalInfo.OrganizacionIDEntrada = Convert.ToInt32(dr["OrganizacionIDEntrada"]);
animalInfo.FolioEntrada = Convert.ToInt32(dr["FolioEntrada"]);
animalInfo.PesoLlegada = Convert.ToInt32(dr["PesoLlegada"]);
animalInfo.Paletas = Convert.ToInt32(dr["Paletas"]);
if (dr["CausaRechadoID"] is DBNull)
{
animalInfo.CausaRechadoID = 0;
}
else
{
animalInfo.CausaRechadoID = Convert.ToInt32(dr["CausaRechadoID"]);
}
animalInfo.Venta = Convert.ToBoolean(dr["Venta"]);
animalInfo.Cronico = Convert.ToBoolean(dr["Cronico"]);
animalInfo.Activo = Convert.ToBoolean(dr["Activo"]);
animalInfo.FechaCreacion = Convert.ToDateTime(dr["FechaCreacion"]);
animalInfo.UsuarioCreacionID = Convert.ToInt32(dr["UsuarioCreacionID"]);
//animalInfo.FechaModificacion = Convert.ToDateTime(dr["FechaModificacion"]);
//animalInfo.UsuarioModificacionID = Convert.ToInt32(dr["UsuarioModificacionID"]);
animalInfo.CorralID = Convert.ToInt32(dr["CorralID"]);
animalInfo.CodigoCorral = Convert.ToString(dr["Codigo"]);
}
animalInfo.ListaAnimalesMovimiento = listaMovimiento;
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
return(animalInfo);
}
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);
}
}
/// <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>
/// Obtener total de cabezas
/// </summary>
/// <param name="animalInfo"></param>
/// <returns></returns>
///
private bool ObtenerTotalCabezas(AnimalMovimientoInfo animalInfo)
{
var objObtenerCabezas = new CorteTransferenciaGanadoDAL();
var resultado = objObtenerCabezas.ObtenerTotales(animalInfo);
if (resultado == null)
{
return(false);
}
if (resultado.TotalCortadas != resultado.Total)
{
return(false);
}
return(true);
}
public string ActualizarCorralesCabezas(AnimalMovimientoInfo animalMovimiento, int loteOrigen)
{
try
{
Logger.Info();
var corralBl = new CorralBL();
return(corralBl.ActualizarCorralesCabezas(animalMovimiento, loteOrigen));
}
catch (ExcepcionGenerica)
{
throw;
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
}
public void ActualizarSalidaEnfermeria(AnimalMovimientoInfo resultadoLoteOrigen)
{
try
{
Logger.Info();
var loteBL = new LoteBL();
loteBL.ActualizarSalidaEnfermeria(resultadoLoteOrigen);
}
catch (ExcepcionGenerica)
{
throw;
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
}
public void EliminarSalidaEnfermeria(AnimalMovimientoInfo loteCorralOrigen)
{
try
{
Logger.Info();
var loteBL = new LoteBL();
loteBL.EliminarSalidaEnfermeria(loteCorralOrigen);
}
catch (ExcepcionGenerica)
{
throw;
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
}
/// <summary>
/// Guardar animal salida
/// </summary>
/// <param name="corralInfo"></param>
/// <param name="animalMovimientoInfo"></param>
public int GuardarCorralAnimalSalida(CorralInfo corralInfo, AnimalMovimientoInfo animalMovimientoInfo)
{
try
{
Logger.Info();
var animalBl = new AnimalBL();
var animalInfo = animalBl.GuardarCorralAnimalSalida(corralInfo, animalMovimientoInfo);
return(animalInfo);
}
catch (ExcepcionGenerica)
{
throw;
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
}
/// <summary>
/// Obtener parametros para consultar totales de corte por transferencia.
/// </summary>
/// <param name="trampaInfo"></param>
/// <param name="animal"></param>
/// <returns></returns>
internal static Dictionary <string, object> ObtenerParametrosTotales(AnimalMovimientoInfo animal)
{
try
{
Logger.Info();
var parametros =
new Dictionary <string, object>
{
{ "@LoteID", animal.LoteID },
{ "@TipoMovimiento", (int)TipoMovimiento.CortePorTransferencia },
{ "@Activo", (int)EstatusEnum.Activo }
};
return(parametros);
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
}
/// <summary>
/// Obtiene el costo de un tratamiento en un movimiento
/// </summary>
/// <param name="movimiento">se debe de proporcionar Organizacion y animalmovimiento</param>
/// <param name="tratamientoId">Identificador del producto</param>
/// <returns></returns>
internal decimal ObtenerCosto(AnimalMovimientoInfo movimiento, int tratamientoId)
{
decimal result;
try
{
Logger.Info();
var tratamientoDal = new TratamientoDAL();
result = tratamientoDal.ObtenerCostoPorMovimiento(movimiento, tratamientoId);
}
catch (ExcepcionGenerica)
{
throw;
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
return(result);
}
/// <summary>
/// Metodo para obetener los totales de corte por transferencia
/// </summary>
/// <param name="animalInfo"></param>
/// <param name="act"></param>
/// <returns></returns>
public CorteTransferenciaTotalCabezasInfo ObtenerTotales(AnimalMovimientoInfo animalInfo)
{
CorteTransferenciaTotalCabezasInfo result;
try
{
Logger.Info();
var objCorteTransferencia = new CorteTransferenciaGanadoBL();
result = objCorteTransferencia.ObtenerTotales(animalInfo);
}
catch (ExcepcionGenerica)
{
throw;
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
return(result);
}
/// <summary>
/// Obtiene el costo de un producto de un tratamiento en un movimiento
/// </summary>
/// <param name="movimiento">se debe de proporcionar Organizacion y animalmovimiento</param>
/// <param name="tratamiento">Identificador del producto</param>
/// <returns></returns>
public decimal ObtenerCostoProducto(AnimalMovimientoInfo movimiento, TratamientoProductoInfo tratamiento)
{
decimal result;
try
{
Logger.Info();
var enfermeriaBl = new EnfermeriaBL();
result = enfermeriaBl.ObtenerCostoProducto(movimiento, tratamiento);
}
catch (ExcepcionGenerica)
{
throw;
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
return(result);
}
/// <summary>
/// Metrodo Para Guardar en en la tabla AnimalMovimiento
/// </summary>
internal AnimalMovimientoInfo GuardarAnimalMovimiento(AnimalMovimientoInfo animalMovimientoInfo)
{
AnimalMovimientoInfo result;
try
{
Logger.Info();
var animalMovimientoDAL = new AnimalMovimientoDAL();
result = animalMovimientoDAL.GuardarAnimalMovimiento(animalMovimientoInfo);
}
catch (ExcepcionGenerica)
{
throw;
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
return(result);
}
internal static List <AnimalMovimientoInfo> ObtenerUltimoMovimientoAnimal(IDataReader reader)
{
var movimientos = new List <AnimalMovimientoInfo>();
try
{
Logger.Info();
AnimalMovimientoInfo elemento;
while (reader.Read())
{
elemento = new AnimalMovimientoInfo
{
AnimalID = Convert.ToInt32(reader["AnimalID"]),
AnimalMovimientoID = Convert.ToInt64(reader["AnimalMovimientoID"]),
OrganizacionID = Convert.ToInt32(reader["OrganizacionID"]),
CorralID = Convert.ToInt32(reader["CorralID"]),
LoteID = Convert.ToInt32(reader["LoteID"]),
FechaMovimiento = Convert.ToDateTime(reader["FechaMovimiento"]),
Peso = Convert.ToInt32(reader["Peso"]),
Temperatura = Convert.ToDouble(reader["Temperatura"]),
TipoMovimientoID = Convert.ToInt32(reader["TipoMovimientoID"]),
TrampaID = Convert.ToInt32(reader["TrampaID"]),
OperadorID = Convert.ToInt32(reader["OperadorID"]),
Observaciones = Convert.ToString(reader["Observaciones"]),
LoteIDOrigen = Convert.ToInt32(reader["LoteIDOrigen"]),
AnimalMovimientoIDAnterior = Convert.ToInt64(reader["AnimalMovimientoIDAnterior"]),
};
movimientos.Add(elemento);
}
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
return(movimientos);
}
/// <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);
}
public void CargarHistorial(HistorialClinicoInfo historialSeleccionado)
{
IList <HistorialClinicoDetalleInfo> detalles = new List <HistorialClinicoDetalleInfo>();
var tratamientoPl = new TratamientoPL();
TratamientoInfo tratamientoInfo = null;
var tratamientoConsultaPl = new TratamientoProductoPL();
var animalMovimiento = new AnimalMovimientoInfo
{
OrganizacionID = historialSeleccionado.OrganizacionID,
AnimalMovimientoID = historialSeleccionado.AnimalMovimientoId
};
if (historialSeleccionado.ListaProblemas != null && historialSeleccionado.ListaProblemas.Any())
{
foreach (var problema in historialSeleccionado.ListaProblemas)
{
if (problema.Tratamientos != null)
{
if (!String.IsNullOrEmpty(historialSeleccionado.Tratamiento.Trim()))
{
//Se separan los tratamientos
string[] listaTratamiento = historialSeleccionado.Tratamiento.Trim().Split(new Char[] { ',' });
foreach (string tratamiento in listaTratamiento)
{
if (tratamiento.Trim() != "")
{
tratamientoInfo = new TratamientoInfo {
TratamientoID = int.Parse(tratamiento.Trim())
};
tratamientoInfo = tratamientoPl.ObtenerPorID(tratamientoInfo.TratamientoID);
var listaDetalles =
tratamientoConsultaPl.ObtenerTratamientoAplicadoPorMovimientoTratamientoID(animalMovimiento, tratamientoInfo);
if (listaDetalles != null)
{
foreach (var historialClinicoDetalleInfo in listaDetalles)
{
historialClinicoDetalleInfo.Problema = problema.Descripcion;
detalles.Add(historialClinicoDetalleInfo);
}
}
}
}
}
/*
* foreach (var tratamiento in problema.Tratamientos)
* {
* var listaDetalles =
* tratamientoConsultaPl.ObtenerTratamientoAplicadoPorMovimientoTratamientoID(animalMovimiento, tratamiento);
* if (listaDetalles != null)
* {
* foreach (var historialClinicoDetalleInfo in listaDetalles)
* {
* historialClinicoDetalleInfo.Problema = problema.Descripcion;
* detalles.Add(historialClinicoDetalleInfo);
* }
* }
* }*/
}
}
}
else if (!String.IsNullOrEmpty(historialSeleccionado.Tratamiento.Trim()))
{
//Se separan los tratamientos
string[] listaTratamiento = historialSeleccionado.Tratamiento.Trim().Split(new Char[] { ',' });
foreach (string tratamiento in listaTratamiento)
{
if (tratamiento.Trim() != "")
{
tratamientoInfo = new TratamientoInfo {
TratamientoID = int.Parse(tratamiento.Trim())
};
tratamientoInfo = tratamientoPl.ObtenerPorID(tratamientoInfo.TratamientoID);
var listaDetalles =
tratamientoConsultaPl.ObtenerTratamientoAplicadoPorMovimientoTratamientoID(animalMovimiento, tratamientoInfo);
if (listaDetalles != null)
{
foreach (var historialClinicoDetalleInfo in listaDetalles)
{
detalles.Add(historialClinicoDetalleInfo);
}
}
}
}
}
GridDetalleHistorial.ItemsSource = detalles;
}
internal static Dictionary <string, object> ObtenerParametrosEliminarSalidaEnfermeria(AnimalMovimientoInfo loteCorralOrigen)
{
Dictionary <string, object> parametros;
try
{
Logger.Info();
parametros = new Dictionary <string, object>
{
{ "@LoteID", loteCorralOrigen.LoteID }
};
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
return(parametros);
}
internal static Dictionary <string, object> ObtenerParametrosActualizarSalidaEnfermeria(AnimalMovimientoInfo resultadoLoteOrigen)
{
Dictionary <string, object> parametros;
try
{
Logger.Info();
parametros = new Dictionary <string, object>
{
{ "@LoteID", resultadoLoteOrigen.LoteID },
{ "@AnimalID", resultadoLoteOrigen.AnimalID },
{ "@UsuarioModificacion", resultadoLoteOrigen.UsuarioCreacionID }
};
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
return(parametros);
}
public static int ObtenerUltimoMovimiento(string arete)
{
AnimalInfo animal = null;
AnimalMovimientoInfo animalMovimiento = null;
CorralInfo corral = null;
List <TratamientoInfo> tratamientos = null;
int respuesta = 0;
try
{
var animalPL = new AnimalPL();
var corralPL = new CorralPL();
var seguridad = (SeguridadInfo)HttpContext.Current.Session["Seguridad"];
int organizacionId = seguridad.Usuario.Organizacion.OrganizacionID;
animal = animalPL.ObtenerAnimalPorArete(arete, organizacionId);
animalMovimiento = animalPL.ObtenerUltimoMovimientoAnimal(animal);
int animalSalida = animalPL.ObtenerExisteSalida(animal.AnimalID);
var tratamiento = new CorteTransferenciaGanadoPL();
tratamientos = tratamiento.ObtenerTratamientosAplicados(animal, -1);
if (tratamientos != null)
{
tratamientos =
tratamientos.Where(
tipo =>
tipo.TipoTratamientoInfo.TipoTratamientoID == TipoTratamiento.Enfermeria.GetHashCode() ||
tipo.TipoTratamientoInfo.TipoTratamientoID ==
TipoTratamiento.EnfermeriaAlCorte.GetHashCode()).
ToList();
for (var i = 0; i < tratamientos.Count; i++)
{
TimeSpan dias = DateTime.Now - tratamientos[i].FechaAplicacion;
if (dias.TotalDays < 30)
{
respuesta = 4; //No han pasado los treinta dias despues de ultimo tratamiento
}
}
}
if (respuesta == 0)
{
if (animalSalida == 0)
{
//if (animalMovimiento.TipoMovimientoID == (int) TipoMovimiento.EntradaEnfermeria)
//{
corral = corralPL.ObtenerPorId(animalMovimiento.CorralID);
if (corral.TipoCorral.TipoCorralID == (int)TipoCorral.Enfermeria ||
corral.TipoCorral.TipoCorralID == (int)TipoCorral.CronicoRecuperacion ||
corral.TipoCorral.TipoCorralID == (int)TipoCorral.CronicoVentaMuerte)
{
if (corral.TipoCorral.TipoCorralID != (int)TipoCorral.CronicoVentaMuerte)
{
respuesta = 1; //El arete es valido
}
else
{
respuesta = 2; //El arete es de tipo cronico
}
}
else
{
respuesta = 0; //El arete no se encuentra en enfermeria
}
//}
//else
//{
// respuesta = 0; //El arete no se encuentra en enfermeria
//}
}
else
{
respuesta = 3; //El arete ya tiene una salida
}
}
}
catch (Exception ex)
{
Logger.Error(ex);
}
return(respuesta);
}
/// <summary>
/// Metodo para guardar la salida a sacrificio a un animal
/// </summary>
/// <param name="animal"></param>
/// <param name="organizacion"></param>
/// <param name="codigoCorral"></param>
/// <param name="corraletaID"></param>
/// <param name="usuarioCreacion"></param>
/// <param name="tipoMovimiento"></param>
/// <param name="operador"></param>
private int GuardarSalidaIndividialSacrificio(AnimalInfo animal, int organizacion, string codigoCorral, int corraletaID, int usuarioCreacion, int tipoMovimiento, int operador)
{
int retorno = 0;
var animalBl = new AnimalBL();
var corralBl = new CorralBL();
var animalMovimientoBl = new AnimalMovimientoBL();
var loteBl = new LoteBL();
var corralOrigen = corralBl.ObtenerCorralPorCodigo(organizacion, codigoCorral);
if (corralOrigen != null)
{
var loteOrigen = loteBl.DeteccionObtenerPorCorral(organizacion, corralOrigen.CorralID);
if (loteOrigen != null)
{
var corralDestino = corralBl.ObtenerPorId(corraletaID);
if (corralDestino != null)
{
var loteDestino = loteBl.DeteccionObtenerPorCorral(organizacion, corralDestino.CorralID);
if (loteDestino == null)
{
// Si el corral destino no tiene lo te se crea uno
var loteBL = new LoteBL();
int loteIDGuardar = 0;
var loteNuevo = new LoteInfo
{
Activo = EstatusEnum.Activo,
Cabezas = 0,
CabezasInicio = 0,
CorralID = corralDestino.CorralID,
DisponibilidadManual = false,
OrganizacionID = organizacion,
TipoCorralID = corralDestino.TipoCorral.TipoCorralID,
TipoProcesoID = TipoProceso.EngordaPropio.GetHashCode(),
UsuarioCreacionID = usuarioCreacion
};
loteIDGuardar = loteBL.GuardaLote(loteNuevo);
loteDestino = new LoteInfo {
LoteID = loteIDGuardar
};
}
// Se obtiene la info del ultimo movimiento del animal
var ultimoMovimiento = animalBl.ObtenerUltimoMovimientoAnimal(animal);
if (ultimoMovimiento != null)
{
var animalMovimientoOrigen = new AnimalMovimientoInfo
{
AnimalID = animal.AnimalID,
CorralID = corralDestino.CorralID,
LoteID = loteDestino.LoteID,
TipoMovimientoID = tipoMovimiento,
OperadorID = operador,
OrganizacionID = organizacion,
TrampaID = ultimoMovimiento.TrampaID,
Peso = ultimoMovimiento.Peso,
Temperatura = ultimoMovimiento.Temperatura,
UsuarioCreacionID = usuarioCreacion
};
animalMovimientoBl.GuardarAnimalMovimiento(animalMovimientoOrigen);
loteOrigen.Cabezas = loteOrigen.Cabezas - 1;
loteDestino.Cabezas = loteDestino.Cabezas + 1;
loteDestino.CabezasInicio = loteDestino.CabezasInicio + 1;
var filtroActualizaCabezas = new FiltroActualizarCabezasLote
{
LoteIDOrigen = loteOrigen.LoteID,
LoteIDDestino = loteDestino.LoteID,
CabezasProcesadas = 1,
UsuarioModificacionID = usuarioCreacion
};
loteBl.ActualizarCabezasProcesadas(filtroActualizaCabezas);
//loteBl.ActualizaNoCabezasEnLote(loteDestino, loteOrigen);
}
else
{
retorno = -1;
}
}
else
{
retorno = -1;
}
}
else
{
retorno = -1;
}
}
else
{
retorno = -1;
}
return(retorno);
}
/// <summary>
///
/// </summary>
/// <param name="animalMovimiento"></param>
/// <param name="tratamiento"></param>
/// <returns></returns>
public List <HistorialClinicoDetalleInfo> ObtenerTratamientoAplicadoPorMovimientoTratamientoID(AnimalMovimientoInfo animalMovimiento, TratamientoInfo tratamiento)
{
try
{
Logger.Info();
var tratamientoProductoBL = new TratamientoProductoBL();
List <HistorialClinicoDetalleInfo> result =
tratamientoProductoBL.ObtenerTratamientoAplicadoPorMovimientoTratamientoID(animalMovimiento, tratamiento);
return(result);
}
catch (ExcepcionGenerica)
{
throw;
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
}
/// <summary>
/// Metodo para Guardar/Modificar un Corral
/// </summary>
/// <param name="arete"></param>
/// <param name="organizacion"></param>
/// <param name="codigoCorral"></param>
/// <param name="corraletaID"></param>
/// <param name="usuarioCreacion"></param>
/// <param name="tipoMovimiento"></param>
/// <param name="operador"></param>
internal int Guardar(string arete, int organizacion, string codigoCorral, int corraletaID, int usuarioCreacion, int tipoMovimiento, int operador)
{
int retorno = 0;
try
{
Logger.Info();
var salidaIndividualDAL = new SalidaIndividualDAL();
var animalBl = new AnimalBL();
var corralBl = new CorralBL();
var loteBl = new LoteBL();
using (var transaccion = new TransactionScope())
{
var animal = animalBl.ObtenerAnimalPorArete(arete, organizacion);
if (animal != null)
{
if (tipoMovimiento == TipoMovimiento.SalidaPorRecuperacion.GetHashCode())
{
var corralOrigen = corralBl.ObtenerCorralPorCodigo(organizacion, codigoCorral);
var loteOrigen = new LoteInfo();
if (corralOrigen != null)
{
loteOrigen = loteBl.DeteccionObtenerPorCorral(organizacion, corralOrigen.CorralID);
}
var corralDestino = corralBl.ObtenerPorId(corraletaID);
var loteDestino = new LoteInfo();
if (corralDestino != null)
{
loteDestino = loteBl.DeteccionObtenerPorCorral(organizacion, corralDestino.CorralID);
}
if (corralOrigen != null)
{
if (loteOrigen != null)
{
if (corralDestino != null)
{
if (corralDestino.TipoCorral.TipoCorralID !=
TipoCorral.CorraletaRecuperado.GetHashCode() && corralDestino.TipoCorral.TipoCorralID != TipoCorral.CorraletaRecuperadosPartida.GetHashCode())
{
if (loteDestino != null)
{
var animalMovimientoBl = new AnimalMovimientoBL();
var ultimoMovimiento = animalBl.ObtenerUltimoMovimientoAnimal(animal);
if (ultimoMovimiento != null)
{
var animalMovimientoOrigen = new AnimalMovimientoInfo
{
AnimalID = animal.AnimalID,
CorralID = corralDestino.CorralID,
LoteID = loteDestino.LoteID,
TipoMovimientoID = tipoMovimiento,
OperadorID = operador,
OrganizacionID = organizacion,
TrampaID = ultimoMovimiento.TrampaID,
Peso = ultimoMovimiento.Peso,
Temperatura = ultimoMovimiento.Temperatura,
UsuarioCreacionID = usuarioCreacion
};
animalMovimientoBl.GuardarAnimalMovimiento(animalMovimientoOrigen);
loteOrigen.Cabezas = loteOrigen.Cabezas - 1;
loteDestino.Cabezas = loteDestino.Cabezas + 1;
loteDestino.CabezasInicio = loteDestino.CabezasInicio + 1;
var filtroActualizaCabezas = new FiltroActualizarCabezasLote
{
LoteIDOrigen = loteOrigen.LoteID,
LoteIDDestino = loteDestino.LoteID,
CabezasProcesadas = 1,
UsuarioModificacionID = usuarioCreacion
};
loteBl.ActualizarCabezasProcesadas(filtroActualizaCabezas);
}
else
{
retorno = -1;
}
}
else
{
retorno = -1;
}
}
else
{
var loteBL = new LoteBL();
var animalMovimientoBl = new AnimalMovimientoBL();
var ultimoMovimiento = animalBl.ObtenerUltimoMovimientoAnimal(animal);
LoteInfo loteDestinoCorraleta = loteBL.DeteccionObtenerPorCorral(organizacion,
corralDestino.CorralID);
int loteIDGuardar = 0;
if (loteDestinoCorraleta == null || loteDestinoCorraleta.Activo == EstatusEnum.Inactivo)
{
var loteNuevo = new LoteInfo
{
Activo = EstatusEnum.Activo,
Cabezas = 1,
CabezasInicio = 1,
CorralID = corralDestino.CorralID,
DisponibilidadManual = false,
OrganizacionID = organizacion,
TipoCorralID = corralDestino.TipoCorral.TipoCorralID,
TipoProcesoID = TipoProceso.EngordaPropio.GetHashCode(),
UsuarioCreacionID = usuarioCreacion
};
loteIDGuardar = loteBL.GuardaLote(loteNuevo);
}
else
{
loteIDGuardar = loteDestinoCorraleta.LoteID;
loteDestinoCorraleta.Cabezas = loteDestinoCorraleta.Cabezas + 1;
var filtroActualizaCabezas = new FiltroActualizarCabezasLote
{
LoteIDOrigen = 0,
LoteIDDestino = loteDestinoCorraleta.LoteID,
CabezasProcesadas = 1,
UsuarioModificacionID = usuarioCreacion
};
loteBl.ActualizarCabezasProcesadas(filtroActualizaCabezas);
//loteBl.ActualizaNoCabezasEnLote(loteDestinoCorraleta, loteDestinoCorraleta);
}
if (ultimoMovimiento != null)
{
var animalMovimientoOrigen = new AnimalMovimientoInfo
{
AnimalID = animal.AnimalID,
CorralID = corralDestino.CorralID,
LoteID = loteIDGuardar,
TipoMovimientoID = tipoMovimiento,
OrganizacionID = organizacion,
OperadorID = operador,
TrampaID = ultimoMovimiento.TrampaID,
Peso = ultimoMovimiento.Peso,
Temperatura = ultimoMovimiento.Temperatura,
UsuarioCreacionID = usuarioCreacion
};
animalMovimientoBl.GuardarAnimalMovimiento(animalMovimientoOrigen);
loteOrigen.Cabezas = loteOrigen.Cabezas - 1;
var filtroActualizaCabezas = new FiltroActualizarCabezasLote
{
LoteIDOrigen = loteOrigen.LoteID,
LoteIDDestino = 0,
CabezasProcesadas = 1,
UsuarioModificacionID = usuarioCreacion
};
loteBl.ActualizarCabezasProcesadas(filtroActualizaCabezas);
}
else
{
retorno = -1;
}
}
}
else
{
retorno = -1;
}
}
else
{
retorno = -1;
}
}
else
{
retorno = -1;
}
}
else//Salida por sacrificio
{
// Se crean los movimientos del animal
retorno = GuardarSalidaIndividialSacrificio(animal, organizacion, codigoCorral, corraletaID, usuarioCreacion, tipoMovimiento, operador);
// Se crea registro en animal Salida
retorno = salidaIndividualDAL.Guardar(arete, organizacion, codigoCorral,
corraletaID, usuarioCreacion, tipoMovimiento);
}
}
else
{
retorno = -1;
}
transaccion.Complete();
}
return(retorno);
}
catch (ExcepcionGenerica)
{
retorno = -1;
throw;
}
catch (Exception ex)
{
retorno = -1;
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
}
