Esempio n. 1
0
        //Guarda los valores de Datos Generales en el archivo de configuración (Devuelve String.Empty en caso de éxito)
        public static string guardarArchivoConfiguracion()
        {
            int cantidadDatosFijos     = 2;
            int cantidadDatosVariables = listaAcciones.Count;

            string[] lineas = new string[cantidadDatosFijos + cantidadDatosVariables];
            int      indice = 0;

            //Guardar frecuencia
            lineas[indice++] = datosGenerales.frecuencia.ToString();

            //Guardar cantidad de registro de acciones
            lineas[indice++] = cantidadDatosVariables.ToString();

            //Guardar acciones
            foreach (RegistroAccion elemento in listaAcciones)
            {
                lineas[indice++] = elemento.ToString(); //Se guarda un registro en una sola linea donde se separan los campos mediante tab '\t'
            }

            //Guardar archivo
            try
            {
                System.IO.File.WriteAllLines(rutaArchivoConfig, lineas);
            }
            catch (Exception ex)
            {
                ControlLog.EscribirLog(ControlLog.TipoGravedad.ERROR, "Core.cs", "guardarArchivoConfiguracion", "Se produjo un error en el guardado del archivo de configuración, error: " + ex.Message);
                return(ex.Message);
            }

            //Ok
            return(String.Empty);
        }
Esempio n. 2
0
        //Carga los nombres de dispositivos según la dirección MAC
        public static String cargarNombresDispositivos()
        {
            string[] lineas = new string[0];

            //Cargar archivo
            try
            {
                if (!(File.Exists(datosGenerales.rutaArchivoDispositivos)))
                {
                    //Primera ejecución, no se encontró el archivo
                    return("Archivo no encontrado: " + datosGenerales.rutaArchivoDispositivos);
                }

                lineas = System.IO.File.ReadAllLines(datosGenerales.rutaArchivoDispositivos);
            }
            catch (Exception ex)
            {
                ControlLog.EscribirLog(ControlLog.TipoGravedad.WARNING, "Core.cs", "cargarNombresDispositivos", "Se produjo un error en la lectura del archivo de dispositivos, error: " + ex.Message);
                //Error de lectura
                return("Se produjo el error al intentar cargar el archivo: " + ex.Message);
            }

            //Recorrer los registros
            foreach (string registro in lineas)
            {
                string   registroAct = registro.Trim();
                string[] registroArr;

                //Registro no vacio
                if (registroAct != string.Empty)
                {
                    registroArr = registroAct.Split('\t');

                    //Valores no vacios
                    if (registroArr.Length > 1 && registroArr[0].Trim() != string.Empty && registroArr[0].Trim() != string.Empty)
                    {
                        IPDispositivo nuevo = new IPDispositivo(registroArr[0].Trim(), registroArr[1].Trim());

                        //Añadir a la lista
                        descripcionDispositivos.Add(nuevo);

                        //Añadir al diccionario
                        descripcionDispositivosDiccionario.Add(registroArr[0].Trim(), registroArr[1].Trim());
                    }
                }
            }

            //Ok
            return(string.Empty);
        }
Esempio n. 3
0
        private void Form1_Load(object sender, EventArgs e)
        {
            String msjLog;

            //Cargar desde archivo la configuración
            string resultado = Core.cargarConfiguracion();

            //Inicializar Log
            if (!ControlLog.Inicializar(Core.datosGenerales.rutaArchivoLog, out msjLog))
            {
                MessageBox.Show("No se pudo inicializar el control de Log: " + msjLog);
            }

            //Inicializar memoria compartida
            _memoriaCompartida = new MemoriaCompartida(Core.datosGenerales.nombreMemoriaCompartida, Core.datosGenerales.nombreMutexCompartido, Core.datosGenerales.capacidadMemoriaCompartida);
            if (!_memoriaCompartida.IniciarConexion(ref msjLog))
            {
                //Error
                ControlLog.EscribirLog(ControlLog.TipoGravedad.WARNING, "Form1.cs", "Form1_Load", "Error al inicializar la memoria compartida: " + msjLog);
                MessageBox.Show("Error al inicializar la memoria compartida: " + msjLog);
            }

            //Instanciar Hilo, que contiene los métodos que ejecuta el Reloj
            _hilo = new Hilo(_memoriaCompartida, lsConectados, lbCant, lbFechaMemoria, lbMsjError);

            //Validar si hay errores
            if (resultado != String.Empty)
            {
                if (MessageBox.Show(resultado + Environment.NewLine + "¿Desear abrir la aplicación desde cero (Si se guarda se borrará el archivo existente)?", "Alerta", MessageBoxButtons.YesNo) == DialogResult.No)
                {
                    //Terminar programa si el usuario indica que no
                    this.Close();
                }
            }

            //Cargar desde archivo la lista de dispositivos
            resultado = Core.cargarNombresDispositivos();

            //Validar si hay errores
            if (resultado != String.Empty)
            {
                MessageBox.Show("Lista de Dispositivos:" + Environment.NewLine + resultado);
            }

            //Cargar datos en los controles
            cargarControles();
        }
Esempio n. 4
0
        //Verifica cambios de estado y ejecuta las acciones si corresponde, actualiza el estado actual en caso de cambio
        public static bool verificarCambioEstado(string mac, bool estadoActual)
        {
            bool huboCambios = false;

            //Obtener estado anterior
            bool   estadoAnterior = estadoActualConectado(mac);
            string parametros;

            //Verificar si cambió el estado
            if (estadoActual != estadoAnterior)
            {
                huboCambios = true;

                if (!accionesPausadas)
                {
                    //Buscar registro de acciones para este dispositivo
                    List <RegistroAccion> acciones = obtenerAccionesAsociadas(mac, estadoActual);

                    //Por cada registro de acciones ejecutar el exe
                    foreach (RegistroAccion accionActual in acciones)
                    {
                        //Generar parámetros
                        parametros = generarParametroAccion(accionActual, estadoActual);

                        //Ejecutar
                        try
                        {
                            Process.Start(accionActual.rutaExe, parametros);
                        }
                        catch (Exception ex)
                        {
                            ControlLog.EscribirLog(ControlLog.TipoGravedad.WARNING, "Core.cs", "verificarCambioEstado", "Error al inicializar el proceso de la acción programada '" + accionActual.rutaExe + "' con parámetros '" + parametros + "' , error: " + ex.Message);
                        }
                    }
                }

                //Actualizar estado actual
                actualizarEstadoDispositivo(mac, estadoActual);
            }

            return(huboCambios);
        }
Esempio n. 5
0
        public static bool accionesPausadas = false;    //Si es verdadero no se ejecutan las acciones programadas

        #region Metodos Públicos

        //Carga la configuración guardada del archivo (Se devuelve String.Empty indica que se cargó sin errores)
        public static String cargarConfiguracion()
        {
            string[] lineas = new string[0];
            string   cadenaAux;
            bool     resultAux;
            int      cantidadDatosFijos = 2; //Cantidad de registros que debe tener el archivo minimamente
            int      cantidadAcciones;

            datosGenerales = new DatosGenerales();
            int indice = 0;

            //Cargar archivo
            try
            {
                if (!(File.Exists(rutaArchivoConfig)))
                {
                    //Primera ejecución, no se encontró el archivo
                    return(String.Empty);
                }

                lineas = System.IO.File.ReadAllLines(rutaArchivoConfig);
            }
            catch (Exception ex)
            {
                ControlLog.EscribirLog(ControlLog.TipoGravedad.ERROR, "Core.cs", "cargarConfiguracion", "No se pudo leer el archivo de configuración: " + ex.Message);
                //Error de lectura
                return("Se produjo el error al intentar cargar el archivo: " + ex.Message);
            }

            //Si no hay registros informar
            if (lineas.Length == 0)
            {
                return("Se produjo el error al intentar cargar el archivo: No hay ningún dato");
            }

            //Verificar la cantidad de registros
            if (lineas.Length < cantidadDatosFijos)
            {
                return("Se produjo el error al intentar cargar el archivo: Cantidad de registros insuficientes (" + lineas.Length.ToString() + " lineas)");
            }

            //Cargar frecuencia
            cadenaAux = lineas[indice];
            resultAux = Int32.TryParse(cadenaAux, out datosGenerales.frecuencia);
            if (!resultAux)
            {
                return("Se produjo el error al intentar cargar la frecuencia: Valor no numérico (" + cadenaAux + ")");
            }
            indice++;

            //Cargar cantidad de acciones
            cadenaAux = lineas[indice];
            resultAux = Int32.TryParse(cadenaAux, out cantidadAcciones);
            if (!resultAux)
            {
                return("Se produjo el error al intentar cargar la cantidad de acciones: Valor no numérico (" + cadenaAux + ")");
            }
            indice++;

            //Cargar acciones
            try
            {
                for (int i = 0; i < cantidadAcciones; i++)
                {
                    RegistroAccion nuevo = new RegistroAccion(lineas[indice++]);
                    listaAcciones.Add(nuevo);
                }
            }
            catch (Exception ex)
            {
                ControlLog.EscribirLog(ControlLog.TipoGravedad.ERROR, "Core.cs", "cargarConfiguracion", "Se produjo un error en la lectura del archivo de configuración, en el momento de lectura de las acciones programadas, error: " + ex.Message);
                return("Se produjo un error al cargar las acciones: " + ex.Message);
            }

            //Ok
            return(string.Empty);
        }