/// <summary>
/// Obtiene la lista de tratamientos por TipoTrtamiento
/// </summary>
/// <param name="tratamientoInfo"></param>
/// <returns></returns>
public IList <TratamientoInfo> ObtenerTratamientosPorTipo(TratamientoInfo tratamientoInfo)
{
try
{
Logger.Info();
Dictionary <string, object> parameters =
AuxTratamientoDAL.ObtenerParametrosObtenerTratamientosPorTipo(tratamientoInfo);
DataSet ds = Retrieve("TratamientoGanado_ObtenerPorTipo", parameters);
IList <TratamientoInfo> result = null;
if (ValidateDataSet(ds))
{
result = MapTratamientoDAL.ObtenerTipoTratamientos(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>
/// Metodo para Crear un registro de Tratamiento
/// </summary>
/// <param name="info">Valores de la entidad que será creada</param>
internal int Centros_Crear(TratamientoInfo info)
{
try
{
Logger.Info();
Dictionary <string, object> parameters = AuxTratamientoDAL.Centros_ObtenerParametrosCrear(info);
int result = Create("TratamientoCentros_Crear", 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);
}
}
/// <summary>
/// Metodo para Crear un registro de Tratamiento
/// </summary>
/// <param name="info">Valores de la entidad que será creada</param>
/// <param name="tratamientoID">Valores de la entidad que será creada</param>
internal int GuardarTratamientoProducto(TratamientoInfo info, int tratamientoID)
{
try
{
Logger.Info();
Dictionary <string, object> parameters = AuxTratamientoDAL.GuardarTratamientoProducto(info, tratamientoID);
int result = Create("Tratamiento_GuardarTratamientoProducto", 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);
}
}
/// <summary>
/// Valida si el código del tratamiento ya existe para esa organización
/// </summary>
/// <param name="info"></param>
internal bool ValidarExisteTratamiento(TratamientoInfo info)
{
try
{
Logger.Info();
Dictionary <string, object> parameters = AuxTratamientoDAL.ObtenerParametrosValidaExisteTratamiento(info);
DataSet ds = Retrieve("Tratamiento_ObtenerPorOrganizacionCodigo", parameters);
bool result = ValidateDataSet(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>
/// Método que obtiene un registro
/// </summary>
/// <param name="ds"></param>
/// <returns></returns>
internal static TratamientoInfo ObtenerPorDescripcion(DataSet ds)
{
try
{
Logger.Info();
DataTable dt = ds.Tables[ConstantesDAL.DtDatos];
TratamientoInfo entidad =
(from info in dt.AsEnumerable()
select
new TratamientoInfo
{
TratamientoID = info.Field <int>("TratamientoID"),
Organizacion = new OrganizacionInfo {
OrganizacionID = info.Field <int>("OrganizacionID"), Descripcion = info.Field <string>("Organizacion")
},
CodigoTratamiento = info.Field <int>("CodigoTratamiento"),
TipoTratamientoInfo = new TipoTratamientoInfo {
TipoTratamientoID = info.Field <int>("TipoTratamientoID"), Descripcion = info.Field <string>("TipoTratamiento")
},
Sexo = Sexo.Macho.ToString()[0].ToString() == info.Field <string>("Sexo") ? Sexo.Macho : Sexo.Hembra,
RangoInicial = info.Field <int>("RangoInicial"),
RangoFinal = info.Field <int>("RangoFinal"),
Activo = info.Field <bool>("Activo").BoolAEnum(),
}).First();
return(entidad);
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
}
/// <summary>
/// Obtiene un registro de Tratamiento
/// </summary>
/// <param name="descripcion">Descripción de la Tratamiento</param>
/// <returns></returns>
internal TratamientoInfo ObtenerPorDescripcion(string descripcion)
{
try
{
Logger.Info();
Dictionary <string, object> parameters = AuxTratamientoDAL.ObtenerParametrosPorDescripcion(descripcion);
DataSet ds = Retrieve("Tratamiento_ObtenerPorDescripcion", parameters);
TratamientoInfo result = null;
if (ValidateDataSet(ds))
{
result = MapTratamientoDAL.ObtenerPorDescripcion(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);
}
}
internal IList <TratamientoInfo> ObtenerTratamientosCorte(TratamientoInfo tratamientoInfo, Metafilaxia bMetafilaxia)
{
try
{
IList <TratamientoInfo> result = null;
Logger.Info();
Dictionary <string, object> parameters = AuxTratamientoDAL.ObtenerTipoTratamientos(tratamientoInfo, bMetafilaxia);
DataSet ds = Retrieve("TratamientoGanado_Obtener", parameters);
if (ValidateDataSet(ds))
{
result = MapTratamientoDAL.ObtenerTipoTratamientos(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>
/// Metodo para Guardar/Modificar una entidad Tratamiento
/// </summary>
/// <param name="info"></param>
internal void Centros_Guardar(TratamientoInfo info)
{
try
{
using (TransactionScope transaction = new TransactionScope())
{
Logger.Info();
var tratamientoDAL = new TratamientoDAL();
int tratamientoID = info.TratamientoID;
int organizacionID = info.Organizacion.OrganizacionID;
if (tratamientoID == 0)
{
tratamientoID = tratamientoDAL.Centros_Crear(info);
}
else
{
tratamientoDAL.Centros_Actualizar(info);
}
tratamientoDAL.Centros_GuardarTratamientoProducto(info, tratamientoID, organizacionID);
info.TratamientoID = tratamientoID;
transaction.Complete();
}
}
catch (ExcepcionGenerica)
{
throw;
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
}
/// <summary>
/// Obtiene los datos de los problemas de la deteccion
/// </summary>
/// <param name="ds">Dataset con los datos</param>
/// <param name="tratamiento"></param>
/// <returns></returns>
internal static List <ProblemaInfo> ObtenerProblemasPorDeteccion(DataSet ds, TratamientoInfo tratamiento)
{
List <ProblemaInfo> problemas;
try
{
Logger.Info();
DataTable dt = ds.Tables[ConstantesDAL.DtDatos];
var tratamientosDAL = new TratamientoDAL();
problemas = (from info in dt.AsEnumerable()
select new ProblemaInfo
{
ProblemaID = info.Field <int>("ProblemaID"),
Descripcion = info.Field <string>("Descripcion"),
isCheked = true,
Tratamientos = tratamiento == null ? null :tratamientosDAL.ObtenerTratamientosPorProblemas(tratamiento, new List <int> {
info.Field <int>("ProblemaID")
}),
TipoProblema = new TipoProblemaInfo {
TipoProblemaId = info.Field <int>("TipoProblemaId")
},
}).ToList();
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
return(problemas);
}
/// <summary>
/// Obtiene solo la lista de tratamientos seleccionados y sus productos
/// </summary>
/// <param name="tratamientos"></param>
/// <returns></returns>
internal List <ProductoInfo> ObtenerProductosDelTratamiento(TratamientoInfo tratamientos)
{
var contador = 0;
var listaProductos = new List <ProductoInfo>();
try
{
Logger.Info();
var productoDal = new ProductoDAL();
ResultadoInfo <ProductoInfo> result = productoDal.ObtenerProductosPorTratamiento(tratamientos);
foreach (var producto in result.Lista)
{
producto.Renglon = ++contador;
listaProductos.Add(producto);
}
return(listaProductos);
}
catch (ExcepcionGenerica)
{
throw;
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
}
/// <summary>
/// Obtiene los tratamientos por tipo de tratamiento de reimplante
/// </summary>
/// <param name="tratamientoInfo"></param>
/// <returns></returns>
internal IList <TratamientoInfo> ObtenerTratamientosPorTipoReimplante(TratamientoInfo tratamientoInfo)
{
try
{
Logger.Info();
var tratamientoDAL = new TratamientoDAL();
IList <TratamientoInfo> tratamientos = tratamientoDAL.ObtenerTratamientosPorTipoReimplante(tratamientoInfo);
if (tratamientos != null)
{
var productoDal = new ProductoDAL();
ResultadoInfo <ProductoInfo> result = productoDal.ObtenerProductosPorTratamientoPorXML(tratamientos.ToList());
if (result != null && result.Lista != null && result.Lista.Any())
{
tratamientos.ForEach(prod =>
{
prod.Productos =
result.Lista.Where(id => id.TratamientoID == prod.TratamientoID).
Select(p => p).ToList();
});
}
}
return(tratamientos);
}
catch (ExcepcionGenerica)
{
throw;
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
}
/// <summary>
/// Obtiene parametros para crear
/// </summary>
/// <param name="tratamiento">Valores de la entidad</param>
/// <param name="tratamientoID">Id de la tabla Tratamiento</param>
/// <returns></returns>
internal static Dictionary <string, object> GuardarTratamientoProducto(TratamientoInfo tratamiento, int tratamientoID)
{
try
{
Logger.Info();
var xml =
new XElement("ROOT",
from info in tratamiento.ListaTratamientoProducto
select
new XElement("TratamientoProducto",
new XElement("TratamientoProductoID", info.TratamientoProductoID),
new XElement("TratamientoID", tratamientoID),
new XElement("ProductoID", info.Producto.ProductoId),
new XElement("Dosis", info.Dosis),
new XElement("Activo", info.Activo.GetHashCode()),
new XElement("UsuarioCreacionID", info.UsuarioCreacionID),
new XElement("UsuarioModificacionID", info.UsuarioModificacionID)
));
var parametros =
new Dictionary <string, object>
{
{ "@XmlTratamientoProducto", xml.ToString() }
};
return(parametros);
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
}
/// <summary>
/// Obtiene parametros para crear
/// </summary>
/// <param name="info">Valores de la entidad</param>
/// <returns></returns>
internal static Dictionary <string, object> ObtenerParametrosCrear(TratamientoInfo info)
{
try
{
Logger.Info();
var parametros =
new Dictionary <string, object>
{
{ "@OrganizacionID", info.Organizacion.OrganizacionID },
{ "@CodigoTratamiento", info.CodigoTratamiento },
{ "@TipoTratamientoID", info.TipoTratamientoInfo.TipoTratamientoID },
{ "@Sexo", info.Sexo == Sexo.Macho ? 'M' : 'H' },
//{"@Sexo", info.Sexo},
{ "@RangoInicial", info.RangoInicial },
{ "@RangoFinal", info.RangoFinal },
{ "@UsuarioCreacionID", info.UsuarioCreacionID },
{ "@Activo", info.Activo },
};
return(parametros);
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
}
public void ObtenerTratamientoPorId()
{
var tratamientoPL = new TratamientoPL();
TratamientoInfo tratamiento = tratamientoPL.ObtenerPorID(3);
Assert.IsNotNull(tratamiento);
Assert.IsNotNull(tratamiento.Organizacion);
Assert.IsNotNull(tratamiento.TipoTratamientoInfo);
Assert.IsTrue(tratamiento.Organizacion.Descripcion.Length > 0);
Assert.IsTrue(tratamiento.TipoTratamientoInfo.Descripcion.Length > 0);
}
/// <summary>
/// Obtiene la lista de tratamientos por problema
/// </summary>
/// <param name="tratamientoInfo"></param>
/// <param name="listaProblemas"></param>
/// <returns></returns>
internal IList <TratamientoInfo> ObtenerTratamientosPorProblemas(TratamientoInfo tratamientoInfo, List <int> listaProblemas)
{
try
{
Logger.Info();
var tratamientoDAL = new TratamientoDAL();
var resultTratamientos = tratamientoDAL.ObtenerTratamientosPorProblemas(tratamientoInfo, listaProblemas);
List <TratamientoInfo> lista = null;
//Eliminar los tratamientos repetidos
if (resultTratamientos != null)
{
lista = EliminarTratamientosRepetidos(resultTratamientos);
}
/* Se obtendran los tratamiento de Aretes sin ligarlos al problema */
tratamientoInfo.TipoTratamiento = (int)TipoTratamiento.Arete;
var resultTrataamientosArete = tratamientoDAL.ObtenerTratamientosPorTipo(tratamientoInfo);
if (lista == null)
{
lista = new List <TratamientoInfo>();
}
if (resultTrataamientosArete != null)
{
lista.AddRange(resultTrataamientosArete);
}
if (lista != null)
{
var productoDal = new ProductoDAL();
ResultadoInfo <ProductoInfo> result = productoDal.ObtenerProductosPorTratamientoPorXML(lista);
if (result != null && result.Lista != null && result.Lista.Any())
{
lista.ForEach(prod =>
{
prod.Productos =
result.Lista.Where(id => id.TratamientoID == prod.TratamientoID).
Select(p => p).ToList();
});
}
}
return(lista);
}
catch (ExcepcionGenerica)
{
throw;
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
}
/// <summary>
/// Metodo que inicializa los objetos principales de la pantalla
/// </summary>
private void InicializaContexto()
{
TratamientoInfo = new TratamientoInfo
{
Organizacion = new OrganizacionInfo
{
TipoOrganizacion = new TipoOrganizacionInfo()
},
TipoTratamientoInfo = new TipoTratamientoInfo(),
ListaTratamientoProducto = new List <TratamientoProductoInfo>(),
Sexo = Sexo.Hembra
};
}
private void CargarTratamientos(IEnumerable <ProblemaTratamientoInfo> lista)
{
var tratamientoDAL = new TratamientoDAL();
IList <TratamientoInfo> listaTratamientos = tratamientoDAL.ObtenerTodos();
foreach (ProblemaTratamientoInfo problemaTratamiento in lista)
{
TratamientoInfo tratamiento =
listaTratamientos.FirstOrDefault(tra => tra.TratamientoID == problemaTratamiento.TratamientoID);
if (tratamiento == null)
{
continue;
}
problemaTratamiento.Tratamiento = tratamiento;
}
}
/// <summary>
/// Evento que se ejecuta mientras se esta cerrando la ventana
/// </summary>
/// <param name="e"></param>
protected override void OnClosing(CancelEventArgs e)
{
if (confirmaSalir)
{
MessageBoxResult result = SkMessageBox.Show(this, Properties.Resources.Msg_CerrarSinGuardar, MessageBoxButton.YesNo,
MessageImage.Question);
if (result == MessageBoxResult.Yes)
{
TratamientoInfo = null;
}
else
{
e.Cancel = true;
}
}
}
/// <summary>
/// Metodo para Guardar/Modificar una entidad Tratamiento
/// </summary>
/// <param name="info">Representa la entidad que se va a grabar</param>
public void Centros_Guardar(TratamientoInfo info)
{
try
{
Logger.Info();
var tratamientoBL = new TratamientoBL();
tratamientoBL.Centros_Guardar(info);
}
catch (ExcepcionGenerica)
{
throw;
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
}
/// <summary>
/// Valida si el código del tratamiento ya existe para esa organización
/// </summary>
/// <param name="filtro"></param>
/// <returns></returns>
internal bool ValidarExisteTratamiento(TratamientoInfo filtro)
{
try
{
Logger.Info();
var tratamientoDAL = new TratamientoDAL();
bool result = tratamientoDAL.ValidarExisteTratamiento(filtro);
return(result);
}
catch (ExcepcionGenerica)
{
throw;
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
}
/// <summary>
/// Obtiene los tratamientos por problema
/// </summary>
/// <param name="tratamientoInfo"></param>
/// <param name="listaProblemas"></param>
/// <returns></returns>
public IList <TratamientoInfo> ObtenerTratamientosPorProblemas(TratamientoInfo tratamientoInfo, List <int> listaProblemas)
{
try
{
Logger.Info();
var tratamientoBL = new TratamientoBL();
var result = tratamientoBL.ObtenerTratamientosPorProblemas(tratamientoInfo, listaProblemas);
return(result);
}
catch (ExcepcionGenerica)
{
throw;
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
}
/// <summary>
/// Obtiene una entidad por su Id
/// </summary>
/// <param name="tratamientoID"></param>
/// <returns></returns>
public TratamientoInfo ObtenerPorID(int tratamientoID)
{
try
{
Logger.Info();
var tratamientoBL = new TratamientoBL();
TratamientoInfo result = tratamientoBL.ObtenerPorID(tratamientoID);
return(result);
}
catch (ExcepcionGenerica)
{
throw;
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
}
/// <summary>
///
/// </summary>
/// <param name="tratamiento"></param>
/// <returns></returns>
public List <TratamientoProductoInfo> ObtenerPorTratamientoID(TratamientoInfo tratamiento)
{
try
{
Logger.Info();
var tratamientoProductoBL = new TratamientoProductoBL();
List <TratamientoProductoInfo> result = tratamientoProductoBL.ObtenerPorTratamientoID(tratamiento);
return(result);
}
catch (ExcepcionGenerica)
{
throw;
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
}
/// <summary>
/// Obtiene una entidad Tratamiento por su descripcion
/// </summary>
/// <param name="descripcion">Obtiene una entidad Tratamiento por su Id</param>
/// <returns></returns>
internal TratamientoInfo ObtenerPorDescripcion(string descripcion)
{
try
{
Logger.Info();
var tratamientoDAL = new TratamientoDAL();
TratamientoInfo result = tratamientoDAL.ObtenerPorDescripcion(descripcion);
return(result);
}
catch (ExcepcionGenerica)
{
throw;
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
}
/// <summary>
/// Obtiene la lista de tratamientos por tipo
/// </summary>
/// <param name="tratamientoInfo"></param>
/// <param name="bMetafilaxia"></param>
/// <returns></returns>
public IList <TratamientoInfo> ObtenerTipoTratamientosCorte(TratamientoInfo tratamientoInfo, Metafilaxia bMetafilaxia)
{
try
{
Logger.Info();
var tratamientoBL = new TratamientoBL();
IList <TratamientoInfo> result = tratamientoBL.ObtenerTipoTratamientosCorte(tratamientoInfo, bMetafilaxia);
return(result);
}
catch (ExcepcionGenerica)
{
throw;
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
}
internal static Dictionary <string, object> ObtenerTratamientosPorTipo(TratamientoInfo tratamiento)
{
try
{
Logger.Info();
var parametros =
new Dictionary <string, object>
{
{ "@OrganizacionID", tratamiento.OrganizacionId },
{ "@Sexo", tratamiento.Sexo.ToString()[0] },
{ "@Peso", tratamiento.Peso }
};
return(parametros);
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
}
/// <summary>
/// Obtiene parametros para crear
/// </summary>
/// <param name="info">Valores de la entidad</param>
/// <returns></returns>
internal static Dictionary <string, object> Centros_ObtenerParametrosCrear(TratamientoInfo info)
{
try
{
Logger.Info();
var parametros =
new Dictionary <string, object>
{
{ "@OrganizacionID", info.Organizacion.OrganizacionID },
{ "@CodigoTratamiento", info.CodigoTratamiento },
{ "@Descripcion", info.Auxiliar },
{ "@UsuarioCreacionID", info.UsuarioCreacionID },
{ "@Activo", info.Activo },
};
return(parametros);
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
}
/// <summary>
/// Constructor parametrizado
/// </summary>
public TratamientoEdicion(TratamientoInfo tratamiento)
{
try
{
TratamientoInfo = tratamiento;
if (TratamientoInfo.ListaTratamientoProducto != null && TratamientoInfo.ListaTratamientoProducto.Any())
{
int ordenSecuencia = 0;
TratamientoInfo.ListaTratamientoProducto.ForEach(productos =>
{
ordenSecuencia = ordenSecuencia + 1;
productos.Orden = ordenSecuencia;
});
}
InitializeComponent();
}
catch (Exception ex)
{
Logger.Error(ex);
SkMessageBox.Show(this, Properties.Resources.TratamientoEdicion_ErrorInicial, MessageBoxButton.OK, MessageImage.Error);
}
}
/// <summary>
/// Obtiene el historial clinico
/// </summary>
/// <param name="animal"></param>
/// <returns></returns>
internal IList <HistorialClinicoInfo> ObtenerHistorialClinico(AnimalInfo animal)
{
try
{
Logger.Info();
Dictionary <string, object> parametros =
AuxEnfermeriaDAL.ObtenerHistorialClinico(animal);
DataSet ds = Retrieve("Enfermeria_ObtenerHistorialClinico", parametros);
IList <HistorialClinicoInfo> historialClinico = null;
var tratamiento = new TratamientoInfo
{
OrganizacionId = animal.OrganizacionIDEntrada,
Sexo = animal.TipoGanado.Sexo
};
if (ValidateDataSet(ds))
{
historialClinico =
MapEnfermeriaDal.ObtenerHistorialClinico(ds, tratamiento);
}
return(historialClinico);
}
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 la lista de tratamientos especificada para corte
/// </summary>
/// <param name="tratamientoInfo"></param>
/// <param name="bMetafilaxia"></param>
/// <returns></returns>
internal IList <TratamientoInfo> ObtenerTipoTratamientosCorte(TratamientoInfo tratamientoInfo, Metafilaxia bMetafilaxia)
{
try
{
Logger.Info();
var tratamientoDAL = new TratamientoDAL();
IList <TratamientoInfo> lista = null;
IList <TratamientoInfo> resultTrataamientos =
tratamientoDAL.ObtenerTratamientosCorte(tratamientoInfo, bMetafilaxia);
if (resultTrataamientos != null)
{
//Eliminar los tratamientos repetidos
lista = EliminarTratamientosRepetidos(resultTrataamientos);
var productoDal = new ProductoDAL();
ResultadoInfo <ProductoInfo> result = productoDal.ObtenerProductosPorTratamientoPorXML(lista.ToList());
if (result != null && result.Lista != null && result.Lista.Any())
{
lista.ForEach(prod =>
{
prod.Productos =
result.Lista.Where(id => id.TratamientoID == prod.TratamientoID).
Select(p => p).ToList();
});
}
}
return(lista);
}
catch (ExcepcionGenerica)
{
throw;
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
}