public static AnimalInfo ObtenerExisteArete(string arete)
{
AnimalInfo animal = null;
try
{
var animalPL = new AnimalPL();
var muertePL = new MuertePL();
var seguridad = (SeguridadInfo)HttpContext.Current.Session["Seguridad"];
int organizacionId = seguridad.Usuario.Organizacion.OrganizacionID;
animal = animalPL.ObtenerAnimalPorArete(arete, organizacionId);
if (animal != null)
{
MuerteInfo muerto = muertePL.ObtenerMuertoPorArete(organizacionId, arete);
if (muerto != null)
{
animal.AnimalID = -1;
}
}
//ObtenerCorralDestinoAnimal(arete);
}
catch (Exception ex)
{
Logger.Error(ex);
}
return(animal);
}
public void Tick(IHTNAgent npc, float deltaTime, float time)
{
ScientistAStarContext npcContext = npc.AiDomain.NpcContext as ScientistAStarContext;
if (npcContext == null)
{
return;
}
BaseNpc animal = (BaseNpc)null;
float num = float.MaxValue;
for (int index = 0; index < npcContext.AnimalsInRange.Count; ++index)
{
AnimalInfo animalInfo = npcContext.AnimalsInRange[index];
if (Object.op_Inequality((Object)animalInfo.Animal, (Object)null) && (double)animalInfo.SqrDistance < (double)num)
{
num = animalInfo.SqrDistance;
animal = animalInfo.Animal;
}
}
if (Object.op_Inequality((Object)animal, (Object)null))
{
AttackEntity firearm = npcContext.Domain.GetFirearm();
if ((double)num < (double)npc.AiDefinition.Engagement.SqrCloseRangeFirearm(firearm))
{
npcContext.Memory.RememberPrimaryAnimal(animal);
npcContext.SetFact(Rust.Ai.HTN.ScientistAStar.Facts.NearbyAnimal, true, true, true, true);
return;
}
}
npcContext.SetFact(Rust.Ai.HTN.ScientistAStar.Facts.NearbyAnimal, false, true, true, true);
}
internal AnimalInfo ExisteAreteMetalicoEnPartida(AnimalInfo animalInfo)
{
AnimalInfo result = null;
try
{
Dictionary <string, object> parametros = AuxCorteGanadoDAL.ObtenerParametrosExisteAreteMetalicoEnPartida(animalInfo);
DataSet ds = Retrieve("[dbo].[CorteGanado_ExisteAreteMetalicoEnPartida]", parametros);
if (ValidateDataSet(ds))
{
result = MapCorteGanadoDAL.ObtenerExisteExisteAreteEnPartida(ds);
}
}
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);
}
return(result);
}
/// <summary>
/// Metodo para obtener la ultima deteccion que sele realizo al animal
/// </summary>
/// <param name="animalEnfermo"></param>
/// <returns></returns>
internal AnimalDeteccionInfo ObtenerAnimalDetectadoPorAreteUltimaDeteccion(AnimalInfo animalEnfermo)
{
try
{
Logger.Info();
Dictionary <string, object> parametros = AuxEnfermeriaDAL.ObtenerParametrosObtenerAnimalDetectadoPorArete(animalEnfermo);
DataSet ds = Retrieve("Enfermeria_ObtenerAnimalDetectadoPorAreteUltimaDeteccion", parametros);
AnimalDeteccionInfo animalDetectado = null;
if (ValidateDataSet(ds))
{
animalDetectado = MapEnfermeriaDal.ObtenerAnimalDetectadoPorAreteUltimaDeteccion(ds, animalEnfermo.OrganizacionIDEntrada)[0];
}
return(animalDetectado);
}
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);
}
}
public ActionResult DeleteConfirmed(int id)
{
AnimalInfo animalInfo = db.AnimalInfo.Find(id);
AnimalBehavior animalBehavior = db.AnimalBehavior.Find(id);
AnimalHistory animalHistory = db.AnimalHistory.Find(id);
ChipIdentification chipIdentification = db.ChipIdentification.Find(id);
AdditionalContact additionalContact = db.AdditionalContact.Find(id);
AdditionalPetInfo additionalPetInfo = db.AdditonalPetInfo.Find(id);
Insurance insurance = db.Insurance.Find(id);
MedicalHistory medicalHistory = db.MedicalHistory.Find(id);
SecondaryContact secondaryContact = db.SecondaryContact.Find(id);
TrackingOperations trackingOperations = db.TrackingOperations.Find(id);
db.AnimalInfo.Remove(animalInfo);
db.AnimalBehavior.Remove(animalBehavior);
db.AnimalHistory.Remove(animalHistory);
db.ChipIdentification.Remove(chipIdentification);
db.AdditionalContact.Remove(additionalContact);
db.AdditonalPetInfo.Remove(additionalPetInfo);
db.Insurance.Remove(insurance);
db.MedicalHistory.Remove(medicalHistory);
db.SecondaryContact.Remove(secondaryContact);
db.TrackingOperations.Remove(trackingOperations);
db.SaveChanges();
return(RedirectToAction("Index"));
}
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>
/// 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 para ver si existe el animal como vendido
/// </summary>
/// <param name="animal"></param>
/// <returns></returns>
public VentaGanadoDetalleInfo ExisteAnimal(AnimalInfo animal)
{
try
{
Logger.Info();
Dictionary <string, object> parameters = AuxVentaGanadoDetalle.ObtenerParametrosAnimalID(animal);
DataSet ds = Retrieve("SalidaIndividualVenta_ObtenerVentaDetallePorAnimalID", parameters);
VentaGanadoDetalleInfo ventaDetalle = null;
if (ValidateDataSet(ds))
{
ventaDetalle = MapVentaGanadoDetalleDAL.ObtenerVentaGanadoDetalle(ds);
}
return(ventaDetalle);
}
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 para mapear y obtener la trazabilidad de animalMovimiento
/// </summary>
/// <param name="animal"></param>
/// <returns></returns>
internal AnimalInfo ObtenerTrazabilidadAnimalMovimiento(AnimalInfo animal)
{
try
{
Logger.Info();
Dictionary <string, object> parameters =
AuxAnimalMovimientoDAL.ObtenerTrazabilidadAnimalMovimiento(animal);
var ds = Retrieve("AnimalMovimiento_ObtenerTrazabilidadAnimalMovimiento", parameters);
AnimalInfo result = null;
if (ValidateDataSet(ds))
{
result = MapAnimalMovimientosDAL.ObtenerTrazabilidadAnimalMovimiento(ds, animal);
}
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);
}
}
public void TestGetDangerousAnimals()
{
var expected = 1;
var repository = new Repository <AnimalInfo>();
Shark shark = new Shark()
{
Name = "The great White Shark", IsDangerous = true
};
Tarantula tarantula = new Tarantula()
{
Name = "Rose hair tarantula"
};
var tarantulaInfo = new AnimalInfo(tarantula);
tarantulaInfo.Image = "Some base64 tarantula image";
var sharkInfo = new AnimalInfo(shark);
sharkInfo.Image = "Some base64 of great white shark image";
repository.Insert(sharkInfo);
repository.Insert(tarantulaInfo);
var actual = repository.GetDangerous().Count;
Assert.AreEqual(expected, actual);
}
/// <summary>
/// Metodo para guardar la transferencia de ganado con compensacion de animal
/// </summary>
/// <param name="animal"></param>
/// <param name="corralDestino"></param>
/// <param name="animalCompensado"></param>
/// <param name="corralOrigen"></param>
/// <param name="usuario"></param>
/// <param name="decrementarCabezas"></param>
/// <returns></returns>
internal bool GuardarTransferenciaGanadoCompensacion(AnimalInfo animal, CorralInfo corralDestino, AnimalInfo animalCompensado, CorralInfo corralOrigen, int usuario, bool decrementarCabezas)
{
bool resp = false;
try
{
Logger.Info();
var transferenciaDAL = new TransferenciaGanadoIndividualDAL();
using (var transaccion = new TransactionScope())
{
// Se envia el animal al destino
resp = transferenciaDAL.GuardarTransferenciaGanado(animal, corralDestino, usuario, decrementarCabezas);
// Se envia el animal compensado al origen
resp = transferenciaDAL.GuardarTransferenciaGanado(animalCompensado, corralOrigen, usuario, decrementarCabezas);
transaccion.Complete();
}
}
catch (ExcepcionGenerica)
{
throw;
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
return(resp);
}
public void Tick(IHTNAgent npc, float deltaTime, float time)
{
ScientistJunkpileContext npcContext = npc.AiDomain.NpcContext as ScientistJunkpileContext;
if (npcContext == null)
{
return;
}
BaseNpc animal = (BaseNpc)null;
float sqrDistance = float.MaxValue;
for (int index = 0; index < npcContext.AnimalsInRange.Count; ++index)
{
AnimalInfo animalInfo = npcContext.AnimalsInRange[index];
if (Object.op_Inequality((Object)animalInfo.Animal, (Object)null) && (double)animalInfo.SqrDistance < (double)sqrDistance)
{
sqrDistance = animalInfo.SqrDistance;
animal = animalInfo.Animal;
}
}
if (Object.op_Inequality((Object)animal, (Object)null) && AnimalReasoner.IsNearby(npcContext.Domain, sqrDistance))
{
npcContext.Memory.RememberPrimaryAnimal(animal);
npcContext.SetFact(Rust.Ai.HTN.ScientistJunkpile.Facts.NearbyAnimal, true, true, true, true);
}
else
{
npcContext.SetFact(Rust.Ai.HTN.ScientistJunkpile.Facts.NearbyAnimal, false, true, true, true);
}
}
public void Tick(IHTNAgent npc, float deltaTime, float time)
{
BearContext npcContext = npc.AiDomain.NpcContext as BearContext;
if (npcContext == null)
{
return;
}
BaseNpc animal = null;
float sqrDistance = Single.MaxValue;
for (int i = 0; i < npcContext.AnimalsInRange.Count; i++)
{
AnimalInfo item = npcContext.AnimalsInRange[i];
if (item.Animal != null && item.SqrDistance < sqrDistance)
{
sqrDistance = item.SqrDistance;
animal = item.Animal;
}
}
if (!(animal != null) || sqrDistance >= npc.AiDefinition.Engagement.SqrMediumRange)
{
npcContext.SetFact(Facts.NearbyAnimal, false, true, true, true);
return;
}
npcContext.Memory.RememberPrimaryAnimal(animal);
npcContext.SetFact(Facts.NearbyAnimal, true, true, true, true);
}
public static AnimalInfo ValidaEsAnimalDeCargaInicial(AnimalInfo animalInfo)
{
AnimalInfo animal = null;
try{
var seguridad = HttpContext.Current.Session["Seguridad"] as SeguridadInfo;
int organizacionId = seguridad.Usuario.Organizacion.OrganizacionID;
var animalPl = new AnimalPL();
/* Validar Si el arete existe en el inventario */
animal = animalPl.ObtenerAnimalPorArete(animalInfo.Arete, organizacionId);
if (!(animal != null && animal.CargaInicial))
{
animal = null;
}
}
catch (Exception ex)
{
Logger.Error(ex);
//throw;
}
return(animal);
}
/// <summary>
/// Obtener entrada de ganado
/// </summary>
/// <param name="animalInfo"></param>
/// <returns></returns>
internal EntradaGanadoInfo ObtenerEntradaGanado(AnimalInfo animalInfo)
{
EntradaGanadoInfo result = null;
try
{
Logger.Info();
var parameters = AuxCorteTransferenciaGanado.ObtenerParametrosEntradaGanado(animalInfo);
var ds = Retrieve("CorteTransferenciaGanado_ObtenerEntradaGanado", parameters);
if (ValidateDataSet(ds))
{
result = MapCorteTransferenciaGanadoDAL.ObtenerEntradaGanado(ds);
}
}
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);
}
return(result);
}
/// <summary>
/// Metodo para guardar la transferencia de ganado con compensacion de animal
/// </summary>
/// <param name="animal"></param>
/// <param name="corralDestino"></param>
/// <param name="animalCompensado"></param>
/// <param name="corralOrigen"></param>
/// <param name="usuario"></param>
/// <param name="decrementarCabezas"></param>
/// <returns></returns>
public bool GuardarTransferenciaGanadoCompensacion(AnimalInfo animal, CorralInfo corralDestino, AnimalInfo animalCompensado, CorralInfo corralOrigen, int usuario, bool decrementarCabezas)
{
bool resultado = false;
try
{
Logger.Info();
var transferenciaBL = new TransferenciaGanadoIndividualBL();
resultado = transferenciaBL.GuardarTransferenciaGanadoCompensacion(animal,
corralDestino,
animalCompensado,
corralOrigen,
usuario,
decrementarCabezas);
}
catch (ExcepcionGenerica)
{
throw;
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
return(resultado);
}
private void AnimalsList_SelectionChanged(object sender, SelectionChangedEventArgs e)
{
var item = (ListBox)sender;
var animal = (Animal)item.SelectedItem;
AnimalInfo.Navigate(new AnimalPage(animal));
}
public void Tick(IHTNAgent npc, float deltaTime, float time)
{
NPCTurretContext npcContext = npc.AiDomain.NpcContext as NPCTurretContext;
if (npcContext == null)
{
return;
}
BaseNpc animal = null;
float sqrDistance = Single.MaxValue;
for (int i = 0; i < npcContext.AnimalsInRange.Count; i++)
{
AnimalInfo item = npcContext.AnimalsInRange[i];
if (item.Animal != null && item.SqrDistance < sqrDistance)
{
sqrDistance = item.SqrDistance;
animal = item.Animal;
}
}
if (animal != null)
{
AttackEntity firearm = npcContext.Domain.GetFirearm();
if (sqrDistance < npc.AiDefinition.Engagement.SqrCloseRangeFirearm(firearm))
{
npcContext.Memory.RememberPrimaryAnimal(animal);
npcContext.SetFact(Facts.NearbyAnimal, true, true, true, true);
return;
}
}
npcContext.SetFact(Facts.NearbyAnimal, false, true, true, true);
}
/// <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);
}
}
public void OnPostSearch1()
{
RegionEndpoint region = Config.ConfigManager.GetRegion();
string idToken = HttpContext.GetTokenAsync("id_token").Result;
string identityPoolId = "ap-southeast-2:c8b11111-ea22-3333-4444-555555555c5a";
string userPoolId = "ap-southeast-2_U634533B";
string providerName = $"cognito-idp.ap-southeast-2.amazonaws.com/{userPoolId}";
CognitoAWSCredentials cognitoCredentials = new CognitoAWSCredentials(identityPoolId, region);
cognitoCredentials.AddLogin(providerName, idToken);
IAmazonDynamoDB db = new AmazonDynamoDBClient(cognitoCredentials, region);
string tableName = "Animals";
Table animalTbl = Table.LoadTable(db, tableName);
var singleItem = animalTbl.GetItemAsync(AnimalId).Result;
AnimalSet = new List <AnimalInfo>();
if (singleItem != null)
{
AnimalInfo info = new AnimalInfo();
info.AnimalId = singleItem.ContainsKey("AnimalId") ? (string)singleItem["AnimalId"] : String.Empty;
info.Name = singleItem.ContainsKey("Name") ? (string)singleItem["Name"] : String.Empty;
info.Age = singleItem.ContainsKey("Age") ? int.Parse(singleItem["Age"]) : 0;
info.Breed = singleItem.ContainsKey("Breed") ? (string)singleItem["Breed"] : String.Empty;
info.Image = singleItem.ContainsKey("Image") ? (string)singleItem["Image"] : String.Empty;
AnimalSet.Add(info);
}
}
/// <summary>
/// Obtiene El animal que se encuentren salida
/// </summary>
/// <param name="animalInfo"></param>
/// <returns></returns>
internal AnimalSalidaInfo AnimalSalidaEnfermeria(AnimalInfo animalInfo)
{
try
{
Logger.Info();
Dictionary <string, object> parametros =
AuxEnfermeriaDAL.ObtenerParametrosAnimalSalidaEnfermeria(animalInfo);
DataSet ds = Retrieve("CorteTransferenciaGanado_AnimalSalidaEnfermeria", parametros);
AnimalSalidaInfo animalResultadoInfo = null;
if (ValidateDataSet(ds))
{
animalResultadoInfo = MapAnimalDAL.ObtenerAnimalSalidaDatos(ds);
}
return(animalResultadoInfo);
}
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);
}
}
public void OnPostSearch2()
{
AWSCredentials stsCredentails = _securityClient.GetTenantCredentials();
IAmazonDynamoDB db = new AmazonDynamoDBClient(stsCredentails, Amazon.RegionEndpoint.APSoutheast2);
string tableName = "Animals";
Table animalTbl = Table.LoadTable(db, tableName);
GetItemOperationConfig config = new GetItemOperationConfig();
config.AttributesToGet = new List <string>();
config.AttributesToGet.Add("AnimalId");
config.AttributesToGet.Add("Name");
config.AttributesToGet.Add("Age");
// config.AttributesToGet.Add("Breed");
config.AttributesToGet.Add("Image");
var singleItem = animalTbl.GetItemAsync(AnimalId, config).Result;
AnimalSet = new List <AnimalInfo>();
if (singleItem != null)
{
AnimalInfo info = new AnimalInfo();
info.AnimalId = singleItem.ContainsKey("AnimalId")? (string)singleItem["AnimalId"]:String.Empty;
info.Name = singleItem.ContainsKey("Name") ? (string)singleItem["Name"] : String.Empty;
info.Age = singleItem.ContainsKey("Age") ? int.Parse(singleItem["Age"]) : 0;
info.Breed = singleItem.ContainsKey("Breed") ? (string)singleItem["Breed"] : String.Empty;
info.Image = singleItem.ContainsKey("Image") ? (string)singleItem["Image"] : String.Empty;
AnimalSet.Add(info);
}
}
private void CreateAllFound(IEnumerable <RawInfoHolder> raws)
{
foreach (RawInfoHolder r in raws)
{
AnimalInfo.CreateNewAsset(r);
}
}
public ModifyAdoptInfoViewModel(AnimalInfo item)
{
this.AnimalID = item.AnimalID;
this.AgeAndUnit = item.Age;
this.Age = (!string.IsNullOrEmpty(item.Age)?item.Age.Substring(0, item.Age.Length - 1):"");
this.CityLocation = item.CityLocation;
this.Contacter = item.Contacter;
this.ContacterEmail = item.ContacterEmail;
this.ContacterPhone = item.ContacterPhone;
this.CoverHeader = item.Header;
this.CoverIntro = item.ShortIntro;
this.CoverPhotoByte = item.Photo;
this.Height = item.Height;
this.Introduction = item.Intro;
this.IsOpen = item.IsOpen.Value;
this.IsSpay = item.IsSpay;
this.Length = item.Length;
this.Name = item.Name;
this.Personality = item.Personality;
this.PhotoExtension = item.PhotoExt;
this.SpecialNeed = item.SpecialNeed;
this.Type = item.Type;
this.Unit = item.Unit;
this.Weight = item.Weight;
}
/// <summary>
/// Método para obtener los datos de la compra
/// </summary>
/// <param name="ds"></param>
/// <returns></returns>
internal static AnimalInfo ObtenerDatosReimplante(DataSet ds)
{
AnimalInfo resultado = null;
try
{
Logger.Info();
resultado = MapAnimalDAL.ObtenerAnimal(ds);
foreach (DataRow dr in ds.Tables[0].Rows)
{
resultado.Corral = Convert.ToString(dr["CodigoCorral"]);
if (String.IsNullOrEmpty(Convert.ToString(dr["Peso"])))
{
resultado.PesoAlCorte = 0;
}
else
{
resultado.PesoAlCorte = Convert.ToInt32(dr["Peso"]);
}
}
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
return(resultado);
}
/// <summary>
/// Metodo para enviar animal de AnimalCosto a AnimalCostoHistorico
/// </summary>
/// <param name="animalInactivo"></param>
public bool EnviarAnimalMovimientoAHistorico(AnimalInfo animalInactivo)
{
var envioCosto = false;
try
{
Logger.Info();
var animalMovimientoDAL = new AnimalMovimientoDAL();
//Se envia el animal de AnimalMovimiento a AnimalMovimientoHistorico
animalMovimientoDAL.EnviarAnimalMovimientoAHistorico(animalInactivo);
//Se elimina el animal de AnimalMovimiento
animalMovimientoDAL.EliminarAnimalMovimiento(animalInactivo);
envioCosto = true;
}
catch (ExcepcionGenerica)
{
throw;
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
return(envioCosto);
}
/// <summary>
/// Elimina el consumo de tabla
/// </summary>
/// <param name="animalInactivo"></param>
internal void EliminarAnimalConsumo(AnimalInfo animalInactivo)
{
try
{
Logger.Info();
var parameters = new Dictionary <string, object> {
{ "@AnimalID", animalInactivo.AnimalID }
};
Delete("AnimalConsumo_EliminarAnimalConsumo", parameters);
}
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>
/// Obtiene un listado de corrales por tipo
/// </summary>
/// <param name="animalInfo"></param>
/// <param name="tipoMovimiento"></param>
/// <returns></returns>
internal List <TratamientoInfo> ObtenerTratamientosAnimal(AnimalInfo animalInfo, int tipoMovimiento)
{
try
{
Logger.Info();
Dictionary <string, object> parametros = AuxCorteTransferenciaGanado.ObtenerParametrosMovimientosAnimal(animalInfo, tipoMovimiento);
DataSet ds = Retrieve("CorteTransferenciaGanado_ObtenerTratamientosAplicados", parametros);
List <TratamientoInfo> tratamientos = null;
if (ValidateDataSet(ds))
{
tratamientos = MapCorteTransferenciaGanadoDAL.ObtenerTratamientosAplicados(ds);
}
return(tratamientos);
}
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 para guardar la transferencia de ganado
/// </summary>
/// <param name="animal"></param>
/// <param name="corralDestino"></param>
/// <param name="usuario"></param>
/// <param name="decrementaCabezas"></param>
/// <returns></returns>
internal bool GuardarTransferenciaGanado(AnimalInfo animal, CorralInfo corralDestino, int usuario, bool decrementaCabezas)
{
try
{
Logger.Info();
var parametros = new Dictionary <string, object>
{
{ "@AnimalID", animal.AnimalID },
{ "@CorralDestinoID", corralDestino.CorralID },
{ "@UsuarioCreacionID", usuario },
{ "@DecrementaCabezas", decrementaCabezas }
};
Create("TransferenciaGanadoIndividual_Guardar", parametros);
return(true);
}
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);
}
}
/// Obtiene un animal en casi de que exista
internal AnimalInfo ObtenerExistenciaAnimal(AnimalInfo animalInfo, int loteID)
{
try
{
Logger.Info();
Dictionary <string, object> parametros = AuxProgramacionSacrificio.ObtenerParametrosObtenerExistenciaAnimal(animalInfo, loteID);
DataSet ds = Retrieve("ProgramacionSacrificio_ObtenerExistenciaAnimal", parametros);
AnimalInfo result = null;
if (ValidateDataSet(ds))
{
result = MapProgramacionSacrificioDAL.ObtenerExistenciaAnimal(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);
}
}
