Пример #1
0
 /// <summary>
 /// ES: Actualiza un perfil ya guardado.
 /// </summary>
 /// <param name="IdProfile">ES: Identificador del perfil que se desea editar.</param>
 /// <param name="profileData">ES: Nuevos datos del perfil a editar.</param>
 public void UpdateProfile(int IdProfile, Profiles profileData)
 {
     try
     {
         _dataManagerProfiles.UpdateData(IdProfile, profileData);
     }
     catch (Exception ex) { RuntimeLogs.SendLog(ex.Message, typeof(ProfileManager).Name + ".UpdateProfile(int, Profile)"); }
 }
Пример #2
0
 /// <summary>
 /// ES: Elimina permanentemente un perfil.
 /// </summary>
 /// <param name="IdProfile">ES: Identificador del perfil que se desea eliminar.</param>
 public void DeleteProfile(int IdProfile)
 {
     try
     {
         _dataManagerProfiles.DeleteRegister(IdProfile);
     }
     catch (Exception ex) { RuntimeLogs.SendLog(ex.Message, typeof(ProfileManager).Name + ".DeleteProfile(int)"); }
 }
Пример #3
0
 /// <summary>
 /// ES: Constructor de la clase ProfileManager.
 /// </summary>
 public ProfileManager()
 {
     try
     {
         _profiles = _dataManagerProfiles.RecoverData();
     }
     catch (Exception ex) { RuntimeLogs.SendLog(ex.Message, typeof(ProfileManager).Name + ".ProfileManager()"); }
 }
Пример #4
0
 /// <summary>
 /// ES: Guarda un nuevo perfil.
 /// </summary>
 /// <param name="profileData">ES: Datos del nuevo perfil a añadir.</param>
 public void NewProfile(Profiles profileData)
 {
     try {
         _profiles.Add(profileData);
         _dataManagerProfiles.SaveData(profileData);
     }
     catch (Exception ex) { RuntimeLogs.SendLog(ex.Message, typeof(ProfileManager).Name + ".NewProfile(Profile)"); }
 }
Пример #5
0
 /// <summary>
 /// ES: Elimina todos los datos del archivo binario.
 /// PRECAUCIÓN: Una vez eliminados, no es posible recuperarlos.
 /// </summary>
 public void ClearBinary()
 {
     try
     {
         Stream stream = new FileStream(_fileDirection, FileMode.Truncate, FileAccess.Write, FileShare.ReadWrite);
     }
     catch (Exception ex) { RuntimeLogs.SendLog(ex.Message, typeof(DataSerializer <T>).Name + ".ClearBinary()"); }
 }
Пример #6
0
 /// <summary>
 /// ES: Guarda elementos en el archivo binario.
 /// </summary>
 /// <param name="data">ES: Dato a almacenar en el archivo binario.</param>
 public void SaveData(T data)
 {
     try
     {
         _formatter.Serialize(WriteStream(), data);
     }
     catch (Exception ex) { RuntimeLogs.SendLog(ex.Message, typeof(DataSerializer <T>).Name + ".SaveData(T)"); }
 }
Пример #7
0
 /// <summary>
 /// ES: Constructor de la clase DataSerializer.
 /// </summary>
 /// <param name="FileName">ES: Nombre del archivo binario.</param>
 public DataSerializer(string FileName)
 {
     try
     {
         _fileDirection = AppDomain.CurrentDomain.BaseDirectory + FileName;
         _formatter     = new BinaryFormatter();
     }
     catch (Exception ex) { RuntimeLogs.SendLog(ex.Message, typeof(DataSerializer <T>).Name + ".DataSerializer(string)"); }
 }
Пример #8
0
 /// <summary>
 /// ES: Guarda todos los elementos almacenados en una lista en el archivo binario.
 /// </summary>
 /// <param name="data">ES: Lista que contiene los datos.</param>
 public void SaveData(List <T> data)
 {
     try
     {
         for (int i = 0; i < data.Count; ++i)
         {
             SaveData(data[i]);
         }
     }
     catch (Exception ex) { RuntimeLogs.SendLog(ex.Message, typeof(DataSerializer <T>).Name + ".SaveData(List<T>)"); }
 }
Пример #9
0
 /// <summary>
 /// ES: Actualiza un registro del archivo binario.
 /// </summary>
 /// <param name="IdRegister">ES: Identificador del registro que se desea actualizar.</param>
 /// <param name="data">ES: Elemento por el cual debe actualizado</param>
 public void UpdateData(int IdRegister, T data)
 {
     try
     {
         List <T> list = this.RecoverData();
         list[IdRegister] = data;
         ClearBinary();
         SaveData(list);
     }
     catch (Exception ex) { RuntimeLogs.SendLog(ex.Message, typeof(DataSerializer <T>).Name + ".UpdateData(int, T)"); }
 }
Пример #10
0
 /// <summary>
 /// ES: Elimina un registro en el archivo binario.
 /// </summary>
 /// <param name="IdRegister">ES: Identificador del registro que se desea eliminar.</param>
 public void DeleteRegister(int IdRegister)
 {
     try
     {
         List <T> list = this.RecoverData();
         list.Remove(list[IdRegister]);
         this.ClearBinary();
         this.SaveData(list);
     }
     catch (Exception ex) { RuntimeLogs.SendLog(ex.Message, typeof(DataSerializer <T>).Name + ".DeleteRegister(int)"); }
 }
Пример #11
0
 /// <summary>
 /// ES: Recupera un registro que se encuentre en el archivo binario.
 /// </summary>
 /// <param name="IdRegister">ES: Registro a devolver</param>
 /// <returns>ES: Devuelve un registro si es que existe en el binario, caso de que no exista devuelve un valor por defecto.</returns>
 public T RecoverData(int IdRegister)
 {
     try
     {
         Stream stream   = ReadStream();
         int    typeSize = Marshal.SizeOf(typeof(T));
         stream.Seek((IdRegister - 1) * typeSize, SeekOrigin.Begin);
         return((T)_formatter.Deserialize(stream));
     }
     catch (Exception ex) { RuntimeLogs.SendLog(ex.Message, typeof(DataSerializer <T>).Name + ".RecoverData(int)"); }
     return(default(T));
 }
Пример #12
0
        /// <summary>
        /// ES: Recupera todos los datos almacenados en el archivo binario en ese momento en una lista.
        /// </summary>
        /// <returns>ES: Devuelve todos los datos presentes en el binario en una lista.</returns>
        public List <T> RecoverData()
        {
            List <T> list = new List <T>();

            try
            {
                Stream stream = ReadStream();
                while (stream.Position < stream.Length)
                {
                    T result = (T)_formatter.Deserialize(stream);
                    list.Add(result);
                }
            }
            catch (Exception ex) { RuntimeLogs.SendLog(ex.Message, typeof(DataSerializer <T>).Name + ".RecoverAllData()"); }
            return(list);
        }
Пример #13
0
        /// <summary>
        /// ES: Procesa datos recogidos por Arduino SDA.
        /// </summary>
        /// <param name="rawData">ES: String con los datos sin procesar.</param>
        /// <param name="resultTable">ES: SensorDataArray donde se almacenaran los resultados</param>
        /// <param name="clearTable">ES: Indicar 'true' si se quiere limpiar los datos de la tabla</param>
        public void Process(string rawData, ref Containers.SensorData resultTable, List <Containers.Measurement> format)
        {
            // Se verifica que el mensaje sea para SDA.
            if (rawData.StartsWith("SDA: "))
            {
                rawData = rawData.Remove(0, 5);
            }
            else
            {
                return;
            }

            // Se separan los datos
            string[] rawColumnsData = rawData.Split(' ');
            List <Containers.Measurement> receivedData = new List <Containers.Measurement>();

            // Se convierten los datos a double
            for (int i = 0; i < rawColumnsData.Length; ++i)
            {
                try
                {
                    double processedData = Convert.ToDouble(rawColumnsData[i]);
                    Containers.Measurement newMeasure = new Containers.Measurement();

                    newMeasure.Value   = processedData;
                    newMeasure.Measure = format[i].Measure;
                    newMeasure.Name    = format[i].Name;
                    receivedData.Add(newMeasure);
                }
                catch (Exception ex)
                {
                    RuntimeLogs.SendLog(ex.Message, "Processing.Process(string, ref SensorDataArray, bool = false)");
                }
            }
            resultTable.AddRow(receivedData);
        }