Refactor helper classes

- Move the majority of the logic from the Design project to the main project
- Call the helper classes directly from the main project, instead of redirecting from the Design to the main project

Author: bparks13

OpenEphys.Onix1.Design/ChannelConfigurationDialog.cs

@@ -313,7 +313,7 @@ internal T OpenAndParseConfigurationFile<T>() where T : ProbeGroup
 
             if (ofd.ShowDialog() == DialogResult.OK && File.Exists(ofd.FileName))
             {
-                var newConfiguration = DesignHelper.DeserializeString<T>(File.ReadAllText(ofd.FileName));
+                var newConfiguration = JsonHelper.DeserializeString<T>(File.ReadAllText(ofd.FileName));
 
                 return newConfiguration;
             }
@@ -927,7 +927,7 @@ private void MenuItemSaveFile(object sender, EventArgs e)
 
             if (sfd.ShowDialog() == DialogResult.OK)
             {
-                DesignHelper.SerializeObject(ProbeGroup, sfd.FileName);
+                JsonHelper.SerializeObject(ProbeGroup, sfd.FileName);
             }
         }
 

OpenEphys.Onix1.Design/DesignHelper.cs

@@ -10,57 +10,6 @@ namespace OpenEphys.Onix1.Design
 {
     static class DesignHelper
     {
-        /// <summary>
-        /// Given a string with a valid JSON structure, deserialize the string to the given type.
-        /// </summary>
-        /// <typeparam name="T"></typeparam>
-        /// <param name="jsonString"></param>
-        /// <returns></returns>
-        #nullable enable
-        public static T? DeserializeString<T>(string jsonString)
-        {
-            var errors = new List<string>();
-
-            var serializerSettings = new JsonSerializerSettings()
-            {
-                Error = delegate(object sender, Newtonsoft.Json.Serialization.ErrorEventArgs args)
-                {
-                    errors.Add(args.ErrorContext.Error.Message);
-                    args.ErrorContext.Handled = true;
-                }
-            };
-
-            var obj = JsonConvert.DeserializeObject<T>(jsonString, serializerSettings);
-
-            if (errors.Count > 0)
-            {
-                MessageBox.Show($"There were errors encountered while parsing a JSON string. Check the console " +
-                    $"for an error log.", "JSON Parse Error");
-
-                foreach (var e in errors)
-                {
-                    Console.Error.WriteLine(e);
-                }
-
-                return default;
-            }
-
-            return obj;
-        }
-        #nullable disable
-
-        public static void SerializeObject(object _object, string filepath)
-        {
-            var serializerSettings = new JsonSerializerSettings()
-            {
-                NullValueHandling = NullValueHandling.Ignore,
-            };
-
-            var stringJson = JsonConvert.SerializeObject(_object, Formatting.Indented, serializerSettings);
-
-            File.WriteAllText(filepath, stringJson);
-        }
-
         public static IEnumerable<Control> GetAllControls(this Control root)
         {
             var stack = new Stack<Control>();

OpenEphys.Onix1.Design/Rhs2116StimulusSequenceDialog.cs

@@ -875,7 +875,7 @@ int GetNumberOfSteps(double amplitude, Rhs2116StepSize stepSize)
 
         internal override void SerializeStimulusSequence(string fileName)
         {
-            DesignHelper.SerializeObject(Sequence, fileName);
+            JsonHelper.SerializeObject(Sequence, fileName);
         }
 
         internal override bool IsSequenceValid()
@@ -885,7 +885,7 @@ internal override bool IsSequenceValid()
 
         internal override void DeserializeStimulusSequence(string fileName)
         {
-            var newSequence = DesignHelper.DeserializeString<Rhs2116StimulusSequencePair>(File.ReadAllText(fileName));
+            var newSequence = JsonHelper.DeserializeString<Rhs2116StimulusSequencePair>(File.ReadAllText(fileName));
 
             if (newSequence != null && newSequence.Stimuli.Length == 32)
             {

OpenEphys.Onix1/JsonHelper.cs

@@ -0,0 +1,87 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using Newtonsoft.Json;
+
+namespace OpenEphys.Onix1
+{
+    internal static class JsonHelper
+    {
+        public static T DeserializeString<T>(string jsonString) where T : class
+        {
+            var errors = new List<string>();
+
+            var serializerSettings = new JsonSerializerSettings()
+            {
+                Error = delegate (object sender, Newtonsoft.Json.Serialization.ErrorEventArgs args)
+                {
+                    errors.Add(args.ErrorContext.Error.Message);
+                    args.ErrorContext.Handled = true;
+                }
+            };
+
+            try
+            {
+                var obj = JsonConvert.DeserializeObject<T>(jsonString, serializerSettings);
+
+                if (errors.Count > 0)
+                {
+                    Console.WriteLine("There were errors encountered while parsing a JSON string.\n");
+                    foreach (var e in errors)
+                    {
+                        Console.Error.WriteLine(e);
+                    }
+                    return null;
+                }
+
+                return obj;
+            }
+            catch (JsonReaderException e)
+            {
+                throw new InvalidDataException("Invalid JSON format", e);
+            }
+            catch (JsonSerializationException e)
+            {
+                throw new InvalidDataException("Failed to deserialize JSON", e);
+            }
+        }
+
+        public static void SerializeObject(object obj, string filepath)
+        {
+            if (string.IsNullOrEmpty(filepath))
+                return;
+
+            var serializerSettings = new JsonSerializerSettings()
+            {
+                NullValueHandling = NullValueHandling.Ignore,
+            };
+
+            var stringJson = JsonConvert.SerializeObject(obj, Formatting.Indented, serializerSettings);
+
+            try
+            {
+                File.WriteAllText(filepath, stringJson);
+            }
+            catch (UnauthorizedAccessException e)
+            {
+                throw new IOException($"Access denied writing to '{filepath}'. Check file permissions.", e);
+            }
+            catch (DirectoryNotFoundException e)
+            {
+                throw new IOException($"Directory not found for '{filepath}'. Ensure the directory exists.", e);
+            }
+            catch (PathTooLongException e)
+            {
+                throw new IOException($"File path '{filepath}' exceeds system maximum length.", e);
+            }
+            catch (IOException e)
+            {
+                throw new IOException($"Unable to write to '{filepath}'. The file may be in use.", e);
+            }
+            catch (Exception e)
+            {
+                throw new IOException($"Unexpected error writing to '{filepath}'.", e);
+            }
+        }
+    }
+}

OpenEphys.Onix1/ProbeInterfaceHelper.cs

@@ -0,0 +1,52 @@
+using System;
+using System.IO;
+using OpenEphys.ProbeInterface.NET;
+
+namespace OpenEphys.Onix1
+{
+    internal static class ProbeInterfaceHelper
+    {
+        public const string ProbeInterfaceFileNameFilter = "ProbeInterface Files|*.json|All Files|*.*";
+
+        public static T LoadExternalProbeInterfaceFile<T>(string probeInterfaceFileName) where T : ProbeGroup
+        {
+            if (string.IsNullOrEmpty(probeInterfaceFileName))
+            {
+                throw new ArgumentNullException(nameof(probeInterfaceFileName), "ProbeInterface file path cannot be null or empty.");
+            }
+
+            if (!File.Exists(probeInterfaceFileName))
+            {
+                throw new FileNotFoundException($"The ProbeInterface file '{probeInterfaceFileName}' does not exist.");
+            }
+
+            try
+            {
+                string jsonContent = File.ReadAllText(probeInterfaceFileName);
+                var result = JsonHelper.DeserializeString<T>(jsonContent) ?? throw new InvalidDataException($"Failed to parse ProbeInterface file: {probeInterfaceFileName}");
+                return result;
+            }
+            catch (UnauthorizedAccessException e)
+            {
+                throw new IOException($"Access denied reading '{probeInterfaceFileName}'. Check file permissions.", e);
+            }
+            catch (PathTooLongException e)
+            {
+                throw new IOException($"File path '{probeInterfaceFileName}' exceeds system maximum length.", e);
+            }
+            catch (IOException e)
+            {
+                throw new IOException($"Unable to read '{probeInterfaceFileName}'. The file may be in use.", e);
+            }
+            catch (Exception e)
+            {
+                throw new IOException($"Unexpected error reading '{probeInterfaceFileName}'.", e);
+            }
+        }
+
+        public static void SaveExternalProbeInterfaceFile(ProbeGroup probeGroup, string probeInterfaceFile)
+        {
+            JsonHelper.SerializeObject(probeGroup, probeInterfaceFile);
+        }
+    }
+}