Example #1
0
 /// <summary>
 ///  Método que obtiene un registro
 /// </summary>
 /// <param name="ds"></param>
 /// <returns></returns>
 internal static ParametroInfo ObtenerPorID(DataSet ds)
 {
     try
     {
         Logger.Info();
         DataTable     dt      = ds.Tables[ConstantesDAL.DtDatos];
         ParametroInfo entidad =
             (from info in dt.AsEnumerable()
              select
              new ParametroInfo
         {
             ParametroID = info.Field <int>("ParametroID"),
             TipoParametro = new TipoParametroInfo
             {
                 TipoParametroID = info.Field <int>("TipoParametroID"),
                 Descripcion = info.Field <string>("TipoParametro")
             },
             Descripcion = info.Field <string>("Descripcion"),
             Clave = info.Field <string>("Clave"),
             Activo = info.Field <bool>("Activo").BoolAEnum(),
         }).First();
         return(entidad);
     }
     catch (Exception ex)
     {
         Logger.Error(ex);
         throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
     }
 }
 /// <summary>
 /// Constructor para editar una entidad Parametro Existente
 /// </summary>
 /// <param name="parametroInfo"></param>
 public ParametroEdicion(ParametroInfo parametroInfo)
 {
     InitializeComponent();
     CargaTipoParametro();
     parametroInfo.UsuarioModificacionID = AuxConfiguracion.ObtenerUsuarioLogueado();
     Contexto = parametroInfo;
 }
Example #3
0
 /// <summary>
 /// Metodo para Guardar/Modificar una entidad Parametro
 /// </summary>
 /// <param name="info"></param>
 internal int Guardar(ParametroInfo info)
 {
     try
     {
         Logger.Info();
         var parametroDAL = new ParametroDAL();
         int result       = info.ParametroID;
         if (info.ParametroID == 0)
         {
             result = parametroDAL.Crear(info);
         }
         else
         {
             parametroDAL.Actualizar(info);
         }
         return(result);
     }
     catch (ExcepcionGenerica)
     {
         throw;
     }
     catch (Exception ex)
     {
         Logger.Error(ex);
         throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
     }
 }
 /// <summary>
 /// Inicializa el Contexto
 /// </summary>
 private void InicializaContexto()
 {
     Contexto = new ParametroInfo
     {
         TipoParametro     = new TipoParametroInfo(),
         UsuarioCreacionID = AuxConfiguracion.ObtenerUsuarioLogueado(),
     };
 }
Example #5
0
        public void ObtenerParametroPorId()
        {
            var           parametroPL = new ParametroPL();
            ParametroInfo parametro   = parametroPL.ObtenerPorID(1);

            Assert.IsNotNull(parametro);
            Assert.IsNotNull(parametro.TipoParametro);
            Assert.IsTrue(parametro.Descripcion.Length > 0);
            Assert.IsTrue(parametro.TipoParametro.Descripcion.Length > 0);
        }
Example #6
0
 /// <summary>
 /// Inicializa el Contexto
 /// </summary>
 private void InicializaContexto()
 {
     Contexto = new ParametroInfo
     {
         Descripcion       = string.Empty,
         Activo            = EstatusEnum.Activo,
         TipoParametro     = new TipoParametroInfo(),
         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(txtDescripcion.Text) || Contexto.Descripcion == string.Empty)
                {
                    resultado = false;
                    mensaje   = Properties.Resources.ParametroEdicion_MsgDescripcionRequerida;
                    txtDescripcion.Focus();
                }
                else if (cmbTipoParametro.SelectedItem == null || Contexto.TipoParametro.TipoParametroID == 0)
                {
                    resultado = false;
                    mensaje   = Properties.Resources.ParametroEdicion_MsgTipoParametroIDRequerida;
                    cmbTipoParametro.Focus();
                }
                else if (string.IsNullOrWhiteSpace(txtClave.Text) || Contexto.Clave == string.Empty)
                {
                    resultado = false;
                    mensaje   = Properties.Resources.ParametroEdicion_MsgClaveRequerida;
                    txtClave.Focus();
                }
                else
                {
                    int    parametroId = Extensor.ValorEntero(txtParametroID.Text);
                    string descripcion = txtDescripcion.Text.Trim();

                    var           parametroPL = new ParametroPL();
                    ParametroInfo parametro   = parametroPL.ObtenerPorDescripcion(descripcion);

                    if (parametro != null && (parametroId == 0 || parametroId != parametro.ParametroID))
                    {
                        resultado = false;
                        mensaje   = string.Format(Properties.Resources.ParametroEdicion_MsgDescripcionExistente, parametro.ParametroID);
                    }
                }
            }
            catch (Exception ex)
            {
                throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
            }

            if (!string.IsNullOrWhiteSpace(mensaje))
            {
                SkMessageBox.Show(this, mensaje, MessageBoxButton.OK, MessageImage.Warning);
            }
            return(resultado);
        }
    public virtual ParametroInfo GetInfoParametros(string particula)
    {
        reader.Load(Application.StartupPath+"\\"+xmlPath);
        XmlNodeList oldCd;
        oldCd = reader.SelectNodes("/particulas/particula[nombre='" + particula + "']/parametros/*");
        ParametroInfo result = new ParametroInfo(oldCd.Count);
        int i=0;
        foreach (XmlNode nod in oldCd)
        {
            result.ListaDatosDeParametros[i++] = new DatosDeParametroInfo(nod.SelectSingleNode("nombre").InnerXml, nod.SelectSingleNode("tipo").InnerXml);

         }
        return result;
    }
Example #9
0
 public Parametros(RSAConfiguration configuration,ParametroInfo partInfo,object[] valores)
 {
     config=configuration;
     pInfo=partInfo;
     val=valores;
     //
     // Required for Windows Form Designer support
     //
     InitializeComponent();
     InitMycontrols();
     //
     // TODO: Add any constructor code after InitializeComponent call
     //
 }
 /// <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;
         }
     }
 }
Example #11
0
 /// <summary>
 /// Obtiene un lista paginada
 /// </summary>
 /// <param name="pagina"></param>
 /// <param name="filtro"></param>
 /// <returns></returns>
 public ResultadoInfo <ParametroInfo> ObtenerPorPagina(PaginacionInfo pagina, ParametroInfo filtro)
 {
     try
     {
         Logger.Info();
         var parametroBL = new ParametroBL();
         ResultadoInfo <ParametroInfo> result = parametroBL.ObtenerPorPagina(pagina, filtro);
         return(result);
     }
     catch (ExcepcionGenerica)
     {
         throw;
     }
     catch (Exception ex)
     {
         Logger.Error(ex);
         throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
     }
 }
Example #12
0
 /// <summary>
 /// Metodo para Guardar/Modificar una entidad Parametro
 /// </summary>
 /// <param name="info">Representa la entidad que se va a grabar</param>
 public int Guardar(ParametroInfo info)
 {
     try
     {
         Logger.Info();
         var parametroBL = new ParametroBL();
         int result      = parametroBL.Guardar(info);
         return(result);
     }
     catch (ExcepcionGenerica)
     {
         throw;
     }
     catch (Exception ex)
     {
         Logger.Error(ex);
         throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
     }
 }
Example #13
0
 /// <summary>
 /// Obtiene una entidad Parametro por su descripción
 /// </summary>
 /// <param name="descripcion"></param>
 /// <returns></returns>
 internal ParametroInfo ObtenerPorDescripcion(string descripcion)
 {
     try
     {
         Logger.Info();
         var           parametroDAL = new ParametroDAL();
         ParametroInfo result       = parametroDAL.ObtenerPorDescripcion(descripcion);
         return(result);
     }
     catch (ExcepcionGenerica)
     {
         throw;
     }
     catch (Exception ex)
     {
         Logger.Error(ex);
         throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
     }
 }
Example #14
0
 /// <summary>
 /// Obtiene una entidad por su Clave
 /// </summary>
 /// <param name="parametroInfo"></param>
 /// <returns></returns>
 public ParametroInfo ObtenerPorParametroTipoParametro(ParametroInfo parametroInfo)
 {
     try
     {
         Logger.Info();
         var           parametroBL = new ParametroBL();
         ParametroInfo result      = parametroBL.ObtenerPorParametroTipoParametro(parametroInfo);
         return(result);
     }
     catch (ExcepcionGenerica)
     {
         throw;
     }
     catch (Exception ex)
     {
         Logger.Error(ex);
         throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
     }
 }
Example #15
0
 /// <summary>
 /// Obtiene la lista para mostrar en el grid
 /// </summary>
 private void ObtenerListaParametro(int inicio, int limite)
 {
     try
     {
         if (ucPaginacion.ContextoAnterior != null)
         {
             bool contextosIguales = ucPaginacion.CompararObjetos(Contexto, ucPaginacion.ContextoAnterior);
             if (!contextosIguales)
             {
                 ucPaginacion.Inicio = 1;
                 inicio = 1;
             }
         }
         var           parametroPL = new ParametroPL();
         ParametroInfo filtros     = ObtenerFiltros();
         var           pagina      = new PaginacionInfo {
             Inicio = inicio, Limite = limite
         };
         ResultadoInfo <ParametroInfo> resultadoInfo = parametroPL.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 <Parametro>();
         }
     }
     catch (ExcepcionGenerica)
     {
         SkMessageBox.Show(Application.Current.Windows[ConstantesVista.WindowPrincipal], Properties.Resources.Parametro_ErrorBuscar, MessageBoxButton.OK, MessageImage.Error);
     }
     catch (Exception ex)
     {
         Logger.Error(ex);
         SkMessageBox.Show(Application.Current.Windows[ConstantesVista.WindowPrincipal], Properties.Resources.Parametro_ErrorBuscar, MessageBoxButton.OK, MessageImage.Error);
     }
 }
Example #16
0
 /// <summary>
 /// Obtiene parametros para crear
 /// </summary>
 /// <param name="info">Valores de la entidad</param>
 /// <returns></returns>
 internal static Dictionary <string, object> ObtenerParametrosCrear(ParametroInfo info)
 {
     try
     {
         Logger.Info();
         var parametros =
             new Dictionary <string, object>
         {
             { "@Descripcion", info.Descripcion },
             { "@TipoParametroID", info.TipoParametro.TipoParametroID },
             { "@Clave", info.Clave },
             { "@Activo", info.Activo },
             { "@UsuarioCreacionID", info.UsuarioCreacionID },
         };
         return(parametros);
     }
     catch (Exception ex)
     {
         Logger.Error(ex);
         throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
     }
 }
Example #17
0
 /// <summary>
 /// Valida la el parametro y la configuracion del parametro de tipoCorralDestino
 /// </summary>
 /// <returns>Regresa true si el parametro esta registrado y esta configurado como activo para la organizacion del usuario logueado.</returns>
 private bool ValidarParametroCorralDestino()
 {
     try
     {
         Logger.Info();
         bool                    parametroConfigurado    = true;
         ParametroPL             parametroPl             = new ParametroPL();
         ParametroOrganizacionPL parametroOrganizacionPl = new ParametroOrganizacionPL();
         List <ParametroInfo>    parametros             = parametroPl.ObtenerTodos(EstatusEnum.Activo).ToList();
         ParametroInfo           parametroCorralDestino = null;
         if (parametros != null)
         {
             parametroCorralDestino = parametros.Where(parametro => parametro.Clave == ParametrosEnum.CORRALDESTINOORGANIZACION.ToString()).FirstOrDefault();
         }
         if (parametroCorralDestino == null)
         {
             parametroConfigurado = false;
         }
         else
         {
             ParametroOrganizacionInfo parametroValor = parametroOrganizacionPl.ObtenerPorOrganizacionIDClaveParametro(int.Parse(Application.Current.Properties["OrganizacionID"].ToString()), ParametrosEnum.CORRALDESTINOORGANIZACION.ToString());
             if (parametroValor == null || parametroValor.Activo == EstatusEnum.Inactivo)
             {
                 parametroConfigurado = false;
             }
             else
             {
                 parametroConfigurado = true;
             }
         }
         return(parametroConfigurado);
     }
     catch (Exception ex)
     {
         Logger.Error(ex);
         SkMessageBox.Show(Application.Current.Windows[ConstantesVista.WindowPrincipal], ex.Message, MessageBoxButton.OK, MessageImage.Error);
         return(false);
     }
 }
Example #18
0
 /// <summary>
 /// Obtiene parametros para obtener lista paginada
 /// </summary>
 /// <param name="pagina"></param>
 /// <param name="filtro"></param>
 /// <returns></returns>
 internal static Dictionary <string, object> ObtenerParametrosPorPaginaTipoParametro(PaginacionInfo pagina, ParametroInfo filtro)
 {
     try
     {
         Logger.Info();
         var parametros =
             new Dictionary <string, object>
         {
             { "@Descripcion", filtro.Descripcion },
             { "@TipoParametroID", filtro.TipoParametro.TipoParametroID },
             { "@Activo", filtro.Activo },
             { "@Inicio", pagina.Inicio },
             { "@Limite", pagina.Limite }
         };
         return(parametros);
     }
     catch (Exception ex)
     {
         Logger.Error(ex);
         throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
     }
 }
Example #19
0
 /// <summary>
 /// Obtiene Parametro pora filtrar por tipo parametro
 /// </summary>
 /// <param name="parametroInfo">Descripción de la entidad </param>
 /// <returns></returns>
 internal static Dictionary <string, object> ObtenerParametrosPorParametroTipoParametro(ParametroInfo parametroInfo)
 {
     try
     {
         Logger.Info();
         var parametros =
             new Dictionary <string, object>
         {
             { "@ParametroID", parametroInfo.ParametroID },
             { "@TipoParametroID", parametroInfo.TipoParametro.TipoParametroID },
             { "@Activo", parametroInfo.Activo }
         };
         return(parametros);
     }
     catch (Exception ex)
     {
         Logger.Error(ex);
         throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
     }
 }
        /// <summary>
        /// Carga el comboBox de los corrales segun la organizacion del usuario que se logueo
        /// </summary>
        void CargarCorralesComboBox()
        {
            //cbCorrales.Items.Clear();
            InicializaContexto();
            //Contexto = new SalidaPorMuerteEnTransitoInfo {OrganizacionID = Contexto.OrganizacionID};
            corrales = CorralBL.ObtenerCorralesPorOrganizacionID(Contexto.OrganizacionID);

            //cargar combobox de corrales
            if (corrales.Count == 0) //en caso de no encontrarse ningun corral
            {
                //verificar si el parametroID de la tabla de organizacion del usuario logueado este registrado en la tabla parametros
                //SP: Parametro_ObtenerPorDescripcion con la descripcion; 'Corral para faltantes de compra directa' / 'Corral para faltantes de origen propio'

                //verificar que exista la configuracion del parametro corral  de faltantes para la organizacion
                //:SP ParametroOrganizacion_ObtenerPorParametroOrganizacionID ; con OrganizacionID del usuario logueado, ParametroID que corresponda al parametro de la primera validacion

                //verificar que el corral tenga un lote activo (en caso de no hallar corrales)
                //LoteBL.ObtenerActivosPorCorral(AuxConfiguracion.ObtenerOrganizacionUsuarioID, int corralID);

                var           parametroPl = new ParametroPL();
                ParametroInfo parametroFaltantesCompraDirecta = parametroPl.ObtenerPorDescripcion(
                    Properties.Resources.SalidaGanadoTransito_Parametro_Faltantes_Compra_Directa);

                ParametroInfo parametroFaltantesOrigenPropio = parametroPl.ObtenerPorDescripcion(
                    Properties.Resources.SalidaGanadoTransito_Parametro_Faltantes_Origen_Propio);

                if ((parametroFaltantesCompraDirecta != null &&
                     parametroFaltantesCompraDirecta.Activo == EstatusEnum.Activo) ||
                    (parametroFaltantesOrigenPropio != null &&
                     parametroFaltantesOrigenPropio.Activo == EstatusEnum.Activo))
                {
                    var parametroOrganizacionPl = new ParametroOrganizacionPL();
                    var parOrganizacionFaltantesCompraDirecta =
                        new ParametroOrganizacionInfo
                    {
                        Organizacion = new OrganizacionInfo(),
                        Parametro    = new ParametroInfo()
                    };
                    parOrganizacionFaltantesCompraDirecta.Organizacion.OrganizacionID = Contexto.OrganizacionID;
                    if (parametroFaltantesCompraDirecta != null)
                    {
                        parOrganizacionFaltantesCompraDirecta.Parametro.ParametroID =
                            parametroFaltantesCompraDirecta.ParametroID;
                    }
                    parOrganizacionFaltantesCompraDirecta =
                        parametroOrganizacionPl.ObtenerPorParametroOrganizacionID(
                            parOrganizacionFaltantesCompraDirecta);

                    var parOrganizacionFaltantesOrigenPropio =
                        new ParametroOrganizacionInfo
                    {
                        Organizacion = new OrganizacionInfo(),
                        Parametro    = new ParametroInfo()
                    };
                    parOrganizacionFaltantesOrigenPropio.Organizacion.OrganizacionID = Contexto.OrganizacionID;
                    parOrganizacionFaltantesOrigenPropio.Parametro.ParametroID       =
                        parametroFaltantesOrigenPropio.ParametroID;
                    parOrganizacionFaltantesOrigenPropio =
                        parametroOrganizacionPl.ObtenerPorParametroOrganizacionID(
                            parOrganizacionFaltantesOrigenPropio);

                    if (parOrganizacionFaltantesCompraDirecta == null || parOrganizacionFaltantesOrigenPropio == null)
                    {
                        SkMessageBox.Show(Application.Current.Windows[ConstantesVista.WindowPrincipal],
                                          Properties.Resources.SalidaGanadoTransito_MsgConfiguracionCorralNoExiste,
                                          MessageBoxButton.OK, MessageImage.Warning);
                        BloquearPantalla();
                    }
                    else
                    {
                        if (!parOrganizacionFaltantesCompraDirecta.Activo.ValorBooleanoDesdeEnum() && !parOrganizacionFaltantesOrigenPropio.Activo.ValorBooleanoDesdeEnum())
                        {
                            SkMessageBox.Show(Application.Current.Windows[ConstantesVista.WindowPrincipal],
                                              Properties.Resources.SalidaGanadoTransito_MsgConfiguracionCorralNoExiste,
                                              MessageBoxButton.OK, MessageImage.Warning);
                            BloquearPantalla();
                        }
                        else
                        {
                            SkMessageBox.Show(Application.Current.Windows[ConstantesVista.WindowPrincipal],
                                              Properties.Resources.SalidaGanadoTransito_MsgCorralActivoNoEncontrado,
                                              MessageBoxButton.OK, MessageImage.Warning);
                            BloquearPantalla();
                        }
                    }
                }
                else
                {
                    SkMessageBox.Show(Application.Current.Windows[ConstantesVista.WindowPrincipal],
                                      Properties.Resources.SalidaGanadoTransito_MsgParametroCorralNoExiste, MessageBoxButton.OK,
                                      MessageImage.Warning);
                    BloquearPantalla();
                    cbCorrales.IsEnabled = true;
                }
            }
            var seleccione = new CorralesPorOrganizacionInfo
            {
                CorralID    = 0,
                Descripcion = "Seleccione"
            };

            corrales.Insert(0, seleccione);
            cbCorrales.ItemsSource   = new List <CorralesPorOrganizacionInfo>();
            cbCorrales.ItemsSource   = corrales;
            cbCorrales.SelectedValue = 0;
        }