Add research node packet (#8360)

Common/Api/Organization.cs

@@ -117,6 +117,11 @@ public class ProductItem
         /// </summary>
         [JsonProperty(PropertyName = "productId")]
         public int Id { get; set; }
+
+        /// <summary>
+        /// Quantity for this product
+        /// </summary>
+        public int Quantity { get; set; }
     }
 
     /// <summary>

Common/Extensions.cs

@@ -209,21 +209,36 @@ public static MarketHoursDatabase.Entry GetEntry(this MarketHoursDatabase market
         /// <param name="jsonArray">The value to deserialize</param>
         public static List<string> DeserializeList(this string jsonArray)
         {
-            List<string> result = new();
+            return DeserializeList<string>(jsonArray);
+        }
+
+        /// <summary>
+        /// Helper method to deserialize a json array into a list also handling single json values
+        /// </summary>
+        /// <param name="jsonArray">The value to deserialize</param>
+        public static List<T> DeserializeList<T>(this string jsonArray)
+        {
             try
             {
                 if (string.IsNullOrEmpty(jsonArray))
                 {
-                    return result;
+                    return new();
                 }
-                result = JsonConvert.DeserializeObject<List<string>>(jsonArray);
+                return JsonConvert.DeserializeObject<List<T>>(jsonArray);
             }
-            catch(JsonReaderException)
+            catch (Exception ex)
             {
-                result.Add(jsonArray);
-            }
+                if (ex is not JsonReaderException && ex is not JsonSerializationException)
+                {
+                    throw;
+                }
 
-            return result;
+                if (typeof(T) == typeof(string))
+                {
+                    return new List<T> { (T)Convert.ChangeType(jsonArray, typeof(T), CultureInfo.InvariantCulture) };
+                }
+                return new List<T> { JsonConvert.DeserializeObject<T>(jsonArray) };
+            }
         }
 
         /// <summary>

Common/Global.cs

@@ -990,7 +990,12 @@ public enum DeploymentTarget
         /// <summary>
         /// Local Platform (1)
         /// </summary>
-        LocalPlatform
+        LocalPlatform,
+
+        /// <summary>
+        /// Private Cloud Platform (2)
+        /// </summary>
+        PrivateCloudPlatform
     }
 
     /// <summary>

Common/Packets/AlgorithmNodePacket.cs

@@ -71,6 +71,10 @@ public string AlgorithmId
                 {
                     return ((LiveNodePacket)this).DeployId;
                 }
+                else if (Type == PacketType.ResearchNode)
+                {
+                    return ((ResearchNodePacket)this).ResearchId;
+                }
                 return ((BacktestNodePacket)this).BacktestId;
             }
         }

Common/Packets/Packet.cs

@@ -191,5 +191,8 @@ public enum PacketType
 
         /// Algorithm tags update
         AlgorithmTagsUpdate,
+
+        /// Research job packet
+        ResearchNode,
     }
 }

Common/Packets/ResearchNodePacket.cs

@@ -0,0 +1,41 @@
+/*
+ * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
+ * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+*/
+
+namespace QuantConnect.Packets
+{
+    /// <summary>
+    /// Represents a research node packet
+    /// </summary>
+    public class ResearchNodePacket : AlgorithmNodePacket
+    {
+        /// <summary>
+        /// The research id
+        /// </summary>
+        public string ResearchId { get; set; }
+
+        /// <summary>
+        /// Associated research token
+        /// </summary>
+        public string ResearchToken { get; set; }
+
+        /// <summary>
+        /// Creates a new instance
+        /// </summary>
+        public ResearchNodePacket() : base(PacketType.ResearchNode)
+        {
+        }
+    }
+}

Common/Util/Composer.cs

@@ -315,7 +315,7 @@ public T GetExportedValueByTypeName<T>(string typeName, bool forceTypeNameOnExis
                     if (selectedPart == null)
                     {
                         throw new ArgumentException(
-                            $"Unable to locate any exports matching the requested typeName: {typeName}", nameof(typeName));
+                            $"Unable to locate any exports matching the requested typeName: {typeName}. Type: {type}", nameof(typeName));
                     }
 
                     var exportDefinition =

Tests/Common/Util/ExtensionsTests.cs

@@ -46,6 +46,35 @@ namespace QuantConnect.Tests.Common.Util
     [TestFixture]
     public class ExtensionsTests
     {
+        [TestCase("A test", 1)]
+        [TestCase("[\"A test\"]", 1)]
+        [TestCase("[\"A test\", \"something else\"]", 2)]
+        public void DeserializeList(string input, int count)
+        {
+            var result = input.DeserializeList();
+            Assert.AreEqual(count, result.Count);
+            Assert.AreEqual("A test", result[0]);
+            if (count == 2)
+            {
+                Assert.AreEqual("something else", result[1]);
+            }
+        }
+
+        private class DeserializeListObject { public int Property { get; set; } }
+        [TestCase("{ \"property\": 10}", 1)]
+        [TestCase("[{ \"property\": 10}]", 1)]
+        [TestCase("[{ \"property\": 10}, { \"property\": 20 }]", 2)]
+        public void DeserializeObjectList(string input, int count)
+        {
+            var result = input.DeserializeList<DeserializeListObject>();
+            Assert.AreEqual(count, result.Count);
+            Assert.AreEqual(10, result[0].Property);
+            if (count == 2)
+            {
+                Assert.AreEqual(20, result[1].Property);
+            }
+        }
+
         [TestCase(true)]
         [TestCase(false)]
         public void ConvertPythonSymbolEnumerableSingle(bool useSymbol)