Add Schema Compare Service endpoint to include/exclude all comparison diffs (#2466)

* Add schema compare include/exclude all diffs

* Add service test for include/exclude all

* Code review changes

* Add test for include/exclude all schema differences

* Reorder using statements.

* Add count assert

* Verify expected number of included/excluded diffs

* Move include/exclude all count assert

* Verify include all works after excluding all

* Improve test example

* Make target script match dev setup for include/exclude all

Author: lewis-sanchez

src/Microsoft.SqlTools.ServiceLayer/SchemaCompare/Contracts/SchemaCompareIncludeExcludeAllNodesRequest.cs

@@ -0,0 +1,53 @@
+//
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+//
+
+#nullable disable
+
+using System.Collections.Generic;
+using Microsoft.SqlTools.Hosting.Protocol.Contracts;
+using Microsoft.SqlTools.ServiceLayer.TaskServices;
+using Microsoft.SqlTools.ServiceLayer.Utility;
+
+namespace Microsoft.SqlTools.ServiceLayer.SchemaCompare.Contracts
+{
+    /// <summary>
+    /// Parameters for a schema compare include specific node request
+    /// </summary>
+    public class SchemaCompareIncludeExcludeAllNodesParams
+    {
+        /// <summary>
+        /// Operation id of the schema compare operation
+        /// </summary>
+        public string OperationId { get; set; }
+
+        /// <summary>
+        /// Indicator for include or exclude request
+        /// </summary>
+        public bool IncludeRequest { get; set; }
+
+        /// <summary>
+        /// Execution mode for the operation. Default is execution
+        /// </summary>
+        public TaskExecutionMode TaskExecutionMode { get; set; }
+    }
+
+    public class SchemaCompareIncludeExcludeAllNodesRequest
+    {
+        public static readonly RequestType<SchemaCompareIncludeExcludeAllNodesParams, ResultStatus> Type =
+       RequestType<SchemaCompareIncludeExcludeAllNodesParams, ResultStatus>.Create("schemaCompare/includeExcludeAllNodes");
+    }
+
+    /// <summary>
+    /// Parameters returned from a schema compare include/exclude all node request.
+    /// </summary>
+    public class SchemaCompareIncludeExcludeAllNodesResult : ResultStatus
+    {
+        /// <summary>
+        /// Differences that were all included or excluded
+        /// </summary>
+        public List<DiffEntry> AllIncludedOrExcludedDifferences { get; set; }
+
+    }
+}

src/Microsoft.SqlTools.ServiceLayer/SchemaCompare/SchemaCompareIncludeExcludeAllNodesOperation.cs

@@ -0,0 +1,122 @@
+//
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+//
+
+#nullable disable
+using System;
+using System.Collections.Generic;
+using System.Threading;
+using Microsoft.SqlServer.Dac.Compare;
+using Microsoft.SqlTools.ServiceLayer.SchemaCompare.Contracts;
+using Microsoft.SqlTools.ServiceLayer.TaskServices;
+using Microsoft.SqlTools.Utility;
+
+namespace Microsoft.SqlTools.ServiceLayer.SchemaCompare
+{
+    /// <summary>
+    /// Class to represent an in-progress schema compare include/exclude all Node operation
+    /// </summary>
+    class SchemaCompareIncludeExcludeAllNodesOperation : ITaskOperation
+    {
+        private CancellationTokenSource cancellation = new CancellationTokenSource();
+        private bool disposed = false;
+
+        /// <summary>
+        /// Gets the unique id associated with this instance.
+        /// </summary>
+        public string OperationId { get; private set; }
+
+        public SchemaCompareIncludeExcludeAllNodesParams Parameters { get; }
+
+        protected CancellationToken CancellationToken { get { return this.cancellation.Token; } }
+
+        public string ErrorMessage { get; set; }
+
+        public SqlTask SqlTask { get; set; }
+
+        public SchemaComparisonResult ComparisonResult { get; set; }
+
+        public bool Success { get; set; }
+
+        public List<DiffEntry> AllIncludedOrExcludedDifferences;
+
+
+        public SchemaCompareIncludeExcludeAllNodesOperation(SchemaCompareIncludeExcludeAllNodesParams parameters, SchemaComparisonResult comparisonResult)
+        {
+            Validate.IsNotNull("parameters", parameters);
+            this.Parameters = parameters;
+            Validate.IsNotNull("comparisonResult", comparisonResult);
+            this.ComparisonResult = comparisonResult;
+        }
+
+        /// <summary>
+        /// Execute will include/exclude all differences in the schema compare result.
+        /// </summary>
+        /// <param name="mode"></param>
+        public void Execute(TaskExecutionMode mode)
+        {
+            this.CancellationToken.ThrowIfCancellationRequested();
+
+            try
+            {
+                var schemaDifferences = new List<SchemaDifference>(this.ComparisonResult.Differences);
+                this.IncludeExcludeAllDifferences(schemaDifferences);
+            }
+            catch (Exception e)
+            {
+                ErrorMessage = e.Message;
+                Logger.Error(string.Format("Schema compare include/exclude all operation {0} failed with exception {1}", this.OperationId, e.Message));
+                throw;
+            }
+
+            this.AllIncludedOrExcludedDifferences = new List<DiffEntry>();
+            if (this.ComparisonResult.Differences != null)
+            {
+                foreach (SchemaDifference difference in this.ComparisonResult.Differences)
+                {
+                    DiffEntry diffEntry = SchemaCompareUtils.CreateDiffEntry(difference, null, this.ComparisonResult);
+                    this.AllIncludedOrExcludedDifferences.Add(diffEntry);
+                }
+            }
+        }
+
+        private void IncludeExcludeAllDifferences(List<SchemaDifference> schemaDifferences)
+        {
+            var problematicDifferences = new List<SchemaDifference>();
+            foreach (SchemaDifference difference in schemaDifferences)
+            {
+                this.Success = this.Parameters.IncludeRequest ? this.ComparisonResult.Include(difference) : this.ComparisonResult.Exclude(difference);
+
+                if (!this.Success)
+                {
+                    problematicDifferences.Add(difference);
+                }
+            }
+
+            if (problematicDifferences.Count != 0)
+            {
+                IncludeExcludeAllDifferences(problematicDifferences);
+            }
+        }
+
+        /// <summary>
+        /// The schema compare public api doesn't currently take a cancellation token so the operation can't be cancelled 
+        /// </summary>
+        public void Cancel()
+        {
+        }
+
+        /// <summary>
+        /// Disposes the operation.
+        /// </summary>
+        public void Dispose()
+        {
+            if (!disposed)
+            {
+                this.Cancel();
+                disposed = true;
+            }
+        }
+    }
+}

src/Microsoft.SqlTools.ServiceLayer/SchemaCompare/SchemaCompareService.cs

@@ -55,6 +55,7 @@ public void InitializeService(ServiceHost serviceHost)
             serviceHost.SetRequestHandler(SchemaComparePublishDatabaseChangesRequest.Type, this.HandleSchemaComparePublishDatabaseChangesRequest, true);
             serviceHost.SetRequestHandler(SchemaComparePublishProjectChangesRequest.Type, this.HandleSchemaComparePublishProjectChangesRequest, true);
             serviceHost.SetRequestHandler(SchemaCompareIncludeExcludeNodeRequest.Type, this.HandleSchemaCompareIncludeExcludeNodeRequest, true);
+            serviceHost.SetRequestHandler(SchemaCompareIncludeExcludeAllNodesRequest.Type, this.HandleSchemaCompareIncludeExcludeAllNodesRequest, true);
             serviceHost.SetRequestHandler(SchemaCompareGetDefaultOptionsRequest.Type, this.HandleSchemaCompareGetDefaultOptionsRequest, true);
             serviceHost.SetRequestHandler(SchemaCompareOpenScmpRequest.Type, this.HandleSchemaCompareOpenScmpRequest, true);
             serviceHost.SetRequestHandler(SchemaCompareSaveScmpRequest.Type, this.HandleSchemaCompareSaveScmpRequest, true);
@@ -305,6 +306,44 @@ await requestContext.SendResult(new ResultStatus()
             }
         }
 
+        // <summary>
+        /// Handles request for exclude incude all nodes in Schema compare result
+        /// </summary>
+        /// <returns></returns>
+        public async Task HandleSchemaCompareIncludeExcludeAllNodesRequest(SchemaCompareIncludeExcludeAllNodesParams parameters, RequestContext<ResultStatus> requestContext)
+        {
+            SchemaCompareIncludeExcludeAllNodesOperation operation = null;
+            try
+            {
+                SchemaComparisonResult compareResult = schemaCompareResults.Value[parameters.OperationId];
+                operation = new SchemaCompareIncludeExcludeAllNodesOperation(parameters, compareResult);
+
+                operation.Execute(parameters.TaskExecutionMode);
+
+                // update the comparison result if the include/exclude was successful
+                if (operation.Success)
+                {
+                    schemaCompareResults.Value[parameters.OperationId] = operation.ComparisonResult;
+                }
+
+                await requestContext.SendResult(new SchemaCompareIncludeExcludeAllNodesResult()
+                {
+                    Success = operation.Success,
+                    ErrorMessage = operation.ErrorMessage,
+                    AllIncludedOrExcludedDifferences = operation.AllIncludedOrExcludedDifferences
+                });
+            }
+            catch (Exception e)
+            {
+                Logger.Error("Failed to select compare schema result node. Error: " + e);
+                await requestContext.SendResult(new SchemaCompareIncludeExcludeAllNodesResult()
+                {
+                    Success = false,
+                    ErrorMessage = operation == null ? e.Message : operation.ErrorMessage,
+                });
+            }
+        }
+
         /// <summary>
         /// Handles request to create default deployment options as per DacFx
         /// </summary>