/// <summary>
 /// Inicializa el Contexto
 /// </summary>
 private void InicializaContexto()
 {
     Contexto = new ConceptoDeteccionInfo
     {
         UsuarioCreacionID = AuxConfiguracion.ObtenerUsuarioLogueado(),
     };
 }
示例#2
0
        public void ConceptoDeteccionObtenerPorIdSinDatos()
        {
            var pl = new ConceptoDeteccionPL();
            ConceptoDeteccionInfo conceptoDeteccion = pl.ObtenerPorID(0);

            Assert.AreEqual(conceptoDeteccion, null);
        }
示例#3
0
 /// <summary>
 /// Metodo para Guardar/Modificar una entidad ConceptoDeteccion
 /// </summary>
 /// <param name="info"></param>
 internal int Guardar(ConceptoDeteccionInfo info)
 {
     try
     {
         Logger.Info();
         var conceptoDeteccionDAL = new ConceptoDeteccionDAL();
         int result = info.ConceptoDeteccionID;
         if (info.ConceptoDeteccionID == 0)
         {
             result = conceptoDeteccionDAL.Crear(info);
         }
         else
         {
             conceptoDeteccionDAL.Actualizar(info);
         }
         return(result);
     }
     catch (ExcepcionGenerica)
     {
         throw;
     }
     catch (Exception ex)
     {
         Logger.Error(ex);
         throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
     }
 }
 /// <summary>
 /// Metodo para Crear un registro de ConceptoDeteccion
 /// </summary>
 /// <param name="info">Valores de la entidad que será creada</param>
 internal int Crear(ConceptoDeteccionInfo info)
 {
     try
     {
         Logger.Info();
         Dictionary <string, object> parameters = AuxConceptoDeteccionDAL.ObtenerParametrosCrear(info);
         int result = Create("ConceptoDeteccion_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);
     }
 }
示例#5
0
        public void ConceptoDeteccionObtenerPorId()
        {
            var pl = new ConceptoDeteccionPL();
            ConceptoDeteccionInfo conceptoDeteccion = pl.ObtenerPorID(1);

            Assert.AreNotEqual(conceptoDeteccion, null);
        }
 /// <summary>
 /// Obtiene un registro de ConceptoDeteccion
 /// </summary>
 /// <param name="descripcion">Descripción de la ConceptoDeteccion</param>
 /// <returns></returns>
 internal ConceptoDeteccionInfo ObtenerPorDescripcion(string descripcion)
 {
     try
     {
         Logger.Info();
         Dictionary <string, object> parameters = AuxConceptoDeteccionDAL.ObtenerParametrosPorDescripcion(descripcion);
         DataSet ds = Retrieve("ConceptoDeteccion_ObtenerPorDescripcion", parameters);
         ConceptoDeteccionInfo result = null;
         if (ValidateDataSet(ds))
         {
             result = MapConceptoDeteccionDAL.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);
     }
 }
 /// <summary>
 /// Inicializa el Contexto
 /// </summary>
 private void InicializaContexto()
 {
     Contexto = new ConceptoDeteccionInfo
     {
         Descripcion       = string.Empty,
         UsuarioCreacionID = AuxConfiguracion.ObtenerUsuarioLogueado(),
     };
 }
        /// <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(txtConceptoDeteccionID.Text))
                {
                    resultado = false;
                    mensaje   = Properties.Resources.ConceptoDeteccionEdicion_MsgConceptoDeteccionIDRequerida;
                    txtConceptoDeteccionID.Focus();
                }
                else if (string.IsNullOrWhiteSpace(txtDescripcion.Text) || Contexto.Descripcion == string.Empty)
                {
                    resultado = false;
                    mensaje   = Properties.Resources.ConceptoDeteccionEdicion_MsgDescripcionRequerida;
                    txtDescripcion.Focus();
                }
                else if (cmbActivo.SelectedItem == null)
                {
                    resultado = false;
                    mensaje   = Properties.Resources.ConceptoDeteccionEdicion_MsgActivoRequerida;
                    cmbActivo.Focus();
                }
                else
                {
                    int    conceptoDeteccionId = Extensor.ValorEntero(txtConceptoDeteccionID.Text);
                    string descripcion         = txtDescripcion.Text;

                    var conceptoDeteccionPL = new ConceptoDeteccionPL();
                    ConceptoDeteccionInfo conceptoDeteccion = conceptoDeteccionPL.ObtenerPorDescripcion(descripcion);

                    if (conceptoDeteccion != null && (conceptoDeteccionId == 0 || conceptoDeteccionId != conceptoDeteccion.ConceptoDeteccionID))
                    {
                        resultado = false;
                        mensaje   = string.Format(Properties.Resources.ConceptoDeteccionEdicion_MsgDescripcionExistente, conceptoDeteccion.ConceptoDeteccionID);
                    }
                }
            }
            catch (Exception ex)
            {
                throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
            }

            if (!string.IsNullOrWhiteSpace(mensaje))
            {
                SkMessageBox.Show(this, mensaje, MessageBoxButton.OK, MessageImage.Warning);
            }
            return(resultado);
        }
示例#9
0
        public void ConceptoDeteccionObtenerPorPaginaSinDatos()
        {
            var pl     = new ConceptoDeteccionPL();
            var pagina = new PaginacionInfo {
                Inicio = 1, Limite = 15
            };
            var filtro = new ConceptoDeteccionInfo {
                Descripcion = "1331312313khgdjkfghjkd"
            };

            ResultadoInfo <ConceptoDeteccionInfo> listaPaginada = pl.ObtenerPorPagina(pagina, filtro);

            Assert.AreEqual(listaPaginada, null);
        }
示例#10
0
        public void ConceptoDeteccionObtenerPorPagina()
        {
            var pl     = new ConceptoDeteccionPL();
            var pagina = new PaginacionInfo {
                Inicio = 1, Limite = 15
            };
            var filtro = new ConceptoDeteccionInfo {
                Descripcion = string.Empty
            };

            ResultadoInfo <ConceptoDeteccionInfo> listaPaginada = pl.ObtenerPorPagina(pagina, filtro);

            Assert.AreNotEqual(listaPaginada, null);
        }
 /// <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;
         }
     }
 }
示例#12
0
        public void ConceptoDeteccionCrear()
        {
            var random       = new Random();
            int randomNumber = random.Next(0, 100);

            var pl = new ConceptoDeteccionPL();
            var conceptoDeteccion = new ConceptoDeteccionInfo
            {
                ConceptoDeteccionID = 0,
                Descripcion         = string.Format("Prueba Unitaria Crear {0}", randomNumber),
                UsuarioCreacionID   = 1,
                Activo = EstatusEnum.Activo
            };

            conceptoDeteccion.ConceptoDeteccionID = pl.Guardar(conceptoDeteccion);
            Assert.AreNotEqual(conceptoDeteccion.ConceptoDeteccionID, 0);
        }
示例#13
0
        public void ConceptoDeteccionGuardarDescripcionExistente()
        {
            var pl = new ConceptoDeteccionPL();
            var conceptoDeteccion = new ConceptoDeteccionInfo
            {
                ConceptoDeteccionID = 0,
                Descripcion         = "ConceptoDeteccion",
                Activo = EstatusEnum.Activo
            };

            try
            {
                pl.Guardar(conceptoDeteccion);
            }
            catch (Exception)
            {
                Assert.AreEqual(conceptoDeteccion.ConceptoDeteccionID, 0);
            }
        }
        /// <summary>
        /// Obtiene la lista para mostrar en el grid
        /// </summary>
        private void ObtenerListaConceptoDeteccion(int inicio, int limite)
        {
            try
            {
                if (ucPaginacion.ContextoAnterior != null)
                {
                    bool contextosIguales = ucPaginacion.CompararObjetos(Contexto, ucPaginacion.ContextoAnterior);
                    if (!contextosIguales)
                    {
                        ucPaginacion.Inicio = 1;
                        inicio = 1;
                    }
                }

                var conceptoDeteccionPL       = new ConceptoDeteccionPL();
                ConceptoDeteccionInfo filtros = ObtenerFiltros();
                var pagina = new PaginacionInfo {
                    Inicio = inicio, Limite = limite
                };
                ResultadoInfo <ConceptoDeteccionInfo> resultadoInfo = conceptoDeteccionPL.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;
                    ucPaginacion.AsignarValoresIniciales();
                    gridDatos.ItemsSource = new List <ConceptoDeteccion>();
                }
            }
            catch (ExcepcionGenerica)
            {
                SkMessageBox.Show(Application.Current.Windows[ConstantesVista.WindowPrincipal], Properties.Resources.ConceptoDeteccion_ErrorBuscar, MessageBoxButton.OK, MessageImage.Error);
            }
            catch (Exception ex)
            {
                Logger.Error(ex);
                SkMessageBox.Show(Application.Current.Windows[ConstantesVista.WindowPrincipal], Properties.Resources.ConceptoDeteccion_ErrorBuscar, MessageBoxButton.OK, MessageImage.Error);
            }
        }
示例#15
0
 /// <summary>
 /// Obtiene una entidad ConceptoDeteccion por su Id
 /// </summary>
 /// <param name="conceptoDeteccionID">Obtiene una entidad ConceptoDeteccion por su Id</param>
 /// <returns></returns>
 internal ConceptoDeteccionInfo ObtenerPorID(int conceptoDeteccionID)
 {
     try
     {
         Logger.Info();
         var conceptoDeteccionDAL     = new ConceptoDeteccionDAL();
         ConceptoDeteccionInfo result = conceptoDeteccionDAL.ObtenerPorID(conceptoDeteccionID);
         return(result);
     }
     catch (ExcepcionGenerica)
     {
         throw;
     }
     catch (Exception ex)
     {
         Logger.Error(ex);
         throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
     }
 }
示例#16
0
 /// <summary>
 /// Obtiene una entidad por su descripción
 /// </summary>
 /// <param name="descripcion"></param>
 /// <returns></returns>
 public ConceptoDeteccionInfo ObtenerPorDescripcion(string descripcion)
 {
     try
     {
         Logger.Info();
         var conceptoDeteccionBL      = new ConceptoDeteccionBL();
         ConceptoDeteccionInfo result = conceptoDeteccionBL.ObtenerPorDescripcion(descripcion);
         return(result);
     }
     catch (ExcepcionGenerica)
     {
         throw;
     }
     catch (Exception ex)
     {
         Logger.Error(ex);
         throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
     }
 }
示例#17
0
 /// <summary>
 /// Metodo para Guardar/Modificar una entidad ConceptoDeteccion
 /// </summary>
 /// <param name="info">Representa la entidad que se va a grabar</param>
 public int Guardar(ConceptoDeteccionInfo info)
 {
     try
     {
         Logger.Info();
         var conceptoDeteccionBL = new ConceptoDeteccionBL();
         int result = conceptoDeteccionBL.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(ConceptoDeteccionInfo 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);
     }
 }
示例#19
0
 /// <summary>
 ///  Método que obtiene un registro
 /// </summary>
 /// <param name="ds"></param>
 /// <returns></returns>
 internal static ConceptoDeteccionInfo ObtenerPorID(DataSet ds)
 {
     try
     {
         Logger.Info();
         DataTable             dt      = ds.Tables[ConstantesDAL.DtDatos];
         ConceptoDeteccionInfo entidad =
             (from info in dt.AsEnumerable()
              select
              new ConceptoDeteccionInfo
         {
             ConceptoDeteccionID = info.Field <int>("ConceptoDeteccionID"),
             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);
     }
 }
示例#20
0
 /// <summary>
 /// Metodo para actualizar un registro de ConceptoDeteccion
 /// </summary>
 /// <param name="info">Valores de la entidad que se actualizarán</param>
 internal void Actualizar(ConceptoDeteccionInfo info)
 {
     try
     {
         Logger.Info();
         Dictionary <string, object> parameters = AuxConceptoDeteccionDAL.ObtenerParametrosActualizar(info);
         Update("ConceptoDeteccion_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);
     }
 }
示例#21
0
        public void ConceptoDeteccionActualizar()
        {
            var random       = new Random();
            int randomNumber = random.Next(0, 100);
            var pl           = new ConceptoDeteccionPL();
            ConceptoDeteccionInfo conceptoDeteccion = pl.ObtenerPorID(1);

            if (conceptoDeteccion != null)
            {
                string descripcion;
                try
                {
                    descripcion = string.Format("Prueba Unitaria Actualizar {0}", randomNumber);
                    conceptoDeteccion.Descripcion           = descripcion;
                    conceptoDeteccion.UsuarioModificacionID = 4;
                    pl.Guardar(conceptoDeteccion);
                }
                catch (Exception)
                {
                    descripcion = string.Empty;
                }
                Assert.AreEqual(conceptoDeteccion.Descripcion, descripcion);
            }
        }
 /// <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, ConceptoDeteccionInfo filtro)
 {
     try
     {
         Logger.Info();
         var parametros =
             new Dictionary <string, object>
         {
             { "@ConceptoDeteccionID", filtro.ConceptoDeteccionID },
             { "@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);
     }
 }
示例#23
0
 /// <summary>
 /// Obtiene un lista paginada
 /// </summary>
 /// <param name="pagina"></param>
 /// <param name="filtro"></param>
 /// <returns></returns>
 internal ResultadoInfo <ConceptoDeteccionInfo> ObtenerPorPagina(PaginacionInfo pagina, ConceptoDeteccionInfo filtro)
 {
     try
     {
         Dictionary <string, object> parameters = AuxConceptoDeteccionDAL.ObtenerParametrosPorPagina(pagina, filtro);
         DataSet ds = Retrieve("ConceptoDeteccion_ObtenerPorPagina", parameters);
         ResultadoInfo <ConceptoDeteccionInfo> result = null;
         if (ValidateDataSet(ds))
         {
             result = MapConceptoDeteccionDAL.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);
     }
 }
 /// <summary>
 /// Constructor para editar una entidad ConceptoDeteccion Existente
 /// </summary>
 /// <param name="conceptoDeteccionInfo"></param>
 public ConceptoDeteccionEdicion(ConceptoDeteccionInfo conceptoDeteccionInfo)
 {
     InitializeComponent();
     conceptoDeteccionInfo.UsuarioModificacionID = AuxConfiguracion.ObtenerUsuarioLogueado();
     Contexto = conceptoDeteccionInfo;
 }
示例#25
0
 /// <summary>
 /// Obtiene un lista paginada
 /// </summary>
 /// <param name="pagina"></param>
 /// <param name="filtro"></param>
 /// <returns></returns>
 public ResultadoInfo <ConceptoDeteccionInfo> ObtenerPorPagina(PaginacionInfo pagina, ConceptoDeteccionInfo filtro)
 {
     try
     {
         Logger.Info();
         var conceptoDeteccionBL = new ConceptoDeteccionBL();
         ResultadoInfo <ConceptoDeteccionInfo> result = conceptoDeteccionBL.ObtenerPorPagina(pagina, filtro);
         return(result);
     }
     catch (ExcepcionGenerica)
     {
         throw;
     }
     catch (Exception ex)
     {
         Logger.Error(ex);
         throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
     }
 }