コード例 #1
0
 /// <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);
     }
 }
コード例 #2
0
 /// <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);
     }
 }
コード例 #3
0
 /// <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);
     }
 }
コード例 #4
0
 /// <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);
     }
 }
コード例 #5
0
 /// <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);
     }
 }
コード例 #6
0
 /// <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);
     }
 }
コード例 #7
0
        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);
            }
        }
コード例 #8
0
ファイル: TratamientoBL.cs プロジェクト: vijaydairyf/Prueba
 /// <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);
     }
 }
コード例 #9
0
        /// <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);
        }
コード例 #10
0
ファイル: TratamientoBL.cs プロジェクト: vijaydairyf/Prueba
        /// <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);
            }
        }
コード例 #11
0
ファイル: TratamientoBL.cs プロジェクト: vijaydairyf/Prueba
 /// <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);
     }
 }
コード例 #12
0
 /// <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);
     }
 }
コード例 #13
0
 /// <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);
     }
 }
コード例 #14
0
ファイル: Tratamiento.cs プロジェクト: vijaydairyf/Prueba
        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);
        }
コード例 #15
0
ファイル: TratamientoBL.cs プロジェクト: vijaydairyf/Prueba
        /// <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);
            }
        }
コード例 #16
0
 /// <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
     };
 }
コード例 #17
0
        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;
            }
        }
コード例 #18
0
 /// <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;
         }
     }
 }
コード例 #19
0
 /// <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);
     }
 }
コード例 #20
0
ファイル: TratamientoBL.cs プロジェクト: vijaydairyf/Prueba
 /// <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);
     }
 }
コード例 #21
0
 /// <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);
     }
 }
コード例 #22
0
 /// <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);
     }
 }
コード例 #23
0
 /// <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);
     }
 }
コード例 #24
0
ファイル: TratamientoBL.cs プロジェクト: vijaydairyf/Prueba
 /// <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);
     }
 }
コード例 #25
0
        /// <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);
            }
        }
コード例 #26
0
 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);
     }
 }
コード例 #27
0
 /// <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);
     }
 }
コード例 #28
0
 /// <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);
     }
 }
コード例 #29
0
        /// <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);
            }
        }
コード例 #30
0
ファイル: TratamientoBL.cs プロジェクト: vijaydairyf/Prueba
        /// <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);
            }
        }