Exemple #1
0
 /// <summary>
 /// Metodo para Crear un registro de TipoParametro
 /// </summary>
 /// <param name="info">Valores de la entidad que será creada</param>
 internal int Crear(TipoParametroInfo info)
 {
     try
     {
         Logger.Info();
         Dictionary <string, object> parameters = AuxTipoParametroDAL.ObtenerParametrosCrear(info);
         int result = Create("TipoParametro_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 Guardar/Modificar una entidad TipoParametro
 /// </summary>
 /// <param name="info"></param>
 internal int Guardar(TipoParametroInfo info)
 {
     try
     {
         Logger.Info();
         var tipoParametroDAL = new TipoParametroDAL();
         int result           = info.TipoParametroID;
         if (info.TipoParametroID == 0)
         {
             result = tipoParametroDAL.Crear(info);
         }
         else
         {
             tipoParametroDAL.Actualizar(info);
         }
         return(result);
     }
     catch (ExcepcionGenerica)
     {
         throw;
     }
     catch (Exception ex)
     {
         Logger.Error(ex);
         throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
     }
 }
Exemple #3
0
 /// <summary>
 /// Obtiene los tipos parametro
 /// </summary>
 private void ObtenerTiposParametro()
 {
     try
     {
         var tipoParametroPL = new TipoParametroPL();
         IList <TipoParametroInfo> tiposParametros = tipoParametroPL.ObtenerTodos(EstatusEnum.Activo);
         var tipoParametroSeleccione = new TipoParametroInfo
         {
             Descripcion = Properties.Resources.cbo_Seleccionar
         };
         tiposParametros.Insert(0, tipoParametroSeleccione);
         //cmbTipoParametro.ItemsSource = tiposParametros;
     }
     catch (ExcepcionGenerica)
     {
         SkMessageBox.Show(Application.Current.Windows[ConstantesVista.WindowPrincipal],
                           Properties.Resources.ParametroTrampa_ErrorBuscar, MessageBoxButton.OK,
                           MessageImage.Error);
     }
     catch (Exception ex)
     {
         Logger.Error(ex);
         SkMessageBox.Show(Application.Current.Windows[ConstantesVista.WindowPrincipal],
                           Properties.Resources.ParametroTrampa_ErrorBuscar, MessageBoxButton.OK,
                           MessageImage.Error);
     }
 }
Exemple #4
0
 /// <summary>
 /// Obtiene un registro de TipoParametro
 /// </summary>
 /// <param name="descripcion">Descripción de la TipoParametro</param>
 /// <returns></returns>
 internal TipoParametroInfo ObtenerPorDescripcion(string descripcion)
 {
     try
     {
         Logger.Info();
         Dictionary <string, object> parameters = AuxTipoParametroDAL.ObtenerParametrosPorDescripcion(descripcion);
         DataSet           ds     = Retrieve("TipoParametro_ObtenerPorDescripcion", parameters);
         TipoParametroInfo result = null;
         if (ValidateDataSet(ds))
         {
             result = MapTipoParametroDAL.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);
     }
 }
Exemple #5
0
 /// <summary>
 /// Inicializa el Contexto
 /// </summary>
 private void InicializaContexto()
 {
     Contexto = new TipoParametroInfo
     {
         UsuarioCreacionID = AuxConfiguracion.ObtenerUsuarioLogueado(),
     };
 }
 /// <summary>
 /// Inicializa el Contexto
 /// </summary>
 private void InicializaContexto()
 {
     Contexto = new TipoParametroInfo
     {
         Descripcion       = string.Empty,
         Activo            = EstatusEnum.Activo,
         UsuarioCreacionID = AuxConfiguracion.ObtenerUsuarioLogueado(),
     };
 }
        private void CargaTipoParametro()
        {
            var tipoParametroPL   = new TipoParametroPL();
            var tipoParametroInfo = new TipoParametroInfo
            {
                TipoParametroID = 0,
                Descripcion     = Properties.Resources.cbo_Seleccione,
            };
            IList <TipoParametroInfo> listaTipoParametro = tipoParametroPL.ObtenerTodos(EstatusEnum.Activo);

            listaTipoParametro.Insert(0, tipoParametroInfo);
            cmbTipoParametro.ItemsSource  = listaTipoParametro;
            cmbTipoParametro.SelectedItem = tipoParametroInfo;
        }
Exemple #8
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)
         {
             Contexto = null;
         }
         else
         {
             e.Cancel = true;
         }
     }
 }
 /// <summary>
 /// Obtiene una entidad TipoParametro por su descripción
 /// </summary>
 /// <param name="descripcion"></param>
 /// <returns></returns>
 internal TipoParametroInfo ObtenerPorDescripcion(string descripcion)
 {
     try
     {
         Logger.Info();
         var tipoParametroDAL     = new TipoParametroDAL();
         TipoParametroInfo result = tipoParametroDAL.ObtenerPorDescripcion(descripcion);
         return(result);
     }
     catch (ExcepcionGenerica)
     {
         throw;
     }
     catch (Exception ex)
     {
         Logger.Error(ex);
         throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
     }
 }
Exemple #10
0
 /// <summary>
 /// Obtiene una entidad por su Id
 /// </summary>
 /// <param name="tipoParametroID"></param>
 /// <returns></returns>
 public TipoParametroInfo ObtenerPorID(int tipoParametroID)
 {
     try
     {
         Logger.Info();
         var tipoParametroBL      = new TipoParametroBL();
         TipoParametroInfo result = tipoParametroBL.ObtenerPorID(tipoParametroID);
         return(result);
     }
     catch (ExcepcionGenerica)
     {
         throw;
     }
     catch (Exception ex)
     {
         Logger.Error(ex);
         throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
     }
 }
Exemple #11
0
 /// <summary>
 /// Metodo para Guardar/Modificar una entidad TipoParametro
 /// </summary>
 /// <param name="info">Representa la entidad que se va a grabar</param>
 public int Guardar(TipoParametroInfo info)
 {
     try
     {
         Logger.Info();
         var tipoParametroBL = new TipoParametroBL();
         int result          = tipoParametroBL.Guardar(info);
         return(result);
     }
     catch (ExcepcionGenerica)
     {
         throw;
     }
     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(TipoParametroInfo info)
 {
     try
     {
         Logger.Info();
         var parametros =
             new Dictionary <string, object>
         {
             { "@Descripcion", info.Descripcion },
             { "@Activo", info.Activo },
             { "@UsuarioCreacionID", info.UsuarioCreacionID },
         };
         return(parametros);
     }
     catch (Exception ex)
     {
         Logger.Error(ex);
         throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
     }
 }
 /// <summary>
 /// Obtiene la lista para mostrar en el grid
 /// </summary>
 private void ObtenerListaTipoParametro(int inicio, int limite)
 {
     try
     {
         if (ucPaginacion.ContextoAnterior != null)
         {
             bool contextosIguales = ucPaginacion.CompararObjetos(Contexto, ucPaginacion.ContextoAnterior);
             if (!contextosIguales)
             {
                 ucPaginacion.Inicio = 1;
                 inicio = 1;
             }
         }
         var tipoParametroPL       = new TipoParametroPL();
         TipoParametroInfo filtros = ObtenerFiltros();
         var pagina = new PaginacionInfo {
             Inicio = inicio, Limite = limite
         };
         ResultadoInfo <TipoParametroInfo> resultadoInfo = tipoParametroPL.ObtenerPorPagina(pagina, filtros);
         if (resultadoInfo != null && resultadoInfo.Lista != null &&
             resultadoInfo.Lista.Count > 0)
         {
             gridDatos.ItemsSource       = resultadoInfo.Lista;
             ucPaginacion.TotalRegistros = resultadoInfo.TotalRegistros;
         }
         else
         {
             ucPaginacion.TotalRegistros = 0;
             gridDatos.ItemsSource       = new List <TipoParametro>();
         }
     }
     catch (ExcepcionGenerica)
     {
         SkMessageBox.Show(Application.Current.Windows[ConstantesVista.WindowPrincipal], Properties.Resources.TipoParametro_ErrorBuscar, MessageBoxButton.OK, MessageImage.Error);
     }
     catch (Exception ex)
     {
         Logger.Error(ex);
         SkMessageBox.Show(Application.Current.Windows[ConstantesVista.WindowPrincipal], Properties.Resources.TipoParametro_ErrorBuscar, MessageBoxButton.OK, MessageImage.Error);
     }
 }
Exemple #14
0
        /// <summary>
        /// Metodo que valida los datos para guardar
        /// </summary>
        /// <returns></returns>
        private bool ValidaGuardar()
        {
            bool   resultado = true;
            string mensaje   = string.Empty;

            try
            {
                if (string.IsNullOrWhiteSpace(txtDescripcion.Text) || Contexto.Descripcion == string.Empty)
                {
                    resultado = false;
                    mensaje   = Properties.Resources.TipoParametroEdicion_MsgDescripcionRequerida;
                    txtDescripcion.Focus();
                }
                else
                {
                    int    tipoParametroId = Extensor.ValorEntero(txtTipoParametroID.Text);
                    string descripcion     = txtDescripcion.Text.Trim();

                    var tipoParametroPL             = new TipoParametroPL();
                    TipoParametroInfo tipoParametro = tipoParametroPL.ObtenerPorDescripcion(descripcion);

                    if (tipoParametro != null && (tipoParametroId == 0 || tipoParametroId != tipoParametro.TipoParametroID))
                    {
                        resultado = false;
                        mensaje   = string.Format(Properties.Resources.TipoParametroEdicion_MsgDescripcionExistente, tipoParametro.TipoParametroID);
                    }
                }
            }
            catch (Exception ex)
            {
                throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
            }

            if (!string.IsNullOrWhiteSpace(mensaje))
            {
                SkMessageBox.Show(this, mensaje, MessageBoxButton.OK, MessageImage.Warning);
            }
            return(resultado);
        }
 /// <summary>
 ///  Método que obtiene un registro
 /// </summary>
 /// <param name="ds"></param>
 /// <returns></returns>
 internal static TipoParametroInfo ObtenerPorID(DataSet ds)
 {
     try
     {
         Logger.Info();
         DataTable         dt      = ds.Tables[ConstantesDAL.DtDatos];
         TipoParametroInfo entidad =
             (from info in dt.AsEnumerable()
              select
              new TipoParametroInfo
         {
             TipoParametroID = info.Field <int>("TipoParametroID"),
             Descripcion = info.Field <string>("Descripcion"),
             Activo = info.Field <bool>("Activo").BoolAEnum(),
         }).First();
         return(entidad);
     }
     catch (Exception ex)
     {
         Logger.Error(ex);
         throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
     }
 }
Exemple #16
0
 /// <summary>
 /// Metodo para actualizar un registro de TipoParametro
 /// </summary>
 /// <param name="info">Valores de la entidad que se actualizarán</param>
 internal void Actualizar(TipoParametroInfo info)
 {
     try
     {
         Logger.Info();
         Dictionary <string, object> parameters = AuxTipoParametroDAL.ObtenerParametrosActualizar(info);
         Update("TipoParametro_Actualizar", 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);
     }
 }
Exemple #17
0
 /// <summary>
 /// Constructor para editar una entidad TipoParametro Existente
 /// </summary>
 /// <param name="tipoParametroInfo"></param>
 public TipoParametroEdicion(TipoParametroInfo tipoParametroInfo)
 {
     InitializeComponent();
     tipoParametroInfo.UsuarioModificacionID = AuxConfiguracion.ObtenerUsuarioLogueado();
     Contexto = tipoParametroInfo;
 }
 /// <summary>
 /// Obtiene parametros para obtener lista paginada
 /// </summary>
 /// <param name="pagina"></param>
 /// <param name="filtro"></param>
 /// <returns></returns>
 internal static Dictionary <string, object> ObtenerParametrosPorPagina(PaginacionInfo pagina, TipoParametroInfo filtro)
 {
     try
     {
         Logger.Info();
         var parametros =
             new Dictionary <string, object>
         {
             { "@Descripcion", filtro.Descripcion },
             { "@Activo", filtro.Activo },
             { "@Inicio", pagina.Inicio },
             { "@Limite", pagina.Limite }
         };
         return(parametros);
     }
     catch (Exception ex)
     {
         Logger.Error(ex);
         throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
     }
 }
Exemple #19
0
 /// <summary>
 /// Obtiene un lista paginada
 /// </summary>
 /// <param name="pagina"></param>
 /// <param name="filtro"></param>
 /// <returns></returns>
 internal ResultadoInfo <TipoParametroInfo> ObtenerPorPagina(PaginacionInfo pagina, TipoParametroInfo filtro)
 {
     try
     {
         Logger.Info();
         var tipoParametroDAL = new TipoParametroDAL();
         ResultadoInfo <TipoParametroInfo> result = tipoParametroDAL.ObtenerPorPagina(pagina, filtro);
         return(result);
     }
     catch (ExcepcionGenerica)
     {
         throw;
     }
     catch (Exception ex)
     {
         Logger.Error(ex);
         throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
     }
 }
Exemple #20
0
 /// <summary>
 /// Obtiene un lista paginada de tipos de parametros
 /// </summary>
 /// <param name="pagina"></param>
 /// <param name="filtro"></param>
 /// <returns></returns>
 internal ResultadoInfo <TipoParametroInfo> ObtenerPorPagina(PaginacionInfo pagina, TipoParametroInfo filtro)
 {
     try
     {
         Dictionary <string, object> parameters = AuxTipoParametroDAL.ObtenerParametrosPorPagina(pagina, filtro);
         DataSet ds = Retrieve("TipoParametro_ObtenerPorPagina", parameters);
         ResultadoInfo <TipoParametroInfo> result = null;
         if (ValidateDataSet(ds))
         {
             result = MapTipoParametroDAL.ObtenerPorPagina(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);
     }
 }