From 28eaa67d6f583785befb7845fd74c9175ecaaeb4 Mon Sep 17 00:00:00 2001 From: Marie Rinsche Date: Fri, 28 Jul 2023 13:17:05 +0200 Subject: [PATCH 1/3] Override the equals method of workplan including tests - compare the types of steps and connectors - create tests --- .../Workflows/Implementation/Workplan.cs | 100 +++++++++++++- src/Tests/Moryx.Tests/Moryx.Tests.csproj | 1 + .../Workplans/Dummies/AssemblingActivity.cs | 34 +++++ .../Dummies/AssemblingCapabilities.cs | 23 ++++ .../Workplans/Dummies/AssemblingParameters.cs | 17 +++ .../Workplans/Dummies/AssemblingTask.cs | 16 +++ .../Workplans/Dummies/ColorizingTask.cs | 16 +++ .../Workplans/Dummies/PackagingTask.cs | 16 +++ src/Tests/Moryx.Tests/Workplans/EqualTest.cs | 127 ++++++++++++++++++ 9 files changed, 348 insertions(+), 2 deletions(-) create mode 100644 src/Tests/Moryx.Tests/Workplans/Dummies/AssemblingActivity.cs create mode 100644 src/Tests/Moryx.Tests/Workplans/Dummies/AssemblingCapabilities.cs create mode 100644 src/Tests/Moryx.Tests/Workplans/Dummies/AssemblingParameters.cs create mode 100644 src/Tests/Moryx.Tests/Workplans/Dummies/AssemblingTask.cs create mode 100644 src/Tests/Moryx.Tests/Workplans/Dummies/ColorizingTask.cs create mode 100644 src/Tests/Moryx.Tests/Workplans/Dummies/PackagingTask.cs create mode 100644 src/Tests/Moryx.Tests/Workplans/EqualTest.cs diff --git a/src/Moryx/Workflows/Implementation/Workplan.cs b/src/Moryx/Workflows/Implementation/Workplan.cs index 15aa6650c..a95699a76 100644 --- a/src/Moryx/Workflows/Implementation/Workplan.cs +++ b/src/Moryx/Workflows/Implementation/Workplan.cs @@ -3,7 +3,9 @@ using System.Collections.Generic; using System.Runtime.Serialization; - +using System.Linq; +using System.ComponentModel; + namespace Moryx.Workplans { /// @@ -92,5 +94,99 @@ public static Workplan Restore(List connectors, List { return new Workplan(connectors, steps); } - } + + /// + /// Compare two workplans + /// + /// + /// + public override bool Equals(object obj) + { + + if (!(obj is Workplan)) + { + return false; + } + Workplan newPlan = (Workplan)obj; + + var start = this.Connectors.First(x => x.Name.Equals("Start")); + var end = this.Connectors.First(x => x.Name.Equals("End")); + var failed = this.Connectors.First(x => x.Name.Equals("Failed")); + + var newStart = newPlan.Connectors.First(x => x.Name.Equals("Start")); + var newEnd = newPlan.Connectors.First(x => x.Name.Equals("End")); + var newFailed = newPlan.Connectors.First(x => x.Name.Equals("Failed")); + + var step = this.Steps.First(x => x.Inputs.Any(y => y.Equals(start))); + var newStep = newPlan.Steps.First(x => x.Inputs.Any(y => y.Equals(newStart))); + + List needToCheck = new List(); + List newNeedToCheck = new List(); + + List check = new List(); + + needToCheck.Add(step); + newNeedToCheck.Add(newStep); + + while (needToCheck.Count != 0 && newNeedToCheck.Count != 0) + { + + + for (int a = 0; a < step.Outputs.Length; a++) + { + + var connector = step.Outputs[a]; + var newConnector = newStep.Outputs[a]; + + bool isNotEndConnector = (connector != end && newConnector != newEnd); + bool isNotFailedConnector = (connector != failed && newConnector != newFailed); + + if (isNotEndConnector && isNotFailedConnector) + { + var follower = this.Steps.FirstOrDefault(x => x.Inputs.Any(y => y.Equals(connector))); + var newFollower = newPlan.Steps.FirstOrDefault(x => x.Inputs.Any(y => y.Equals(newConnector))); + + bool isAlreadyChecked = (check.Contains(follower) || check.Contains(newFollower)); + + if (!(isAlreadyChecked)) + { + needToCheck.Add(follower); + newNeedToCheck.Add(newFollower); + } + } + else if (connector.Classification != newConnector.Classification) + { + return false; + } + } + + + + bool isSameStep = (step.GetType() == newStep.GetType()); + if (isSameStep) + { + needToCheck.Remove(step); + newNeedToCheck.Remove(newStep); + + check.Add(step); + + if (needToCheck.Count != 0 && newNeedToCheck.Count != 0) + { + step = needToCheck[0]; + newStep = newNeedToCheck[0]; + } + } + else + { + return false; + } + } + + return true; + } + + + + } } + diff --git a/src/Tests/Moryx.Tests/Moryx.Tests.csproj b/src/Tests/Moryx.Tests/Moryx.Tests.csproj index 1ff29d6a4..d7ba8634a 100644 --- a/src/Tests/Moryx.Tests/Moryx.Tests.csproj +++ b/src/Tests/Moryx.Tests/Moryx.Tests.csproj @@ -14,6 +14,7 @@ + diff --git a/src/Tests/Moryx.Tests/Workplans/Dummies/AssemblingActivity.cs b/src/Tests/Moryx.Tests/Workplans/Dummies/AssemblingActivity.cs new file mode 100644 index 000000000..2c0f056dc --- /dev/null +++ b/src/Tests/Moryx.Tests/Workplans/Dummies/AssemblingActivity.cs @@ -0,0 +1,34 @@ +using Moryx.AbstractionLayer; +using Moryx.AbstractionLayer.Capabilities; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace Moryx.Tests.Workplans.Dummies +{ + [ActivityResults(typeof(DefaultActivityResult))] + public class AssemblingActivity : Activity + { + + + public override ProcessRequirement ProcessRequirement => ProcessRequirement.NotRequired; + + public override ICapabilities RequiredCapabilities => new AssemblingCapabilities(); + + protected override ActivityResult CreateResult(long resultNumber) + { + return ActivityResult.Create((DefaultActivityResult)resultNumber); + } + + protected override ActivityResult CreateFailureResult() + { + return ActivityResult.Create(DefaultActivityResult.Failed); + } + + + + + } +} diff --git a/src/Tests/Moryx.Tests/Workplans/Dummies/AssemblingCapabilities.cs b/src/Tests/Moryx.Tests/Workplans/Dummies/AssemblingCapabilities.cs new file mode 100644 index 000000000..9127e8f0d --- /dev/null +++ b/src/Tests/Moryx.Tests/Workplans/Dummies/AssemblingCapabilities.cs @@ -0,0 +1,23 @@ +using Moryx.AbstractionLayer.Capabilities; + +namespace Moryx.Tests.Workplans.Dummies +{ + + public class AssemblingCapabilities : CapabilitiesBase + { + public int Value { get; set; } + + protected override bool ProvidedBy(ICapabilities provided) + { + var providedAssembling = provided as AssemblingCapabilities; + if (providedAssembling == null) + return false; + + if (providedAssembling.Value < Value) // Provided must be greater or equal + return false; + + return true; + } + } + +} \ No newline at end of file diff --git a/src/Tests/Moryx.Tests/Workplans/Dummies/AssemblingParameters.cs b/src/Tests/Moryx.Tests/Workplans/Dummies/AssemblingParameters.cs new file mode 100644 index 000000000..18738be1f --- /dev/null +++ b/src/Tests/Moryx.Tests/Workplans/Dummies/AssemblingParameters.cs @@ -0,0 +1,17 @@ +using Moryx.AbstractionLayer; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace Moryx.Tests.Workplans.Dummies +{ + public class AssemblingParameters : Parameters + { + protected override void Populate(IProcess process, Parameters instance) + { + + } + } +} diff --git a/src/Tests/Moryx.Tests/Workplans/Dummies/AssemblingTask.cs b/src/Tests/Moryx.Tests/Workplans/Dummies/AssemblingTask.cs new file mode 100644 index 000000000..68acdaf26 --- /dev/null +++ b/src/Tests/Moryx.Tests/Workplans/Dummies/AssemblingTask.cs @@ -0,0 +1,16 @@ +using Moryx.AbstractionLayer; +using System; +using System.Collections.Generic; +using System.ComponentModel.DataAnnotations; +using System.Linq; +using System.Text; +using System.Threading.Tasks; +using System.Xml.Linq; + +namespace Moryx.Tests.Workplans.Dummies +{ + [Display(Name = "Assembling Task", Description = "Task which does something with a product")] + public class AssemblingTask : TaskStep + { + } +} diff --git a/src/Tests/Moryx.Tests/Workplans/Dummies/ColorizingTask.cs b/src/Tests/Moryx.Tests/Workplans/Dummies/ColorizingTask.cs new file mode 100644 index 000000000..3bd3cf207 --- /dev/null +++ b/src/Tests/Moryx.Tests/Workplans/Dummies/ColorizingTask.cs @@ -0,0 +1,16 @@ +using Moryx.AbstractionLayer; +using System; +using System.Collections.Generic; +using System.ComponentModel.DataAnnotations; +using System.Linq; +using System.Text; +using System.Threading.Tasks; +using System.Xml.Linq; + +namespace Moryx.Tests.Workplans.Dummies +{ + [Display(Name = "PackagingTask", Description = "Task which does something with a product")] + public class ColorizingTask : TaskStep + { + } +} \ No newline at end of file diff --git a/src/Tests/Moryx.Tests/Workplans/Dummies/PackagingTask.cs b/src/Tests/Moryx.Tests/Workplans/Dummies/PackagingTask.cs new file mode 100644 index 000000000..19f6ff315 --- /dev/null +++ b/src/Tests/Moryx.Tests/Workplans/Dummies/PackagingTask.cs @@ -0,0 +1,16 @@ +using Moryx.AbstractionLayer; +using System; +using System.Collections.Generic; +using System.ComponentModel.DataAnnotations; +using System.Linq; +using System.Text; +using System.Threading.Tasks; +using System.Xml.Linq; + +namespace Moryx.Tests.Workplans.Dummies +{ + [Display(Name = "PackagingTask", Description = "Task which does something with a product")] + public class PackagingTask : TaskStep + { + } +} diff --git a/src/Tests/Moryx.Tests/Workplans/EqualTest.cs b/src/Tests/Moryx.Tests/Workplans/EqualTest.cs new file mode 100644 index 000000000..621b55572 --- /dev/null +++ b/src/Tests/Moryx.Tests/Workplans/EqualTest.cs @@ -0,0 +1,127 @@ +using Moryx.Workplans; +using Moryx.AbstractionLayer; +using NUnit.Framework; +using Moryx.Tests.Workplans.Dummies; + +namespace Moryx.Tests.Workplans +{ + + [TestFixture] + public class EqualTest + { + private Workplan firstWorkplan; + private Workplan secondWorkplan; + private Workplan thirdWorkplan; + private Workplan fourthWorkplan; + private Workplan fifthWorkplan; + private Workplan sixthWorkplan; + + public Workplan CreateFirstWorkplan() + { + var plan = new Workplan(); + + var start = plan.AddConnector("Start", NodeClassification.Start); + var end = plan.AddConnector("End", NodeClassification.End); + var failed = plan.AddConnector("Failed", NodeClassification.Failed); + + var input = start; + var outputA = plan.AddConnector("A"); + var outputB = plan.AddConnector("B"); + + plan.AddStep(new AssemblingTask(), new AssemblingParameters(), input, outputA, outputB, failed); + + input = outputA; + plan.AddStep(new PackagingTask(), new AssemblingParameters(), input, end, end, failed); + + input = outputB; + plan.AddStep(new ColorizingTask(), new AssemblingParameters(), input, end, failed, failed); + return plan; + } + + public Workplan CreateSecondWorkplan() + { + var plan = new Workplan(); + + var start = plan.AddConnector("Start", NodeClassification.Start); + var end = plan.AddConnector("End", NodeClassification.End); + var failed = plan.AddConnector("Failed", NodeClassification.Failed); + + var input = start; + var outptuA = input; + var outputB = plan.AddConnector("A"); + + plan.AddStep(new AssemblingTask(), new AssemblingParameters(), input, outptuA, outputB, failed); + + input = outputB; + plan.AddStep(new PackagingTask(), new AssemblingParameters(), input, outputB, end, failed); + + return plan; + } + + public Workplan CreateThirdWorkplan() + { + var plan = new Workplan(); + + var start = plan.AddConnector("Start", NodeClassification.Start); + var end = plan.AddConnector("End", NodeClassification.End); + var failed = plan.AddConnector("Failed", NodeClassification.Failed); + + var outputA = plan.AddConnector("A"); + var outputB = plan.AddConnector("B"); + + plan.AddStep(new AssemblingTask(), new AssemblingParameters(), start, outputA, outputB, failed); + + var input = outputA; + + plan.AddStep(new PackagingTask(), new AssemblingParameters(), input, start, end, failed); + + input = outputB; + + plan.AddStep(new ColorizingTask(), new AssemblingParameters(), input, outputA, end, failed); + + return plan; + } + + [SetUp] + public void SetUp() + { + firstWorkplan = CreateFirstWorkplan(); + secondWorkplan = CreateFirstWorkplan(); + + thirdWorkplan = CreateSecondWorkplan(); + fourthWorkplan = CreateSecondWorkplan(); + + fifthWorkplan = CreateThirdWorkplan(); + sixthWorkplan = CreateThirdWorkplan(); + } + + [Test] + public void TestEqualWorkplans() + { + bool result = firstWorkplan.Equals(secondWorkplan); + Assert.That(result, Is.True); + } + + [Test] + public void TestEqualWorkplansSimpleLoop() + { + bool result = thirdWorkplan.Equals(fourthWorkplan); + Assert.That(result, Is.True); + } + + [Test] + public void TestEqualWorkplansDoubleLoop() + { + bool result = fifthWorkplan.Equals(sixthWorkplan); + Assert.That(result, Is.True); + } + + [Test] + public void TestUnequalWorkplans() + { + bool r = thirdWorkplan.Equals(fifthWorkplan); + Assert.That(r, Is.False); + } + } + +} From 59fd6d1d53524aea1bd8a9ce280bfa624b6b0e3a Mon Sep 17 00:00:00 2001 From: Marie Rinsche Date: Mon, 7 Aug 2023 14:43:29 +0200 Subject: [PATCH 2/3] Update after merge request feedback - create an additional method to check connactions and following steps - reduce unnecessary variables - changing the sequence - rename methods in the EqualTest class - switch from a override method to a static method --- .../Workflows/Implementation/Workplan.cs | 113 ++++++++---------- .../Workplans/Dummies/AssemblingActivity.cs | 11 -- src/Tests/Moryx.Tests/Workplans/EqualTest.cs | 26 ++-- 3 files changed, 66 insertions(+), 84 deletions(-) diff --git a/src/Moryx/Workflows/Implementation/Workplan.cs b/src/Moryx/Workflows/Implementation/Workplan.cs index a95699a76..9d0bb02a6 100644 --- a/src/Moryx/Workflows/Implementation/Workplan.cs +++ b/src/Moryx/Workflows/Implementation/Workplan.cs @@ -3,8 +3,7 @@ using System.Collections.Generic; using System.Runtime.Serialization; -using System.Linq; -using System.ComponentModel; +using System.Linq; namespace Moryx.Workplans { @@ -95,85 +94,81 @@ public static Workplan Restore(List connectors, List return new Workplan(connectors, steps); } - /// - /// Compare two workplans - /// - /// - /// - public override bool Equals(object obj) + public static bool NoteSameFollowringSteps(Workplan workplan, Workplan newWorkplan ,IWorkplanStep step, IWorkplanStep newStep, List needToCheck, List newNeedToCheck, List isChecked) { - - if (!(obj is Workplan)) - { - return false; - } - Workplan newPlan = (Workplan)obj; - - var start = this.Connectors.First(x => x.Name.Equals("Start")); - var end = this.Connectors.First(x => x.Name.Equals("End")); - var failed = this.Connectors.First(x => x.Name.Equals("Failed")); - - var newStart = newPlan.Connectors.First(x => x.Name.Equals("Start")); - var newEnd = newPlan.Connectors.First(x => x.Name.Equals("End")); - var newFailed = newPlan.Connectors.First(x => x.Name.Equals("Failed")); - - var step = this.Steps.First(x => x.Inputs.Any(y => y.Equals(start))); - var newStep = newPlan.Steps.First(x => x.Inputs.Any(y => y.Equals(newStart))); - - List needToCheck = new List(); - List newNeedToCheck = new List(); - - List check = new List(); - - needToCheck.Add(step); - newNeedToCheck.Add(newStep); - - while (needToCheck.Count != 0 && newNeedToCheck.Count != 0) + + for (int a = 0; a < step.Outputs.Length; a++) { + var connector = step.Outputs[a]; + var newConnector = newStep.Outputs[a]; - - for (int a = 0; a < step.Outputs.Length; a++) + if (connector.Id == newConnector.Id) { - var connector = step.Outputs[a]; - var newConnector = newStep.Outputs[a]; - - bool isNotEndConnector = (connector != end && newConnector != newEnd); - bool isNotFailedConnector = (connector != failed && newConnector != newFailed); + bool isNotEndConnector = !(connector.Classification.Equals(NodeClassification.End)) && !(newConnector.Classification.Equals(NodeClassification.End)); + bool isNotFailedConnector = !(connector.Classification.Equals(NodeClassification.Failed)) && !(newConnector.Classification.Equals(NodeClassification.Failed)); if (isNotEndConnector && isNotFailedConnector) { - var follower = this.Steps.FirstOrDefault(x => x.Inputs.Any(y => y.Equals(connector))); - var newFollower = newPlan.Steps.FirstOrDefault(x => x.Inputs.Any(y => y.Equals(newConnector))); + var follower = workplan.Steps.FirstOrDefault(x => x.Inputs.Any(y => y.Equals(connector))); + var newFollower = newWorkplan.Steps.FirstOrDefault(x => x.Inputs.Any(y => y.Equals(newConnector))); + + bool isAlreadyChecked = (isChecked.Contains(follower) || isChecked.Contains(newFollower)); - bool isAlreadyChecked = (check.Contains(follower) || check.Contains(newFollower)); - if (!(isAlreadyChecked)) { needToCheck.Add(follower); newNeedToCheck.Add(newFollower); } } - else if (connector.Classification != newConnector.Classification) - { - return false; - } } + else + { + return false; + } + } + return true; + } + /// + /// Compare two workplans + /// + /// + /// + /// + public static bool Equals(Workplan workplan, Workplan newWorkplan) + { + var step = workplan.Steps.First(x => x.Inputs.Any(y => y.Classification.Equals(NodeClassification.Start))); + var newStep = newWorkplan.Steps.First(x => x.Inputs.Any(y => y.Classification.Equals(NodeClassification.Start))); + List needToCheck = new List() { step }; + List newNeedToCheck = new List() { newStep }; + List isChecked = new List(); + + while (needToCheck.Count != 0 && newNeedToCheck.Count != 0) + { bool isSameStep = (step.GetType() == newStep.GetType()); if (isSameStep) { - needToCheck.Remove(step); - newNeedToCheck.Remove(newStep); - check.Add(step); + bool sameConnections = NoteSameFollowringSteps(workplan, newWorkplan, step, newStep, needToCheck, newNeedToCheck, isChecked); + if (sameConnections) + { + needToCheck.Remove(step); + newNeedToCheck.Remove(newStep); + + isChecked.Add(step); - if (needToCheck.Count != 0 && newNeedToCheck.Count != 0) + if (needToCheck.Count != 0 && newNeedToCheck.Count != 0) + { + step = needToCheck[0]; + newStep = newNeedToCheck[0]; + } + } + else { - step = needToCheck[0]; - newStep = newNeedToCheck[0]; + return false; } } else @@ -184,9 +179,7 @@ public override bool Equals(object obj) return true; } - - + } -} - +} \ No newline at end of file diff --git a/src/Tests/Moryx.Tests/Workplans/Dummies/AssemblingActivity.cs b/src/Tests/Moryx.Tests/Workplans/Dummies/AssemblingActivity.cs index 2c0f056dc..5d21a8ca7 100644 --- a/src/Tests/Moryx.Tests/Workplans/Dummies/AssemblingActivity.cs +++ b/src/Tests/Moryx.Tests/Workplans/Dummies/AssemblingActivity.cs @@ -1,18 +1,11 @@ using Moryx.AbstractionLayer; using Moryx.AbstractionLayer.Capabilities; -using System; -using System.Collections.Generic; -using System.Linq; -using System.Text; -using System.Threading.Tasks; namespace Moryx.Tests.Workplans.Dummies { [ActivityResults(typeof(DefaultActivityResult))] public class AssemblingActivity : Activity { - - public override ProcessRequirement ProcessRequirement => ProcessRequirement.NotRequired; public override ICapabilities RequiredCapabilities => new AssemblingCapabilities(); @@ -26,9 +19,5 @@ protected override ActivityResult CreateFailureResult() { return ActivityResult.Create(DefaultActivityResult.Failed); } - - - - } } diff --git a/src/Tests/Moryx.Tests/Workplans/EqualTest.cs b/src/Tests/Moryx.Tests/Workplans/EqualTest.cs index 621b55572..8d0c6a405 100644 --- a/src/Tests/Moryx.Tests/Workplans/EqualTest.cs +++ b/src/Tests/Moryx.Tests/Workplans/EqualTest.cs @@ -16,7 +16,7 @@ public class EqualTest private Workplan fifthWorkplan; private Workplan sixthWorkplan; - public Workplan CreateFirstWorkplan() + public Workplan CreateSimpleWorkplan() { var plan = new Workplan(); @@ -38,7 +38,7 @@ public Workplan CreateFirstWorkplan() return plan; } - public Workplan CreateSecondWorkplan() + public Workplan CreateWorkplanWithLoop() { var plan = new Workplan(); @@ -58,7 +58,7 @@ public Workplan CreateSecondWorkplan() return plan; } - public Workplan CreateThirdWorkplan() + public Workplan CreateWorkplanWithLoopsAndBranches() { var plan = new Workplan(); @@ -85,41 +85,41 @@ public Workplan CreateThirdWorkplan() [SetUp] public void SetUp() { - firstWorkplan = CreateFirstWorkplan(); - secondWorkplan = CreateFirstWorkplan(); + firstWorkplan = CreateSimpleWorkplan(); + secondWorkplan = CreateSimpleWorkplan(); - thirdWorkplan = CreateSecondWorkplan(); - fourthWorkplan = CreateSecondWorkplan(); + thirdWorkplan = CreateWorkplanWithLoop(); + fourthWorkplan = CreateWorkplanWithLoop(); - fifthWorkplan = CreateThirdWorkplan(); - sixthWorkplan = CreateThirdWorkplan(); + fifthWorkplan = CreateWorkplanWithLoopsAndBranches(); + sixthWorkplan = CreateWorkplanWithLoopsAndBranches(); } [Test] public void TestEqualWorkplans() { - bool result = firstWorkplan.Equals(secondWorkplan); + bool result = Workplan.Equals(firstWorkplan, secondWorkplan); Assert.That(result, Is.True); } [Test] public void TestEqualWorkplansSimpleLoop() { - bool result = thirdWorkplan.Equals(fourthWorkplan); + bool result = Workplan.Equals(thirdWorkplan, fourthWorkplan); Assert.That(result, Is.True); } [Test] public void TestEqualWorkplansDoubleLoop() { - bool result = fifthWorkplan.Equals(sixthWorkplan); + bool result = Workplan.Equals(fifthWorkplan, sixthWorkplan); Assert.That(result, Is.True); } [Test] public void TestUnequalWorkplans() { - bool r = thirdWorkplan.Equals(fifthWorkplan); + bool r = Workplan.Equals(firstWorkplan, sixthWorkplan); Assert.That(r, Is.False); } } From 2742aa494f99c6ada9cf026dfa913b33e1152821 Mon Sep 17 00:00:00 2001 From: Marie Rinsche Date: Tue, 8 Aug 2023 13:44:41 +0200 Subject: [PATCH 3/3] Create class for parameters and optimize if-conditions --- .../Implementation/ComparingProperties.cs | 18 ++++ .../Workflows/Implementation/Workplan.cs | 96 +++++++++---------- 2 files changed, 64 insertions(+), 50 deletions(-) create mode 100644 src/Moryx/Workflows/Implementation/ComparingProperties.cs diff --git a/src/Moryx/Workflows/Implementation/ComparingProperties.cs b/src/Moryx/Workflows/Implementation/ComparingProperties.cs new file mode 100644 index 000000000..0acd48bbf --- /dev/null +++ b/src/Moryx/Workflows/Implementation/ComparingProperties.cs @@ -0,0 +1,18 @@ +using Moryx.Workplans; +using System.Collections.Generic; + +namespace Moryx.Workflows.Implementation +{ + public class ComparingProperties + { + public IWorkplanStep Step { get; set;} + public IWorkplanStep NewStep { get; set; } + public Workplan Workplan { get; set; } + public Workplan NewWorkplan { get; set; } + public List IsChecked { get; set; } + public List NeedToCheck { get; set; } + public List NewNeedToCheck { get; set; } + } + +} + diff --git a/src/Moryx/Workflows/Implementation/Workplan.cs b/src/Moryx/Workflows/Implementation/Workplan.cs index 9d0bb02a6..bf473a2bd 100644 --- a/src/Moryx/Workflows/Implementation/Workplan.cs +++ b/src/Moryx/Workflows/Implementation/Workplan.cs @@ -1,9 +1,7 @@ -// Copyright (c) 2023, Phoenix Contact GmbH & Co. KG -// Licensed under the Apache License, Version 2.0 - using System.Collections.Generic; using System.Runtime.Serialization; using System.Linq; +using Moryx.Workflows.Implementation; namespace Moryx.Workplans { @@ -94,41 +92,45 @@ public static Workplan Restore(List connectors, List return new Workplan(connectors, steps); } - public static bool NoteSameFollowringSteps(Workplan workplan, Workplan newWorkplan ,IWorkplanStep step, IWorkplanStep newStep, List needToCheck, List newNeedToCheck, List isChecked) + public static bool CompareOutputs(ComparingProperties outputProperties) { - - for (int a = 0; a < step.Outputs.Length; a++) + + for (int a = 0; a < outputProperties.Step.Outputs.Length; a++) { - var connector = step.Outputs[a]; - var newConnector = newStep.Outputs[a]; + var connector = outputProperties.Step.Outputs[a]; + var newConnector = outputProperties.NewStep.Outputs[a]; - if (connector.Id == newConnector.Id) - { + bool isNotEndConnector = !(connector.Classification.Equals(NodeClassification.End)) && !(newConnector.Classification.Equals(NodeClassification.End)); + bool isNotFailedConnector = !(connector.Classification.Equals(NodeClassification.Failed)) && !(newConnector.Classification.Equals(NodeClassification.Failed)); - bool isNotEndConnector = !(connector.Classification.Equals(NodeClassification.End)) && !(newConnector.Classification.Equals(NodeClassification.End)); - bool isNotFailedConnector = !(connector.Classification.Equals(NodeClassification.Failed)) && !(newConnector.Classification.Equals(NodeClassification.Failed)); + if (isNotEndConnector && isNotFailedConnector) + { + var follower = outputProperties.Workplan.Steps.FirstOrDefault(x => x.Inputs.Any(y => y.Equals(connector))); + var newFollower = outputProperties.NewWorkplan.Steps.FirstOrDefault(x => x.Inputs.Any(y => y.Equals(newConnector))); - if (isNotEndConnector && isNotFailedConnector) + bool isSameStep = CompareSteps(follower, newFollower); + if (!isSameStep) { - var follower = workplan.Steps.FirstOrDefault(x => x.Inputs.Any(y => y.Equals(connector))); - var newFollower = newWorkplan.Steps.FirstOrDefault(x => x.Inputs.Any(y => y.Equals(newConnector))); + return false; + } - bool isAlreadyChecked = (isChecked.Contains(follower) || isChecked.Contains(newFollower)); + bool isAlreadyChecked = (outputProperties.IsChecked.Contains(follower)); - if (!(isAlreadyChecked)) - { - needToCheck.Add(follower); - newNeedToCheck.Add(newFollower); - } + if (!(isAlreadyChecked)) + { + outputProperties.NeedToCheck.Add(follower); + outputProperties.NewNeedToCheck.Add(newFollower); } } - else - { - return false; - } } return true; } + + public static bool CompareSteps(IWorkplanStep step1, IWorkplanStep step2) + { + return step1.GetType() == step2.GetType(); + } + /// /// Compare two workplans /// @@ -137,8 +139,8 @@ public static bool NoteSameFollowringSteps(Workplan workplan, Workplan newWorkpl /// public static bool Equals(Workplan workplan, Workplan newWorkplan) { - var step = workplan.Steps.First(x => x.Inputs.Any(y => y.Classification.Equals(NodeClassification.Start))); - var newStep = newWorkplan.Steps.First(x => x.Inputs.Any(y => y.Classification.Equals(NodeClassification.Start))); + var step = workplan.Steps.FirstOrDefault(x => x.Inputs.Any(y => y.Classification.Equals(NodeClassification.Start))); + var newStep = newWorkplan.Steps.FirstOrDefault(x => x.Inputs.Any(y => y.Classification.Equals(NodeClassification.Start))); List needToCheck = new List() { step }; List newNeedToCheck = new List() { newStep }; @@ -148,38 +150,32 @@ public static bool Equals(Workplan workplan, Workplan newWorkplan) while (needToCheck.Count != 0 && newNeedToCheck.Count != 0) { - bool isSameStep = (step.GetType() == newStep.GetType()); - if (isSameStep) + bool isSameStep = CompareSteps(step, newStep); + if (!isSameStep) { - - bool sameConnections = NoteSameFollowringSteps(workplan, newWorkplan, step, newStep, needToCheck, newNeedToCheck, isChecked); - if (sameConnections) - { - needToCheck.Remove(step); - newNeedToCheck.Remove(newStep); - - isChecked.Add(step); - - if (needToCheck.Count != 0 && newNeedToCheck.Count != 0) - { - step = needToCheck[0]; - newStep = newNeedToCheck[0]; - } - } - else - { - return false; - } + return false; } - else + var properties = new ComparingProperties() {Step = step, NewStep = newStep, Workplan = workplan, NewWorkplan = newWorkplan,IsChecked = isChecked, NeedToCheck = needToCheck, NewNeedToCheck = newNeedToCheck }; + bool sameConnections = CompareOutputs(properties); + if (!sameConnections) { return false; } + needToCheck.Remove(step); + newNeedToCheck.Remove(newStep); + + isChecked.Add(step); + + if (needToCheck.Count != 0 && newNeedToCheck.Count != 0) + { + step = needToCheck[0]; + newStep = newNeedToCheck[0]; + } + } return true; } - } } \ No newline at end of file