DYN-1662: As a dynamo dev, I want to serialize what packages are needed in a graph

src/DynamoCore/DynamoCore.csproj

@@ -114,6 +114,7 @@ limitations under the License.
     <Compile Include="Core\DynamoMigrator.cs" />
     <Compile Include="Engine\ShortestQualifiedNameReplacer.cs" />
     <Compile Include="Exceptions\LibraryLoadFailedException.cs" />
+    <Compile Include="Graph\Workspaces\PackageDependencyInfo.cs" />
     <Compile Include="Graph\Nodes\NodeOutputData.cs" />
     <Compile Include="Graph\Nodes\NodeInputData.cs" />
     <Compile Include="Graph\Workspaces\LayoutExtensions.cs" />

src/DynamoCore/Graph/Workspaces/PackageDependencyInfo.cs

@@ -0,0 +1,102 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Dynamo.Graph.Workspaces
+{
+    /// <summary>
+    /// Class containing info about a Dynamo package. 
+    /// Used for serialization.
+    /// </summary>
+    internal class PackageDependencyInfo
+    {
+        /// <summary>
+        /// Name of the package
+        /// </summary>
+        internal string Name { get; set; }
+
+        /// <summary>
+        /// Version of the package
+        /// </summary>
+        internal Version Version { get; set; }
+
+        /// <summary>
+        /// Guids of nodes in the workspace that are dependent on this package
+        /// </summary>
+        internal HashSet<Guid> Nodes
+        {
+            get { return nodes; }
+        }
+        private HashSet<Guid> nodes;
+
+        /// <summary>
+        /// Create a package info object from the package name and version
+        /// </summary>
+        /// <param name="name"></param>
+        /// <param name="version"></param>
+        internal PackageDependencyInfo(string name, Version version)
+        {
+            Name = name;
+            Version = version;
+            nodes = new HashSet<Guid>();
+        }
+
+        /// <summary>
+        /// Add the Guid of a dependent node
+        /// </summary>
+        /// <param name="guid"></param>
+        internal void AddDependent(Guid guid)
+        {
+             Nodes.Add(guid);
+        }
+
+        /// <summary>
+        /// Add the Guids of a dependent nodes
+        /// </summary>
+        /// <param name="guids"></param>
+        internal void AddDependents(IEnumerable<Guid> guids)
+        {
+            foreach(var guid in guids)
+            {
+                Nodes.Add(guid);
+            }
+        }
+
+        /// <summary>
+        /// Remove a dependent node
+        /// </summary>
+        /// <param name="guid"></param>
+        internal void RemoveDependent(Guid guid)
+        {
+            Nodes.Remove(guid);
+        }
+
+        /// <summary>
+        /// Checks whether two PackageDependencyInfos are equal
+        /// They are equal if their Name and Versions are equal
+        /// </summary>
+        /// <param name="obj"></param>
+        /// <returns></returns>
+        public override bool Equals(object obj)
+        {
+            if (obj == null)
+            {
+                return false;
+            }
+            if (!(obj is PackageDependencyInfo))
+            {
+                return false;
+            }
+
+            var other = obj as PackageDependencyInfo;
+            if (other.Name == this.Name && other.Version == this.Version)
+            {
+                return true;
+            }
+            return false;
+        }
+    }
+}

src/DynamoCore/Graph/Workspaces/SerializationConverters.cs

@@ -525,6 +525,16 @@ public override object ReadJson(JsonReader reader, Type objectType, object exist
             // relevant ports.
             var connectors = obj["Connectors"].ToObject<IEnumerable<ConnectorModel>>(serializer);
 
+            IEnumerable<PackageDependencyInfo> packageDependencies;
+            if (obj["PackageDependencies"] != null)
+            {
+                packageDependencies = obj["PackageDependencies"].ToObject<IEnumerable<PackageDependencyInfo>>(serializer);
+            }
+            else
+            {
+                packageDependencies = new List<PackageDependencyInfo>();
+            }
+
             var info = new WorkspaceInfo(guid.ToString(), name, description, Dynamo.Models.RunType.Automatic);
 
             // IsVisibleInDynamoLibrary and Category should be set explicitly for custom node workspace
@@ -587,6 +597,8 @@ public override object ReadJson(JsonReader reader, Type objectType, object exist
                     info, verboseLogging, isTestMode);
             }
 
+            ws.PackageDependencies = packageDependencies.ToList();
+
             return ws;
         }
 
@@ -689,6 +701,10 @@ public override void WriteJson(JsonWriter writer, object value, JsonSerializer s
             }
             writer.WriteEndArray();
 
+            // PackageDependencies
+            writer.WritePropertyName("PackageDependencies");
+            serializer.Serialize(writer, ws.PackageDependencies);
+
             if (engine != null)
             {
                 // Bindings
@@ -739,6 +755,97 @@ public override object ReadJson(JsonReader reader, Type objectType, object exist
         }
     }
 
+    /// <summary>
+    /// PackageDependencyInfoConverter is used to serialize and deserialize graph package dependencies
+    /// </summary>
+    public class PackageDependencyInfoConverter : JsonConverter
+    {
+        private Logging.ILogger logger;
+
+        /// <summary>
+        /// Constructs a PackageDependencyInfoConverter.
+        /// </summary>
+        /// <param name="logger"></param>
+        public PackageDependencyInfoConverter(Logging.ILogger logger)
+        {
+            this.logger = logger;
+        }
+
+        public override bool CanConvert(Type objectType)
+        {
+            return typeof(PackageDependencyInfo).IsAssignableFrom(objectType);
+        }
+
+        public override bool CanRead
+        {
+            get { return true; }
+        }
+
+        public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
+        {
+            PackageDependencyInfo p = value as PackageDependencyInfo;
+            if (p != null)
+            {
+                writer.WriteStartObject();
+                writer.WritePropertyName("Name");
+                writer.WriteValue(p.Name);
+                writer.WritePropertyName("Version");
+                writer.WriteValue(p.Version.ToString());
+                writer.WritePropertyName("Nodes");
+                writer.WriteStartArray();
+                foreach(var node in p.Nodes)
+                {
+                    writer.WriteValue(node.ToString("N"));
+                }
+                writer.WriteEndArray();
+                writer.WriteEndObject();
+            }
+            else
+            {
+                logger.LogWarning("Unnsuccessful attempt to serialize a PackageDependencyInfo object.", Logging.WarningLevel.Moderate);
+            }
+        }
+
+        public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
+        {
+            var obj = JObject.Load(reader);
+
+            // Get package name
+            var name = obj["Name"].Value<string>();
+
+            // Try get package version
+            var versionString = obj["Version"].Value<string>();
+            Version version;
+            if (!Version.TryParse(versionString, out version))
+            {
+                logger.LogWarning(
+                    string.Format("The version of Package Dependency {0} could not be deserialized.", name), 
+                    Logging.WarningLevel.Moderate);
+            }
+
+            // Create new PackageDependencyInfo
+            var packageInfo = new PackageDependencyInfo(name, version);
+
+            // Try get dependent node IDs
+            var nodes = obj["Nodes"].Values<string>();
+            foreach(var nodeID in nodes)
+            {
+                Guid guid;
+                if (!Guid.TryParse(nodeID, out guid))
+                {
+                    logger.LogWarning(
+                    string.Format("The id ({0}) of a node dependent on {1} could not be parsed as a GUID.", nodeID, name),
+                    Logging.WarningLevel.Moderate);
+                }
+                else
+                {
+                    packageInfo.AddDependent(guid);
+                }
+            }
+            return packageInfo;
+        }
+    }
+
     /// <summary>
     /// DummyNodeWriteConverter is used for serializing DummyNodes to JSON.
     /// Note that the DummyNode objects serialize as their original content and not as a DummyNode.

src/DynamoCore/Graph/Workspaces/SerializationExtensions.cs

@@ -35,7 +35,8 @@ internal static string ToJson(this WorkspaceModel workspace, EngineController en
                         new ConnectorConverter(logger),                        
                         new WorkspaceWriteConverter(engine),
                         new DummyNodeWriteConverter(),
-                        new TypedParameterConverter()
+                        new TypedParameterConverter(),
+                        new PackageDependencyInfoConverter(logger),
                     },
                 ReferenceResolverProvider = () => { return new IdReferenceResolver(); }
             };