public int Guardar(GanadoIntensivoInfo ganadoIntensivo)
{
try
{
int result;
Logger.Info();
var ganadoIntensivoDAL = new GanadoIntensivoDAL();
var loteBL = new LoteBL();
result = ganadoIntensivoDAL.Guardar(ganadoIntensivo);
var filtroActualizarCabezasLote = new FiltroActualizarCabezasLote
{
CabezasProcesadas = ganadoIntensivo.Cabezas,
LoteIDOrigen = ganadoIntensivo.Lote.LoteID,
UsuarioModificacionID = ganadoIntensivo.UsuarioCreacionID,
LoteIDDestino = 0
};
//loteBL.ActualizarCabezasProcesadas(filtroActualizarCabezasLote);
return(result);
}
catch (ExcepcionGenerica)
{
throw;
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
}
/// <summary>
/// Actualiza el Numero de Cabezas de los Lotes
/// </summary>
/// <param name="filtroActualizarCabezasLote"></param>
/// <returns></returns>
public CabezasActualizadasInfo ActualizarCabezasProcesadas(
FiltroActualizarCabezasLote filtroActualizarCabezasLote)
{
CabezasActualizadasInfo result = null;
try
{
Logger.Info();
var loteBL = new LoteBL();
result = loteBL.ActualizarCabezasProcesadas(filtroActualizarCabezasLote);
}
catch (ExcepcionGenerica)
{
throw;
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
return(result);
}
/// <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);
}
/// <summary>
/// Genera los Parametros para la Acutalizacion
/// de las Cabezas que tiene un Lote
/// </summary>
/// <param name="filtroActualizarCabezasLote"></param>
/// <returns></returns>
internal static Dictionary <string, object> ObtenerParametrosActualizarCabezasProcesadas(FiltroActualizarCabezasLote filtroActualizarCabezasLote)
{
Dictionary <string, object> parametros;
try
{
Logger.Info();
parametros = new Dictionary <string, object>
{
{ "@LoteIDOrigen", filtroActualizarCabezasLote.LoteIDOrigen },
{ "@LoteIDDestino", filtroActualizarCabezasLote.LoteIDDestino },
{ "@CabezasProcesadas", filtroActualizarCabezasLote.CabezasProcesadas },
{ "@UsuarioModificacionID", filtroActualizarCabezasLote.UsuarioModificacionID }
};
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
return(parametros);
}
/// <summary>
/// Guardar muerte de ganado intenvio
/// </summary>
/// <param name="ganadoIntensivo"></param>
/// <returns></returns>
public GanadoIntensivoInfo MuerteGanadoIntensivo_Guardar(GanadoIntensivoInfo ganadoIntensivo)
{
try
{
int result;
Logger.Info();
MemoryStream polizaPDF = null;
GanadoIntensivoInfo resultado = new GanadoIntensivoInfo();
using (var transaction = new TransactionScope())
{
var loteBL = new LoteBL();
PolizaAbstract poliza;
IList <PolizaInfo> polizaSalidaMuerteIntensiva;
result = Guardar(ganadoIntensivo);
resultado.FolioTicket = result;
ganadoIntensivo.FolioTicket = result;
var filtroActualizarCabezasLote = new FiltroActualizarCabezasLote
{
CabezasProcesadas = ganadoIntensivo.Cabezas,
LoteIDOrigen = ganadoIntensivo.Lote.LoteID,
UsuarioModificacionID = ganadoIntensivo.UsuarioCreacionID,
LoteIDDestino = 0
};
loteBL.ActualizarCabezasProcesadas(filtroActualizarCabezasLote);
#region Poliza
if (ganadoIntensivo != null)
{
if (ganadoIntensivo.ListaGanadoIntensivoCosto != null &&
ganadoIntensivo.ListaGanadoIntensivoCosto.Any())
{
poliza = FabricaPoliza.ObtenerInstancia().ObtenerTipoPoliza(TipoPoliza.SalidaMuerteIntensiva);
polizaSalidaMuerteIntensiva = poliza.GeneraPoliza(ganadoIntensivo);
if (polizaSalidaMuerteIntensiva != null && polizaSalidaMuerteIntensiva.Any())
{
polizaSalidaMuerteIntensiva.ToList().ForEach(
org =>
{
org.OrganizacionID = ganadoIntensivo.Organizacion.OrganizacionID;
org.UsuarioCreacionID = ganadoIntensivo.UsuarioCreacionID;
org.ArchivoEnviadoServidor = 1;
});
polizaPDF = poliza.ImprimePoliza(ganadoIntensivo, polizaSalidaMuerteIntensiva);
var polizaBL = new PolizaBL();
polizaBL.GuardarServicioPI(polizaSalidaMuerteIntensiva, TipoPoliza.SalidaMuerteIntensiva);
resultado.stream = polizaPDF;
}
}
}
#endregion Poliza
transaction.Complete();
}
return(resultado);
}
catch (ExcepcionGenerica)
{
throw;
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
}
/// <summary>
/// guardar corte por transferencia
/// </summary>
/// <param name="guardarAnimalCorte"></param>
/// <param name="listaTratamientos"></param>
/// <returns></returns>
internal CorteTransferenciaGanadoGuardarInfo GuardarCorteTransferencia(CorteTransferenciaGanadoGuardarInfo guardarAnimalCorte, IList <TratamientoInfo> listaTratamientos)
{
try
{
using (var transaction = new TransactionScope())
{
Logger.Info();
//var corteTransferenciaGanado = new CorteTransferenciaGanadoDAL();
var animalBl = new AnimalBL();
var animalMovimientoBL = new AnimalMovimientoBL();
var corralBl = new CorralBL();
var interfaceSalidaAnimalBl = new InterfaceSalidaAnimalBL();
var interfaceSalidoAnimalInfo =
interfaceSalidaAnimalBl.ObtenerNumeroAreteIndividual(
guardarAnimalCorte.AnimalCorteTransferenciaInfo.Arete, guardarAnimalCorte.OrganizacionId);
if (guardarAnimalCorte.AnimalActualInfo != null)
{
guardarAnimalCorte.AnimalCorteTransferenciaInfo.FechaCompra =
guardarAnimalCorte.AnimalActualInfo.FechaCompra;
}
else
{
if (interfaceSalidoAnimalInfo != null)
{
guardarAnimalCorte.AnimalCorteTransferenciaInfo.FechaCompra =
interfaceSalidoAnimalInfo.FechaCompra;
}
}
var resultoAnimalInfo = animalBl.GuardarAnimal(guardarAnimalCorte.AnimalCorteTransferenciaInfo);
guardarAnimalCorte.AnimalCorteTransferenciaInfo = resultoAnimalInfo;
guardarAnimalCorte.AnimalMovimientoCorteTransferenciaInfo.AnimalID =
guardarAnimalCorte.AnimalCorteTransferenciaInfo.AnimalID;
var loteBl = new LoteBL();
var resultadoLote = -1;
var resultadoLoteOrigen = loteBl.ObtenerPorID(guardarAnimalCorte.AnimalMovimientoOrigenInfo.LoteID);
var resultadoLoteBL =
loteBl.ObtenerLotesActivos(
guardarAnimalCorte.AnimalMovimientoCorteTransferenciaInfo.OrganizacionID,
Convert.ToInt32(guardarAnimalCorte.CorralInfoGen.CorralID));
if (resultadoLoteBL == null)
{
//var corralInfo = new CorralInfo
//{
// Codigo = guardarAnimalCorte.TxtCorralDestino,
// TipoCorral = new TipoCorralInfo { TipoCorralID = (int)TipoCorral.Improductivos },
// Organizacion = new OrganizacionInfo { OrganizacionID = guardarAnimalCorte.OrganizacionId }
//};
CorralInfo resultadoCorralPl = corralBl.ObtenerPorId(guardarAnimalCorte.CorralDestinoID);
if (resultadoCorralPl != null)
{
var loteCrear = new LoteBL();
var tipoProcesoBl = new TipoProcesoBL();
var tipoProcesoResult =
tipoProcesoBl.ObtenerPorOrganizacion(guardarAnimalCorte.OrganizacionId);
var loteInfoLote = new LoteInfo
{
Activo = EstatusEnum.Activo,
Cabezas = Convert.ToInt32(0),
CabezasInicio = Convert.ToInt32(0),
CorralID = resultadoCorralPl.CorralID,
DisponibilidadManual = false,
OrganizacionID =
guardarAnimalCorte.AnimalMovimientoOrigenInfo.OrganizacionID,
TipoCorralID = resultadoCorralPl.TipoCorral.TipoCorralID,
TipoProcesoID = tipoProcesoResult,
UsuarioCreacionID = resultadoCorralPl.UsuarioCreacionID,
};
resultadoLote = loteCrear.GuardaLote(loteInfoLote);
guardarAnimalCorte.LoteDestinoInfo = loteCrear.ObtenerPorID(resultadoLote);
}
}
else
{
guardarAnimalCorte.LoteDestinoInfo = resultadoLoteBL;
}
//Se manda a guardar movimiento de salida de enfermeria
//var animalSalidaInfo = new AnimalSalidaInfo();
//animalSalidaInfo = animalBl.ObtenerAnimalSalidaAnimalID(guardarAnimalCorte.AnimalCorteTransferenciaInfo.AnimalID);
//guardarAnimalCorte.AnimalMovimientoCorteTransferenciaInfo.CorralID = animalSalidaInfo.CorralId;
//guardarAnimalCorte.AnimalMovimientoCorteTransferenciaInfo.LoteID = animalSalidaInfo.LoteId;
//guardarAnimalCorte.AnimalMovimientoCorteTransferenciaInfo.TipoMovimientoID = (int)TipoMovimiento.SalidaEnfermeria;
//guardarAnimalCorte.AnimalMovimientoCorteTransferenciaInfo = animalMovimientoBL.GuardarAnimalMovimiento(guardarAnimalCorte.AnimalMovimientoCorteTransferenciaInfo);
//Se manda a guardar movimiento de corte por transferencia
guardarAnimalCorte.AnimalMovimientoCorteTransferenciaInfo.CorralID =
guardarAnimalCorte.CorralInfoGen.CorralID;
guardarAnimalCorte.AnimalMovimientoCorteTransferenciaInfo.LoteID = resultadoLoteBL != null
? resultadoLoteBL.LoteID
: resultadoLote;
guardarAnimalCorte.AnimalMovimientoCorteTransferenciaInfo.TipoMovimientoID =
(int)TipoMovimiento.CortePorTransferencia;
guardarAnimalCorte.AnimalMovimientoCorteTransferenciaInfo =
animalMovimientoBL.GuardarAnimalMovimiento(
guardarAnimalCorte.AnimalMovimientoCorteTransferenciaInfo);
if (guardarAnimalCorte.AnimalMovimientoCorteTransferenciaInfo != null &&
guardarAnimalCorte.AnimalMovimientoCorteTransferenciaInfo.AnimalMovimientoID > 0)
{
if (resultadoLoteOrigen != null && guardarAnimalCorte.LoteDestinoInfo != null)
{
guardarAnimalCorte.CorralGlobal = guardarAnimalCorte.AnimalMovimientoOrigenInfo.CorralID;
guardarAnimalCorte.LoteDestinoInfo.Cabezas = guardarAnimalCorte.LoteDestinoInfo.Cabezas + 1;
guardarAnimalCorte.LoteDestinoInfo.CabezasInicio =
guardarAnimalCorte.LoteDestinoInfo.CabezasInicio + 1;
resultadoLoteOrigen.Cabezas = resultadoLoteOrigen.Cabezas - 1;
var filtroActualizaCabezas = new FiltroActualizarCabezasLote
{
LoteIDOrigen = resultadoLoteOrigen.LoteID,
LoteIDDestino = guardarAnimalCorte.LoteDestinoInfo.LoteID,
CabezasProcesadas = 1,
UsuarioModificacionID =
guardarAnimalCorte.UsuarioCreacionID
};
var cabezas = loteBl.ActualizarCabezasProcesadas(filtroActualizaCabezas);
//TODO nuevo metodo
//loteBl.ActualizaNoCabezasEnLote(guardarAnimalCorte.LoteDestinoInfo, resultadoLoteOrigen);
loteBl.ActualizarSalidaEnfermeria(guardarAnimalCorte.AnimalMovimientoOrigenInfo);
loteBl.ActualizarFechaSalidaEnLote(resultadoLoteOrigen);
//if (resultadoLoteOrigen.Cabezas == 0)
//{
// resultadoLoteOrigen.Activo = (int)EstatusEnum.Inactivo;
// loteBl.ActualizaActivoEnLote(resultadoLoteOrigen);
//}
// ObtenerTotalCabezas(loteCorralOrigen);
}
if (ObtenerTotalCabezas(guardarAnimalCorte.AnimalMovimientoOrigenInfo))
{
corralBl.TraspasarAnimalSalidaEnfermeria(
guardarAnimalCorte.AnimalSalidaGuardarInfo.CorraletaId,
guardarAnimalCorte.AnimalMovimientoOrigenInfo.LoteID);
//loteDAL.EliminarSalidaEnfermeria(guardarAnimalCorte.AnimalMovimientoOrigenInfo);
}
}
if (guardarAnimalCorte.AnimalMovimientoCorteTransferenciaInfo != null)
{
var almacenMovimientoInfo = new AlmacenMovimientoInfo
{
AlmacenID = guardarAnimalCorte.AlmacenID,
AnimalMovimientoID =
guardarAnimalCorte.AnimalMovimientoCorteTransferenciaInfo
.AnimalMovimientoID,
TipoMovimientoID = (int)TipoMovimiento.SalidaPorConsumo,
Status = (int)EstatusInventario.Aplicado,
Observaciones = "",
UsuarioCreacionID = guardarAnimalCorte.UsuarioCreacionID,
AnimalID =
guardarAnimalCorte.AnimalMovimientoCorteTransferenciaInfo
.AnimalID,
//Verificar
CostoID = (int)Costo.MedicamentoDeImplante,
};
var almacenBL = new AlmacenBL();
almacenBL.GuardarDescontarTratamientos(
listaTratamientos.Where(item => item.Seleccionado && item.Habilitado).ToList(),
almacenMovimientoInfo);
}
var loteProyeccionBL = new LoteProyeccionBL();
LoteProyeccionInfo proyeccionDestino =
loteProyeccionBL.ObtenerPorLote(guardarAnimalCorte.LoteDestinoInfo);
//guardarAnimalCorte.LoteDestinoInfo.LoteID
if (proyeccionDestino == null)
{
LoteProyeccionInfo proyeccionOrigen = loteProyeccionBL.ObtenerPorLote(resultadoLoteOrigen);
if (proyeccionOrigen != null && resultadoLoteOrigen != null && guardarAnimalCorte.LoteDestinoInfo != null)
{
proyeccionOrigen.LoteProyeccionID = 0;
int diasEngordaOrigen = proyeccionOrigen.DiasEngorda;
DateTime fechaInicioLote = resultadoLoteOrigen.FechaInicio;
int diasEngordaReales =
new TimeSpan(DateTime.Now.Ticks - fechaInicioLote.Ticks).Days;
if ((diasEngordaOrigen - diasEngordaReales) <= 0)
{
proyeccionOrigen.DiasEngorda = 0;
}
else
{
proyeccionOrigen.DiasEngorda = diasEngordaOrigen - diasEngordaReales;
}
proyeccionOrigen.LoteID = guardarAnimalCorte.LoteDestinoInfo.LoteID;
proyeccionOrigen.UsuarioCreacionID = guardarAnimalCorte.UsuarioCreacionID;
loteProyeccionBL.Guardar(proyeccionOrigen);
var loteDAL = new LoteDAL();
var filtroDisponibilidad = new FiltroDisponilidadInfo
{
UsuarioId = guardarAnimalCorte.UsuarioCreacionID,
ListaLoteDisponibilidad =
new List <DisponibilidadLoteInfo>
{
new DisponibilidadLoteInfo
{
LoteId = guardarAnimalCorte.LoteDestinoInfo.LoteID,
FechaDisponibilidad =
resultadoLoteOrigen.FechaDisponibilidad,
DisponibilidadManual =
resultadoLoteOrigen.DisponibilidadManual
}
}
};
loteDAL.ActualizarLoteDisponibilidad(filtroDisponibilidad);
}
}
transaction.Complete();
return(guardarAnimalCorte);
}
}
catch (ExcepcionGenerica)
{
return(null);
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
}
/// <summary>
/// Metodo que da salida por venta al ganado intensivo cuano se selcciona tipoventa Externo
/// </summary>
/// <param name="salidaIndividual"></param>
/// <returns></returns>
internal MemoryStream GuardarSalidaGanadoVentaIntensiva(SalidaIndividualInfo salidaIndividual)
{
MemoryStream retorno = null;
try
{
PolizaAbstract poliza;
IList <PolizaInfo> polizaSalidaVenta;
TicketInfo Ticket = new TicketInfo();
CorralInfo corralInfo = new CorralInfo();
CorralBL corralB = new CorralBL();
GanadoIntensivoBL salidaGanadoCosto = new GanadoIntensivoBL();
GanadoIntensivoInfo salidaGanadoInfo = new GanadoIntensivoInfo();
corralInfo = corralB.ObtenerCorralActivoPorCodigo(salidaIndividual.Organizacion, salidaIndividual.Corral);
corralInfo.Organizacion = new OrganizacionInfo();
corralInfo.Organizacion.OrganizacionID = salidaIndividual.Organizacion;
salidaGanadoInfo = salidaGanadoCosto.ObtenerMuerteGanadoIntensivo(corralInfo);
salidaGanadoInfo.Organizacion = new OrganizacionInfo();
salidaGanadoInfo.Organizacion.OrganizacionID = salidaIndividual.Organizacion;
salidaGanadoInfo.Observaciones = "";
Ticket.FolioTicket = salidaIndividual.FolioTicket;
Ticket.Organizacion = salidaIndividual.Organizacion;
var ventaGanadoBL = new VentaGanadoBL();
VentaGanadoInfo salidaPorVentaGanado = ventaGanadoBL.ObtenerVentaGanadoPorTicket(Ticket);
var loteBL = new LoteBL();
CorralBL corralBl = new CorralBL();
LoteInfo lote = loteBL.ObtenerPorID(salidaPorVentaGanado.LoteID);
int iCabezasTotalLote = lote.Cabezas;
lote.Cabezas -= salidaIndividual.NumeroDeCabezas;
//lote.Corral = corralBl.ObtenerCorralPorLoteID(lote.LoteID, salidaIndividual.Organizacion);
//lote.Corral = corralBl.ObtenerCorralPorCodigo()
using (var scope = new TransactionScope())
{
Logger.Info();
var salidaIndividualDAL = new SalidaIndividualDAL();
var filtroActualizaCabezas = new FiltroActualizarCabezasLote
{
LoteIDOrigen = lote.LoteID,
LoteIDDestino = 0,
CabezasProcesadas = salidaIndividual.NumeroDeCabezas,
UsuarioModificacionID = salidaIndividual.Usuario
};
loteBL.ActualizarCabezasProcesadas(filtroActualizaCabezas);
salidaGanadoInfo.ListaGanadoIntensivoCosto = new List <GanadoIntensivoCostoInfo>();
foreach (
var entradaCosteo in
salidaGanadoInfo.EntradaGanadoCosteo.ListaCostoEntrada.OrderBy(id => id.Costo.CostoID))
{
var costoInt = new GanadoIntensivoCostoInfo();
costoInt.Costos = new CostoInfo();
costoInt.Costos = entradaCosteo.Costo;
costoInt.Costos.ImporteCosto = (entradaCosteo.Importe /
salidaGanadoInfo.EntradaGanado.CabezasRecibidas) *
salidaIndividual.NumeroDeCabezas;
costoInt.Importe = costoInt.Costos.ImporteCosto;
salidaGanadoInfo.ListaGanadoIntensivoCosto.Add(costoInt);
}
salidaGanadoInfo.TipoMovimientoID = TipoMovimiento.SalidaVentaIntensivo;
//salidaIndividualDAL.GuardarSalidaIndividualGanadoVenta(salidaIndividual);
salidaGanadoInfo.TotalCabezas = salidaIndividual.NumeroDeCabezas;
salidaGanadoInfo.FolioTicket = salidaIndividual.FolioTicket;
salidaGanadoInfo.TipoFolio = TipoFolio.VentaGanadoIntensivo;
salidaGanadoInfo.PesoBruto = salidaIndividual.PesoBruto;
salidaGanadoInfo.UsuarioCreacionID = salidaIndividual.Usuario;
salidaGanadoInfo.Organizacion.OrganizacionID = salidaIndividual.Organizacion;
salidaGanadoInfo.CabezasText = salidaIndividual.NumeroDeCabezas.ToString();
salidaGanadoCosto.Guardar(salidaGanadoInfo);
#region Poliza
List <ContenedorVentaGanado> ventasGanado =
ventaGanadoBL.ObtenerVentaGanadoIntensivoPorTicketPoliza(Ticket);
if (ventasGanado != null && ventasGanado.Any())
{
poliza = FabricaPoliza.ObtenerInstancia().ObtenerTipoPoliza(TipoPoliza.SalidaVentaIntensiva);
for (int i = 0; i < ventasGanado.Count; i++)
{
ventasGanado[i].EntradaGandoId = salidaGanadoInfo.EntradaGanado.EntradaGanadoID;
ventasGanado[i].OrganizacionId = Ticket.Organizacion;
ventasGanado[i].Lote = lote;
}
polizaSalidaVenta = poliza.GeneraPoliza(ventasGanado);
if (polizaSalidaVenta != null && polizaSalidaVenta.Any())
{
polizaSalidaVenta.ToList().ForEach(
org =>
{
org.OrganizacionID = Ticket.Organizacion;
org.UsuarioCreacionID = salidaIndividual.Usuario;
org.ArchivoEnviadoServidor = 1;
});
retorno = poliza.ImprimePoliza(ventasGanado, polizaSalidaVenta);
var polizaBL = new PolizaBL();
polizaBL.GuardarServicioPI(polizaSalidaVenta, TipoPoliza.SalidaVentaIntensiva);
}
}
// Genera el xml y lo guarda en la ruta especificada en la configuración
var facturaBl = new FacturaBL();
facturaBl.GenerarDatosFacturaVentaDeGanadoIntensivo(Ticket.FolioTicket, Ticket.Organizacion);
#endregion Poliza
scope.Complete();
}
return(retorno);
}
catch (ExcepcionServicio ex)
{
Logger.Error(ex);
throw;
}
catch (ExcepcionGenerica)
{
throw;
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
}
/// <summary>
/// Metodo que le da salida por venta al ganado
/// </summary>
/// <param name="salidaIndividual"></param>
/// <returns></returns>
internal MemoryStream GuardarSalidaIndividualGanadoVenta(SalidaIndividualInfo salidaIndividual)
{
MemoryStream retorno = null;
try
{
PolizaAbstract poliza;
IList <PolizaInfo> polizaSalidaVenta;
TicketInfo Ticket = new TicketInfo();
Ticket.FolioTicket = salidaIndividual.FolioTicket;
Ticket.Organizacion = salidaIndividual.Organizacion;
Ticket.TipoVenta = salidaIndividual.TipoVenta;
var ventaGanadoBL = new VentaGanadoBL();
VentaGanadoInfo salidaPorVentaGanado = ventaGanadoBL.ObtenerVentaGanadoPorTicket(Ticket);
var loteBL = new LoteBL();
LoteInfo lote = loteBL.ObtenerPorID(salidaPorVentaGanado.LoteID);
lote.Cabezas -= salidaIndividual.NumeroDeCabezas;
AnimalBL animalBl = new AnimalBL();
using (var scope = new TransactionScope())
{
Logger.Info();
var salidaIndividualDAL = new SalidaIndividualDAL();
VentaGanadoDetalleBL ventaGanadoDetalleBl = new VentaGanadoDetalleBL();
List <VentaGanadoDetalleInfo> listaVentaGanadoDetalle = ventaGanadoDetalleBl.ObtenerVentaGanadoPorTicket(salidaPorVentaGanado.VentaGanadoID);
List <AnimalCostoInfo> animalCosto = new List <AnimalCostoInfo>();
AnimalCostoBL animalCostoBl = new AnimalCostoBL();
List <AnimalInfo> animalesConsulta = new List <AnimalInfo>();
List <AnimalInfo> animalesProcesar = new List <AnimalInfo>();
foreach (VentaGanadoDetalleInfo ventaGanado in listaVentaGanadoDetalle)
{
animalesConsulta = new List <AnimalInfo>();
ventaGanado.Animal = animalBl.ObtenerAnimalPorArete(ventaGanado.Arete, Ticket.Organizacion);
if (ventaGanado.Animal == null)
{
ventaGanado.Animal = animalBl.ObtenerAnimalPorAreteTestigo(ventaGanado.AreteMetalico, Ticket.Organizacion);
}
animalesConsulta.Add(ventaGanado.Animal);
animalCosto = animalCostoBl.ObtenerCostosAnimal(animalesConsulta);
if (!animalCosto.Any(registro => registro.CostoID == Costo.CostoGanado.GetHashCode()))
{
animalesProcesar.Add(ventaGanado.Animal);
}
}
if (animalesProcesar != null && animalesProcesar.Count > 0)
{
animalBl.ProcesoGenerarCostos(animalesProcesar);
}
salidaIndividualDAL.GuardarSalidaIndividualGanadoVenta(salidaIndividual);
salidaIndividualDAL.GuardarCostosHistoricos(salidaIndividual);
salidaIndividualDAL.GuardarConsumoHistoricos(salidaIndividual);
salidaIndividualDAL.GuardarAnimalHistoricos(salidaIndividual);
var filtroActualizaCabezas = new FiltroActualizarCabezasLote
{
LoteIDOrigen = lote.LoteID,
LoteIDDestino = 0,
CabezasProcesadas = salidaIndividual.NumeroDeCabezas,
UsuarioModificacionID = salidaIndividual.Usuario
};
loteBL.ActualizarCabezasProcesadas(filtroActualizaCabezas);
//loteBL.ActualizaNoCabezasEnLote(lote, lote);
#region Poliza
List <ContenedorVentaGanado> ventasGanado =
ventaGanadoBL.ObtenerVentaGanadoPorTicketPoliza(Ticket.FolioTicket, Ticket.Organizacion);
if (ventasGanado != null && ventasGanado.Any())
{
poliza = FabricaPoliza.ObtenerInstancia().ObtenerTipoPoliza(TipoPoliza.SalidaVenta);
polizaSalidaVenta = poliza.GeneraPoliza(ventasGanado);
if (polizaSalidaVenta != null && polizaSalidaVenta.Any())
{
polizaSalidaVenta.ToList().ForEach(
org =>
{
org.OrganizacionID = Ticket.Organizacion;
org.UsuarioCreacionID = salidaIndividual.Usuario;
org.ArchivoEnviadoServidor = 1;
});
retorno = poliza.ImprimePoliza(ventasGanado, polizaSalidaVenta);
var polizaBL = new PolizaBL();
polizaBL.GuardarServicioPI(polizaSalidaVenta, TipoPoliza.SalidaVenta);
}
}
// Genera el xml y lo guarda en la ruta especificada en la configuración
var facturaBl = new FacturaBL();
facturaBl.GenerarDatosFacturaVentaDeGanado(Ticket.FolioTicket, Ticket.Organizacion);
#endregion Poliza
scope.Complete();
}
return(retorno);
}
catch (ExcepcionServicio ex)
{
Logger.Error(ex);
throw;
}
catch (ExcepcionGenerica)
{
throw;
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
}
/// <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);
}
}
/// <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);
}
//Metodo que guarda el movimiento
private void GuardarMovimientoTraspasoGanadoCorrales(List <AnimalInfo> aretesTotal, CorralInfo corralInfo, UsuarioInfo usuarioInfo)
{
//var animalInfo = new AnimalInfo();
int loteOrigenID = 0;
int loteDestinoID = 0;
var loteBl = new LoteBL();
var animalBL = new AnimalBL();
var animalMovimientoBL = new AnimalMovimientoBL();
var tipoProcesoBl = new TipoProcesoBL();
var fechaBL = new FechaBL();
var loteProyeccionBL = new LoteProyeccionBL();
List <AnimalMovimientoInfo> ultimosMovimientos = animalBL.ObtenerUltimoMovimientoAnimalXML(aretesTotal,
usuarioInfo.
Organizacion.
OrganizacionID);
if (ultimosMovimientos == null)
{
ultimosMovimientos = new List <AnimalMovimientoInfo>();
}
var resultadoLoteBl = loteBl.ObtenerLotesActivos(usuarioInfo.Organizacion.OrganizacionID,
Convert.ToInt32(corralInfo.CorralID));
var tipoProcesoResult =
tipoProcesoBl.ObtenerPorOrganizacion(usuarioInfo.Organizacion.OrganizacionID);
var fechaServidor = fechaBL.ObtenerFechaActual();
IList <LoteInfo> lotesCorrales = loteBl.ObtenerPorOrganizacionEstatus(
usuarioInfo.Organizacion.OrganizacionID, EstatusEnum.Activo);
if (lotesCorrales == null)
{
lotesCorrales = new List <LoteInfo>();
}
IList <LoteProyeccionInfo> lotesProyeccion =
loteProyeccionBL.ObtenerPorLoteXML(usuarioInfo.Organizacion.OrganizacionID, lotesCorrales);
var resultadoLote = -1;
using (var transaction = new TransactionScope())
{
if (resultadoLoteBl == null)
{
var loteCrear = new LoteBL();
var loteInfoLote = new LoteInfo
{
Activo = EstatusEnum.Activo,
Cabezas = Convert.ToInt32(0),
CabezasInicio = Convert.ToInt32(0),
CorralID = corralInfo.CorralID,
DisponibilidadManual = false,
OrganizacionID = usuarioInfo.Organizacion.OrganizacionID,
TipoCorralID = corralInfo.TipoCorral.TipoCorralID,
TipoProcesoID = tipoProcesoResult,
UsuarioCreacionID = usuarioInfo.UsuarioID
};
resultadoLote = loteCrear.GuardaLote(loteInfoLote);
if ((corralInfo.TipoCorral != null &&
corralInfo.TipoCorral.TipoCorralID != TipoCorral.Enfermeria.GetHashCode()) ||
(corralInfo.TipoCorralId > 0 &&
corralInfo.TipoCorralId != TipoCorral.Enfermeria.GetHashCode()))
{
loteBl.ActualizaFechaCierre(resultadoLote, usuarioInfo.UsuarioID);
}
}
foreach (var animalInfo in aretesTotal)
{
var animalMovimientoInfo = new AnimalMovimientoInfo();
animalInfo.OrganizacionIDEntrada = usuarioInfo.Organizacion.OrganizacionID;
//Obtener ultimo movimiento del animal
var ultimoMovimientoInfo =
ultimosMovimientos.FirstOrDefault(ani => ani.AnimalID == animalInfo.AnimalID);
if (ultimoMovimientoInfo != null)
{
animalMovimientoInfo.OrganizacionID = usuarioInfo.Organizacion.OrganizacionID;
animalMovimientoInfo.AnimalID = animalInfo.AnimalID;
animalMovimientoInfo.CorralID = corralInfo.CorralID;
animalMovimientoInfo.LoteID = resultadoLoteBl != null ? resultadoLoteBl.LoteID : resultadoLote;
DateTime diaHoy = fechaServidor.FechaActual.Date;
animalMovimientoInfo.FechaMovimiento = diaHoy.Date;
animalMovimientoInfo.Peso = ultimoMovimientoInfo.Peso;
animalMovimientoInfo.Temperatura = ultimoMovimientoInfo.Temperatura;
animalMovimientoInfo.TipoMovimientoID = (int)TipoMovimiento.TraspasoDeGanado;
animalMovimientoInfo.TrampaID = ultimoMovimientoInfo.TrampaID;
animalMovimientoInfo.OperadorID = ultimoMovimientoInfo.OperadorID;
animalMovimientoInfo.Observaciones = String.Empty;
animalMovimientoInfo.Activo = EstatusEnum.Activo;
animalMovimientoInfo.UsuarioCreacionID = usuarioInfo.UsuarioID;
//Se manda a guardar el registro en base de datos
animalMovimientoInfo = animalMovimientoBL.GuardarAnimalMovimiento(animalMovimientoInfo);
if (animalMovimientoInfo == null || animalMovimientoInfo.AnimalMovimientoID <= 0)
{
return;
}
var resultadoLoteOrigen = loteBl.ObtenerPorID(ultimoMovimientoInfo.LoteID);
var resultadoLoteDestino = loteBl.ObtenerPorID(animalMovimientoInfo.LoteID);
if (resultadoLoteDestino != null)
{
resultadoLoteDestino.UsuarioModificacionID = usuarioInfo.UsuarioID;
}
//Incrementar y Decrementar cabezas
if (resultadoLoteOrigen != null && resultadoLoteDestino != null)
{
loteOrigenID = resultadoLoteOrigen.LoteID;
loteDestinoID = resultadoLoteDestino.LoteID;
resultadoLoteDestino.Cabezas = resultadoLoteDestino.Cabezas + 1;
resultadoLoteDestino.CabezasInicio = resultadoLoteDestino.CabezasInicio + 1;
resultadoLoteOrigen.Cabezas = resultadoLoteOrigen.Cabezas - 1;
//Verificar si el Lote tiene cabezas en 0 para inactivarlo
resultadoLoteOrigen = loteBl.ObtenerPorID(ultimoMovimientoInfo.LoteID);
if (resultadoLoteOrigen.Cabezas != 0)
{
continue;
}
}
}
}
var loteOrigenInfo = loteBl.ObtenerPorID(loteOrigenID);
var loteDestinoInfo = loteBl.ObtenerPorID(loteDestinoID);
if (lotesProyeccion != null && lotesProyeccion.Any())
{
LoteProyeccionInfo proyeccionOrigen =
lotesProyeccion.FirstOrDefault(lote => lote.LoteID == loteOrigenInfo.LoteID);
LoteProyeccionInfo proyeccionDestino =
lotesProyeccion.FirstOrDefault(lote => lote.LoteID == loteDestinoInfo.LoteID);
if (proyeccionOrigen != null && proyeccionDestino == null)
{
proyeccionOrigen.LoteProyeccionID = 0;
int diasEngordaOrigen = proyeccionOrigen.DiasEngorda;
DateTime fechaInicioLote = loteOrigenInfo.FechaInicio;
int diasEngordaReales =
new TimeSpan(DateTime.Now.Ticks - fechaInicioLote.Ticks).Days;
if ((diasEngordaOrigen - diasEngordaReales) <= 0)
{
proyeccionOrigen.DiasEngorda = 0;
}
else
{
proyeccionOrigen.DiasEngorda = diasEngordaOrigen - diasEngordaReales;
}
proyeccionOrigen.LoteID = loteDestinoInfo.LoteID;
proyeccionOrigen.UsuarioCreacionID = usuarioInfo.UsuarioID;
loteProyeccionBL.Guardar(proyeccionOrigen);
var loteDAL = new LoteDAL();
var filtroDisponibilidad = new FiltroDisponilidadInfo
{
UsuarioId = usuarioInfo.UsuarioID,
ListaLoteDisponibilidad =
new List <DisponibilidadLoteInfo>
{
new DisponibilidadLoteInfo
{
LoteId = loteDestinoInfo.LoteID,
FechaDisponibilidad = loteOrigenInfo.FechaDisponibilidad,
DisponibilidadManual = loteOrigenInfo.DisponibilidadManual
}
}
};
loteDAL.ActualizarLoteDisponibilidad(filtroDisponibilidad);
}
}
List <AnimalInfo> animalesOrigen =
animalBL.ObtenerAnimalesPorLote(usuarioInfo.Organizacion.OrganizacionID,
loteOrigenID);
if (animalesOrigen != null && animalesOrigen.Any())
{
loteOrigenInfo.Cabezas = animalesOrigen.Count;
}
List <AnimalInfo> animalesDestino =
animalBL.ObtenerAnimalesPorLote(usuarioInfo.Organizacion.OrganizacionID,
loteDestinoID);
if (animalesDestino != null && animalesDestino.Any())
{
loteDestinoInfo.Cabezas = animalesDestino.Count;
}
//Se actualizan las cabezas que tiene el lote
var filtro = new FiltroActualizarCabezasLote
{
CabezasProcesadas = aretesTotal.Count,
LoteIDDestino = loteDestinoInfo.LoteID,
LoteIDOrigen = loteOrigenInfo.LoteID,
UsuarioModificacionID = usuarioInfo.UsuarioID
};
loteBl.ActualizarCabezasProcesadas(filtro);
transaction.Complete();
}
}
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);
}
}
/// <summary>
/// Guardar entrada enfermeria
/// </summary>
internal EntradaGanadoEnfermeriaInfo GuardarEntradaEnfermeria(EntradaGanadoEnfermeriaInfo entradaGanadoEnfermeria)
{
entradaGanadoEnfermeria.Resultado = false;
try
{
var resultadoCabezas = new CabezasActualizadasInfo();
var transactionOption = new TransactionOptions();
transactionOption.IsolationLevel = System.Transactions.IsolationLevel.ReadCommitted;
using (var transaction = new TransactionScope(TransactionScopeOption.Required, transactionOption))
{
var animalDal = new AnimalDAL();
var animalMovimientoBL = new AnimalMovimientoBL();
var corralBL = new CorralBL();
var loteBL = new LoteBL();
bool actualizaAreteDeteccion = entradaGanadoEnfermeria.Deteccion.ActualizarAreteDeteccion;
bool animalRecaido = entradaGanadoEnfermeria.AnimalRecaido;
if (entradaGanadoEnfermeria.CambiarTipoGanado &&
entradaGanadoEnfermeria.Deteccion.Animal.AnimalID > 0 &&
entradaGanadoEnfermeria.Deteccion.Animal.TipoGanadoID != entradaGanadoEnfermeria.Animal.TipoGanadoID)
{
entradaGanadoEnfermeria.Animal.AnimalID = entradaGanadoEnfermeria.Deteccion.Animal.AnimalID;
entradaGanadoEnfermeria.Animal.UsuarioModificacionID = entradaGanadoEnfermeria.UsuarioId;
}
if (entradaGanadoEnfermeria.Animal.AnimalID == 0)
{
entradaGanadoEnfermeria.Animal.AnimalID = entradaGanadoEnfermeria.Deteccion.Animal.AnimalID;
entradaGanadoEnfermeria.Animal.AplicaBitacora = entradaGanadoEnfermeria.Deteccion.Animal.AplicaBitacora;
}
AnimalInfo animalInfo = animalDal.GuardarAnimal(entradaGanadoEnfermeria.Animal);
if (actualizaAreteDeteccion)
{
//Si el flag esta activo se actualiza el arete en la deteccion de ganado cuando solo traen fotos
var deteccionBl = new DeteccionBL();
deteccionBl.ActualizarDeteccionConFoto(entradaGanadoEnfermeria.Deteccion);
}
/* Si esta activo el flag de recaido generar la deteccion */
if (animalRecaido)
{
entradaGanadoEnfermeria.Deteccion.DeteccionID = GenerarDeteccionAnimalGenerica(entradaGanadoEnfermeria);
}
if (animalInfo != null && animalInfo.AnimalID > 0)
{
entradaGanadoEnfermeria.Animal = animalInfo;
entradaGanadoEnfermeria.Movimiento.AnimalID = animalInfo.AnimalID;
if (entradaGanadoEnfermeria.LoteDestino.LoteID == 0)
{
entradaGanadoEnfermeria.LoteDestino.LoteID = loteBL.GuardaLote(entradaGanadoEnfermeria.LoteDestino);
entradaGanadoEnfermeria.Movimiento.LoteID = entradaGanadoEnfermeria.LoteDestino.LoteID;
}
//Se almacena el movimiento
AnimalMovimientoInfo animalMovimientoInfo =
animalMovimientoBL.GuardarAnimalMovimiento(entradaGanadoEnfermeria.Movimiento);
if (animalMovimientoInfo != null && animalMovimientoInfo.AnimalMovimientoID > 0)
{
if (entradaGanadoEnfermeria.Tratamientos.Any(registro => registro.Seleccionado))
{
var almacenpl = new AlmacenBL();
entradaGanadoEnfermeria.AlmacenMovimiento.AnimalMovimientoID =
animalMovimientoInfo.AnimalMovimientoID;
entradaGanadoEnfermeria.AlmacenMovimiento.AnimalID = animalInfo.AnimalID;
almacenpl.GuardarDescontarTratamientos(entradaGanadoEnfermeria.Tratamientos,
entradaGanadoEnfermeria.AlmacenMovimiento);
}
entradaGanadoEnfermeria.Deteccion.AnimalMovimiento = animalMovimientoInfo;
GurdarDeteccion(entradaGanadoEnfermeria.Deteccion, entradaGanadoEnfermeria.ListaProblemas);
/* Se desactiva la deteccion */
var deteccion = new DeteccionInfo
{
DeteccionID = entradaGanadoEnfermeria.Deteccion.DeteccionID,
UsuarioCreacionID = entradaGanadoEnfermeria.UsuarioId,
Arete = entradaGanadoEnfermeria.Animal.Arete
};
EliminarDeteccion(deteccion);
#region LOTE
//Se decrementan las cabezas del lote
if (entradaGanadoEnfermeria.LoteDestino.LoteID != entradaGanadoEnfermeria.LoteOrigen.LoteID)
{
entradaGanadoEnfermeria.LoteDestino = loteBL.ObtenerPorID(entradaGanadoEnfermeria.LoteDestino.LoteID);
var animalBL = new AnimalBL();
List <AnimalInfo> animalesDestino =
animalBL.ObtenerAnimalesPorLote(entradaGanadoEnfermeria.LoteOrigen.OrganizacionID,
entradaGanadoEnfermeria.LoteDestino.LoteID);
if (animalesDestino != null && animalesDestino.Any())
{
entradaGanadoEnfermeria.LoteDestino.Cabezas = animalesDestino.Count;
}
//Una vez insertado el lote y el animal se incrementan las cabezas de lote
entradaGanadoEnfermeria.LoteDestino.Cabezas =
entradaGanadoEnfermeria.LoteDestino.Cabezas + 1;
if (entradaGanadoEnfermeria.LoteDestino.Cabezas > entradaGanadoEnfermeria.LoteDestino.CabezasInicio)
{
entradaGanadoEnfermeria.LoteDestino.CabezasInicio =
entradaGanadoEnfermeria.LoteDestino.CabezasInicio + 1;
}
entradaGanadoEnfermeria.LoteDestino.UsuarioModificacionID =
entradaGanadoEnfermeria.Movimiento.UsuarioCreacionID;
// ------ //
entradaGanadoEnfermeria.LoteOrigen.Cabezas =
entradaGanadoEnfermeria.LoteOrigen.Cabezas - 1;
List <AnimalInfo> animales =
animalBL.ObtenerAnimalesPorLote(entradaGanadoEnfermeria.LoteOrigen.OrganizacionID,
entradaGanadoEnfermeria.LoteOrigen.LoteID);
if (animales != null && animales.Any())
{
entradaGanadoEnfermeria.LoteOrigen.Cabezas = animales.Count;
}
//Se actualizan las cabezas que tiene el lote
var filtro = new FiltroActualizarCabezasLote
{
CabezasProcesadas = 1,
LoteIDDestino = entradaGanadoEnfermeria.LoteDestino.LoteID,
LoteIDOrigen = entradaGanadoEnfermeria.LoteOrigen.LoteID,
UsuarioModificacionID = entradaGanadoEnfermeria.Movimiento.UsuarioCreacionID
};
resultadoCabezas = loteBL.ActualizarCabezasProcesadas(filtro);
}
#endregion LOTE
//Si ya no tenemos cabezas en el lote se actualizanb los pesos llegada
if (resultadoCabezas.CabezasOrigen <= 0)
{
//Se obtiene el Corral para ver Si es de Recepcion
CorralInfo corralInfo = corralBL.ObtenerCorralPorCodigo(entradaGanadoEnfermeria.LoteOrigen.OrganizacionID,
entradaGanadoEnfermeria.LoteOrigen.Corral.Codigo);
if (corralInfo.GrupoCorral == (int)GrupoCorralEnum.Recepcion)
{
/* Si el corral es de Recepcion */
var corteGanadoPl = new CorteGanadoBL();
corteGanadoPl.ObtenerPesosOrigenLlegada(entradaGanadoEnfermeria.LoteOrigen.OrganizacionID,
entradaGanadoEnfermeria.LoteOrigen.CorralID,
entradaGanadoEnfermeria.LoteOrigen.LoteID);
}
}
transaction.Complete();
entradaGanadoEnfermeria.Resultado = true;
}
}
}
}
catch (ExcepcionGenerica ex)
{
Logger.Error(ex);
entradaGanadoEnfermeria.Resultado = false;
}
catch (Exception ex)
{
Logger.Error(ex);
entradaGanadoEnfermeria.Resultado = false;
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
return(entradaGanadoEnfermeria);
}
/// <summary>
/// Guardar la salida por recuperacion
/// </summary>
/// <returns></returns>
private bool GuardarSalidaRecuperacion()
{
var regreso = false;
if (lisBoxCorralDestino.Items.Count > 0)
{
var lotePL = new LotePL();
var lote = new LoteInfo
{
Corral = new CorralInfo
{
CorralID = corralIdOrigen
},
CorralID = corralIdOrigen,
OrganizacionID = organizacionId
};
lote = lotePL.ObtenerPorCorralID(lote);
var animalMovimientoPL = new AnimalMovimientoPL();
List <AnimalMovimientoInfo> movimientosAnimal = animalMovimientoPL.ObtenerUltimoMovimientoAnimal(animales);
if (movimientosAnimal != null)
{
var loteDestino = new LoteInfo
{
Corral = new CorralInfo
{
CorralID = corralIdDestino
},
CorralID = corralIdDestino,
OrganizacionID = organizacionId
};
loteDestino = lotePL.ObtenerPorCorralID(loteDestino);
movimientosAnimal.ForEach(datos =>
{
datos.LoteID = loteDestino.LoteID;
datos.CorralID = corralIdDestino;
datos.TipoMovimientoID =
TipoMovimiento.SalidaEnfermeria.GetHashCode();
datos.Activo = EstatusEnum.Activo;
datos.UsuarioCreacionID = usuario;
datos.UsuarioModificacionID = usuario;
});
lote.Cabezas -= movimientosAnimal.Count;
loteDestino.Cabezas += movimientosAnimal.Count;
using (var scope = new TransactionScope())
{
animalMovimientoPL.GuardarAnimalMovimientoXML(movimientosAnimal);
var filtro = new FiltroActualizarCabezasLote
{
CabezasProcesadas = movimientosAnimal.Count,
LoteIDDestino = loteDestino.LoteID,
LoteIDOrigen = lote.LoteID,
UsuarioModificacionID = AuxConfiguracion.ObtenerUsuarioLogueado()
};
lotePL.ActualizarCabezasProcesadas(filtro);
scope.Complete();
}
regreso = true;
}
}
return(regreso);
}
