Removed report from operation interrupt behaviour

dbeuchler · dbeuchler · commit 52d6c1fe25d6 · 2025-11-06T14:57:43.000+01:00
diff --git a/docs/migrations/v8_to_v10.md b/docs/migrations/v8_to_v10.md
@@ -64,3 +64,7 @@ These feature were infrequently used and has been removed to simplify the codeba
 
 - Moryx.Tools.FunctionResult: Moved to Moryx.Tools
 - Moryx.AbstractionLayer namespace: All classes have been moved to more specific domain namespaces e.g. Moryx.AbstractionLayer.Resources, Moryx.AbstractionLayer.Products, Moryx.AbstractionLayer.Processes etc.
+
+## Modules-Orders
+
+- Removed report from interrupt of an operation. Reporting during an interruption doesn't add any value. The quantity for the report can only be predicted and will be inaccurate if something goes wrong or is reworked during the interruption.
diff --git a/src/Moryx.Orders.Endpoints/OrderManagementController.cs b/src/Moryx.Orders.Endpoints/OrderManagementController.cs
@@ -68,7 +68,7 @@ public async Task OperationStream(CancellationToken cancelToken)
             var updateEventHandler = new EventHandler<OperationChangedEventArgs>((_, eventArgs) =>
             {
                 var json = JsonConvert.SerializeObject(Converter.ToModel(eventArgs.Operation), _serializerSettings);
-                operationsChannel.Writer.TryWrite(new Tuple<string, string>(OperationTypes.Update.ToString(), json));
+                operationsChannel.Writer.TryWrite(new Tuple<string, string>(nameof(OperationTypes.Update), json));
             });
             _orderManagement.OperationUpdated += updateEventHandler;
 
@@ -80,7 +80,7 @@ public async Task OperationStream(CancellationToken cancelToken)
                     Advice = Converter.ToModel(eventArgs.Advice)
                 };
                 var json = JsonConvert.SerializeObject(advicedOperation, _serializerSettings);
-                operationsChannel.Writer.TryWrite(new Tuple<string, string>(OperationTypes.Advice.ToString(), json));
+                operationsChannel.Writer.TryWrite(new Tuple<string, string>(nameof(OperationTypes.Advice), json));
             });
             _orderManagement.OperationAdviced += adviceEventHandler;
 
@@ -92,19 +92,14 @@ public async Task OperationStream(CancellationToken cancelToken)
                     Report = Converter.ToModel(eventArgs.Report)
                 };
                 var json = JsonConvert.SerializeObject(reportedOperation, _serializerSettings);
-                operationsChannel.Writer.TryWrite(new Tuple<string, string>(OperationTypes.Report.ToString(), json));
+                operationsChannel.Writer.TryWrite(new Tuple<string, string>(nameof(OperationTypes.Report), json));
             });
             _orderManagement.OperationPartialReport += reportEventHandler;
 
-            var interruptedEventHandler = new EventHandler<OperationReportEventArgs>((_, eventArgs) =>
+            var interruptedEventHandler = new EventHandler<OperationChangedEventArgs>((_, eventArgs) =>
             {
-                var interruptedOperation = new OperationReportedModel
-                {
-                    OperationModel = Converter.ToModel(eventArgs.Operation),
-                    Report = Converter.ToModel(eventArgs.Report)
-                };
-                var json = JsonConvert.SerializeObject(interruptedOperation, _serializerSettings);
-                operationsChannel.Writer.TryWrite(new Tuple<string, string>(OperationTypes.Interrupted.ToString(), json));
+                var json = JsonConvert.SerializeObject(Converter.ToModel(eventArgs.Operation), _serializerSettings);
+                operationsChannel.Writer.TryWrite(new Tuple<string, string>(nameof(OperationTypes.Interrupted), json));
             });
             _orderManagement.OperationInterrupted += interruptedEventHandler;
 
@@ -116,7 +111,7 @@ public async Task OperationStream(CancellationToken cancelToken)
                     Report = Converter.ToModel(eventArgs.Report)
                 };
                 var json = JsonConvert.SerializeObject(completedOperation, _serializerSettings);
-                operationsChannel.Writer.TryWrite(new Tuple<string, string>(OperationTypes.Completed.ToString(), json));
+                operationsChannel.Writer.TryWrite(new Tuple<string, string>(nameof(OperationTypes.Completed), json));
             });
             _orderManagement.OperationCompleted += completedEventHandler;
 
@@ -128,14 +123,14 @@ public async Task OperationStream(CancellationToken cancelToken)
                     UserId = eventArgs.User.Identifier
                 };
                 var json = JsonConvert.SerializeObject(startedOperation, _serializerSettings);
-                operationsChannel.Writer.TryWrite(new Tuple<string, string>(OperationTypes.Start.ToString(), json));
+                operationsChannel.Writer.TryWrite(new Tuple<string, string>(nameof(OperationTypes.Start), json));
             });
             _orderManagement.OperationStarted += startedEventHandler;
 
             var changedEventHandler = new EventHandler<OperationChangedEventArgs>((_, eventArgs) =>
             {
                 var json = JsonConvert.SerializeObject(Converter.ToModel(eventArgs.Operation), _serializerSettings);
-                operationsChannel.Writer.TryWrite(new Tuple<string, string>(OperationTypes.Progress.ToString(), json));
+                operationsChannel.Writer.TryWrite(new Tuple<string, string>(nameof(OperationTypes.Progress), json));
             });
             _orderManagement.OperationProgressChanged += changedEventHandler;
 
@@ -424,13 +419,13 @@ public ActionResult ReportOperation(Guid guid, ReportModel report)
         [ProducesResponseType(typeof(MoryxExceptionResponse), StatusCodes.Status404NotFound)]
         [Route("{guid}/interrupt")]
         [Authorize(Policy = OrderPermissions.CanInterrupt)]
-        public ActionResult InterruptOperation(Guid guid, ReportModel report)
+        public ActionResult InterruptOperation(Guid guid)
         {
             var operation = _orderManagement.GetOperation(guid);
             if (operation == null)
                 return NotFound(new MoryxExceptionResponse { Title = Strings.OrderManagementController_OperationNotFound });
 
-            _orderManagement.InterruptOperation(operation, Converter.FromModel(report, _userManagement));
+            _orderManagement.InterruptOperation(operation);
             return Ok();
         }
 
diff --git a/src/Moryx.Orders.Management/Components/IOperationData.cs b/src/Moryx.Orders.Management/Components/IOperationData.cs
@@ -139,7 +139,7 @@ internal interface IOperationData
         /// <summary>
         /// Disables an operation which leads to complete all jobs
         /// </summary>
-        void Interrupt(OperationReport report);
+        void Interrupt();
 
         /// <summary>
         /// Will do a report for the operation.
@@ -195,7 +195,7 @@ internal interface IOperationData
         /// <summary>
         /// Raised if the operation was interrupted
         /// </summary>
-        event EventHandler<ReportEventArgs> Interrupted;
+        event EventHandler<OperationEventArgs> Interrupted;
 
         /// <summary>
         /// Raised if the operation was completed
diff --git a/src/Moryx.Orders.Management/Facade/OrderManagementFacade.cs b/src/Moryx.Orders.Management/Facade/OrderManagementFacade.cs
@@ -66,9 +66,9 @@ private void OnOperationStarted(object sender, StartedEventArgs e)
             OperationStarted?.Invoke(this, new OperationStartedEventArgs(e.OperationData.Operation, e.User));
         }
 
-        private void OnOperationInterrupted(object sender, ReportEventArgs e)
+        private void OnOperationInterrupted(object sender, OperationEventArgs e)
         {
-            OperationInterrupted?.Invoke(this, new OperationReportEventArgs(e.OperationData.Operation, e.Report));
+            OperationInterrupted?.Invoke(this, new OperationChangedEventArgs(e.OperationData.Operation));
         }
 
         private void OnOperationCompleted(object sender, ReportEventArgs e)
@@ -257,15 +257,12 @@ public ReportContext GetInterruptContext(Operation operation)
             return OperationManager.GetInterruptContext(operationData);
         }
 
-        public void InterruptOperation(Operation operation, OperationReport report)
+        public void InterruptOperation(Operation operation)
         {
             ValidateHealthState();
 
-            // Get default user if there is no in the report
-            report.User ??= UserManagement.DefaultUser;
-
             var operationData = GetOperationDataSave(operation);
-            OperationManager.Interrupt(operationData, report);
+            OperationManager.Interrupt(operationData);
         }
 
         private IOperationData GetOperationDataSave(Operation operation)
@@ -332,7 +329,7 @@ public Task<IReadOnlyList<IProductRecipe>> GetAssignableRecipes(ProductIdentity
 
         public event EventHandler<OperationReportEventArgs> OperationCompleted;
 
-        public event EventHandler<OperationReportEventArgs> OperationInterrupted;
+        public event EventHandler<OperationChangedEventArgs> OperationInterrupted;
 
         public event EventHandler<OperationReportEventArgs> OperationPartialReport;
 
diff --git a/src/Moryx.Orders.Management/Implementation/OperationData/OperationData.cs b/src/Moryx.Orders.Management/Implementation/OperationData/OperationData.cs
@@ -421,41 +421,32 @@ internal void HandleStarted(User user)
         }
 
         /// <inheritdoc cref="IOperationData"/>
-        public void Interrupt(OperationReport report)
+        public void Interrupt()
         {
-            Log(LogLevel.Debug, "Operation will be interrupted with SuccessCount {0} and FailureCount {1} by user {2}",
-                report.SuccessCount, report.FailureCount, report.User.Identifier);
+            Log(LogLevel.Debug, "Operation will be interrupted");
 
             lock (_stateLock)
-                _state.Interrupt(report);
+                _state.Interrupt();
         }
 
         /// <summary>
         /// Will complete all jobs and executes a partial report
         /// </summary>
-        internal void HandleManualInterrupting(OperationReport report)
+        internal void HandleManualInterrupting()
         {
             JobHandler.Complete(this);
-            HandlePartialReport(report);
         }
 
         /// <summary>
         /// Will handle manual interrupts. The interrupt was triggered by the user.
         /// Will throw the <see cref="Interrupted"/> event
         /// </summary>
-        internal void HandleManualInterrupted(OperationReport report)
+        internal void HandleManualInterrupted()
         {
             Operation.TargetAmount = ReachableAmount;
 
-            lock (_reports)
-            {
-                _reports.Add(report);
-                Operation.Reports = _reports.ToArray();
-
-            }
-
             Updated?.Invoke(this, new OperationEventArgs(this));
-            Interrupted?.Invoke(this, new ReportEventArgs(this, report));
+            Interrupted?.Invoke(this, new OperationEventArgs(this));
         }
 
         /// <summary>
@@ -466,19 +457,8 @@ internal void HandleInterrupted()
         {
             Operation.TargetAmount = ReachableAmount;
 
-            // Add report for interrupted with user which have started the interruption
-            OperationReport report;
-            lock (_reports)
-            {
-                var lastReportUser = Operation.Reports.Last().User;
-                report = new OperationReport(ConfirmationType.Partial, 0, 0, lastReportUser);
-
-                _reports.Add(report);
-                Operation.Reports = _reports.ToArray();
-            }
-
             Updated?.Invoke(this, new OperationEventArgs(this));
-            Interrupted?.Invoke(this, new ReportEventArgs(this, report));
+            Interrupted?.Invoke(this, new OperationEventArgs(this));
         }
 
         /// <inheritdoc cref="IOperationData"/>
@@ -757,7 +737,7 @@ private TInfo GetOperationInfo<TInfo>()
         public event EventHandler<StartedEventArgs> Started;
 
         /// <inheritdoc cref="IOperationData.Interrupted"/>
-        public event EventHandler<ReportEventArgs> Interrupted;
+        public event EventHandler<OperationEventArgs> Interrupted;
 
         /// <inheritdoc cref="IOperationData.Completed"/>
         public event EventHandler<ReportEventArgs> Completed;
diff --git a/src/Moryx.Orders.Management/Implementation/OperationData/States/AmountReachedState.cs b/src/Moryx.Orders.Management/Implementation/OperationData/States/AmountReachedState.cs
@@ -54,21 +54,10 @@ public override void IncreaseTargetBy(int amount, User user)
             Context.HandleIncreaseTargetBy(amount);
         }
 
-        public override void Interrupt(OperationReport report)
+        public override void Interrupt()
         {
-            switch (report.ConfirmationType)
-            {
-                case ConfirmationType.Final:
-                    NextState(StateCompleted);
-                    Context.HandleCompleted(report);
-                    break;
-                case ConfirmationType.Partial:
-                    NextState(StateInterrupted);
-                    Context.HandleManualInterrupted(report);
-                    break;
-                default:
-                    throw new ArgumentOutOfRangeException(nameof(report.ConfirmationType), report.ConfirmationType, null);
-            }
+            NextState(StateInterrupted);
+            Context.HandleManualInterrupted();
         }
 
         public override ReportContext GetReportContext()
diff --git a/src/Moryx.Orders.Management/Implementation/OperationData/States/OperationDataStateBase.cs b/src/Moryx.Orders.Management/Implementation/OperationData/States/OperationDataStateBase.cs
@@ -72,7 +72,7 @@ public virtual AdviceContext GetAdviceContext()
             return null;
         }
 
-        public virtual void Interrupt(OperationReport report) => InvalidState();
+        public virtual void Interrupt() => InvalidState();
 
         public virtual void Report(OperationReport report) => InvalidState();
 
diff --git a/src/Moryx.Orders.Management/Implementation/OperationData/States/RunningState.cs b/src/Moryx.Orders.Management/Implementation/OperationData/States/RunningState.cs
@@ -34,21 +34,10 @@ public override void IncreaseTargetBy(int amount, User user)
         public override void DecreaseTargetBy(int amount, User user)
             => Context.HandleDecreaseTargetBy(amount);
 
-        public override void Interrupt(OperationReport report)
+        public override void Interrupt()
         {
-            switch (report.ConfirmationType)
-            {
-                case ConfirmationType.Partial:
-                    NextState(StateInterrupting);
-                    Context.HandleManualInterrupting(report);
-                    break;
-                case ConfirmationType.Final:
-                    // ReSharper disable once ExplicitCallerInfoArgument
-                    InvalidState(nameof(Report) + "(final)");
-                    break;
-                default:
-                    throw new ArgumentOutOfRangeException();
-            }
+            NextState(StateInterrupting);
+            Context.HandleManualInterrupting();
         }
 
         public override ReportContext GetReportContext()
diff --git a/src/Moryx.Orders.Management/Implementation/OperationManager/IOperationManager.cs b/src/Moryx.Orders.Management/Implementation/OperationManager/IOperationManager.cs
@@ -45,7 +45,7 @@ internal interface IOperationManager
         /// <summary>
         /// Interrupts the given operation
         /// </summary>
-        void Interrupt(IOperationData operationData, OperationReport report);
+        void Interrupt(IOperationData operationData);
 
         /// <summary>
         /// Aborts the given operation
diff --git a/src/Moryx.Orders.Management/Implementation/OperationManager/OperationManager.cs b/src/Moryx.Orders.Management/Implementation/OperationManager/OperationManager.cs
@@ -155,12 +155,9 @@ public void Report(IOperationData operationData, OperationReport report)
         }
 
         /// <inheritdoc />
-        public void Interrupt(IOperationData operationData, OperationReport report)
+        public void Interrupt(IOperationData operationData)
         {
-            if (!report.User.SignedIn)
-                throw new InvalidOperationException("User for the interrupt of the operation was not signed in.");
-
-            operationData.Interrupt(report);
+            operationData.Interrupt();
         }
 
         /// <inheritdoc />
diff --git a/src/Moryx.Orders.Management/Implementation/Pool/IOperationDataPool.cs b/src/Moryx.Orders.Management/Implementation/Pool/IOperationDataPool.cs
@@ -68,7 +68,7 @@ internal interface IOperationDataPool : IPlugin
         /// <summary>
         /// Raised if an operation was interrupted
         /// </summary>
-        event EventHandler<ReportEventArgs> OperationInterrupted;
+        event EventHandler<OperationEventArgs> OperationInterrupted;
 
         /// <summary>
         /// Raised if an operation was partially reported
diff --git a/src/Moryx.Orders.Management/Implementation/Pool/OperationDataPool.cs b/src/Moryx.Orders.Management/Implementation/Pool/OperationDataPool.cs
@@ -351,8 +351,8 @@ private void OnOperationStarted(object sender, StartedEventArgs eventArgs)
         private void OnOperationCompleted(object sender, ReportEventArgs eventArgs)
             => OperationCompleted?.Invoke(this, eventArgs);
 
-        public event EventHandler<ReportEventArgs> OperationInterrupted;
-        private void OnOperationInterrupted(object sender, ReportEventArgs eventArgs)
+        public event EventHandler<OperationEventArgs> OperationInterrupted;
+        private void OnOperationInterrupted(object sender, OperationEventArgs eventArgs)
             => OperationInterrupted?.Invoke(this, eventArgs);
 
         public event EventHandler<ReportEventArgs> OperationPartialReport;
diff --git a/src/Moryx.Orders/Facade/IOrderManagement.cs b/src/Moryx.Orders/Facade/IOrderManagement.cs
@@ -82,7 +82,7 @@ public interface IOrderManagement
         /// <summary>
         /// Processes a interrupt for the given operation
         /// </summary>
-        void InterruptOperation(Operation operation, OperationReport report);
+        void InterruptOperation(Operation operation);
 
         /// <summary>
         /// Updates the operation source
@@ -107,7 +107,7 @@ public interface IOrderManagement
         /// <summary>
         /// Will be raised if an operation was interrupted
         /// </summary>
-        event EventHandler<OperationReportEventArgs> OperationInterrupted;
+        event EventHandler<OperationChangedEventArgs> OperationInterrupted;
 
         /// <summary>
         /// Will be raised if an operation was partially reported
@@ -146,7 +146,7 @@ public interface IOrderManagement
         AdviceContext GetAdviceContext(Operation operation);
 
         /// <summary>
-        /// Tries to advise the <see cref="Operation"/>. 
+        /// Tries to advise the <see cref="Operation"/>.
         /// The returned advice result contains information regarding the successful or unsuccessful attempt.
         /// </summary>
         /// <param name="operation">The <see cref="Operation"/> to advice.</param>
diff --git a/src/Tests/Moryx.Orders.Management.Tests/Integration/ProductionTests.cs b/src/Tests/Moryx.Orders.Management.Tests/Integration/ProductionTests.cs
@@ -192,7 +192,7 @@ public void SetUp()
         }
 
         [Test(Description = "Runs a full production of a operation. At the end, a final report will be executed.")]
-        [Ignore("This test takes very long and should be moved into an integration test.")]
+        [Ignore("This test takes very long should be fixed!")]
         public void SimpleCompletedProduction()
         {
             const int amount = 10;
diff --git a/src/Tests/Moryx.Orders.Management.Tests/OperationData/OperationDataProductionTests.cs b/src/Tests/Moryx.Orders.Management.Tests/OperationData/OperationDataProductionTests.cs
diff --git a/src/Tests/Moryx.Orders.Management.Tests/OperationData/OperationDataReportTests.cs b/src/Tests/Moryx.Orders.Management.Tests/OperationData/OperationDataReportTests.cs
diff --git a/src/Tests/Moryx.Orders.Management.Tests/OperationData/OperationDataTestBase.cs b/src/Tests/Moryx.Orders.Management.Tests/OperationData/OperationDataTestBase.cs

Original file line number	Diff line number	Diff line change
`@@ -66,9 +66,9 @@ private void OnOperationStarted(object sender, StartedEventArgs e)`
`66`	`66`	`OperationStarted?.Invoke(this, new OperationStartedEventArgs(e.OperationData.Operation, e.User));`
`67`	`67`	`}`
`68`	`68`
`69`		`- private void OnOperationInterrupted(object sender, ReportEventArgs e)`
	`69`	`+ private void OnOperationInterrupted(object sender, OperationEventArgs e)`
`70`	`70`	`{`
`71`		`- OperationInterrupted?.Invoke(this, new OperationReportEventArgs(e.OperationData.Operation, e.Report));`
	`71`	`+ OperationInterrupted?.Invoke(this, new OperationChangedEventArgs(e.OperationData.Operation));`
`72`	`72`	`}`
`73`	`73`
`74`	`74`	`private void OnOperationCompleted(object sender, ReportEventArgs e)`
`@@ -257,15 +257,12 @@ public ReportContext GetInterruptContext(Operation operation)`
`257`	`257`	`return OperationManager.GetInterruptContext(operationData);`
`258`	`258`	`}`
`259`	`259`
`260`		`- public void InterruptOperation(Operation operation, OperationReport report)`
	`260`	`+ public void InterruptOperation(Operation operation)`
`261`	`261`	`{`
`262`	`262`	`ValidateHealthState();`
`263`	`263`
`264`		`- // Get default user if there is no in the report`
`265`		`- report.User ??= UserManagement.DefaultUser;`
`266`		`-`
`267`	`264`	`var operationData = GetOperationDataSave(operation);`
`268`		`- OperationManager.Interrupt(operationData, report);`
	`265`	`+ OperationManager.Interrupt(operationData);`
`269`	`266`	`}`
`270`	`267`
`271`	`268`	`private IOperationData GetOperationDataSave(Operation operation)`
`@@ -332,7 +329,7 @@ public Task<IReadOnlyList<IProductRecipe>> GetAssignableRecipes(ProductIdentity`
`332`	`329`
`333`	`330`	`public event EventHandler<OperationReportEventArgs> OperationCompleted;`
`334`	`331`
`335`		`- public event EventHandler<OperationReportEventArgs> OperationInterrupted;`
	`332`	`+ public event EventHandler<OperationChangedEventArgs> OperationInterrupted;`
`336`	`333`
`337`	`334`	`public event EventHandler<OperationReportEventArgs> OperationPartialReport;`
`338`	`335`
Original file line number	Diff line number	Diff line change
`@@ -72,7 +72,7 @@ public virtual AdviceContext GetAdviceContext()`
`72`	`72`	`return null;`
`73`	`73`	`}`
`74`	`74`
`75`		`- public virtual void Interrupt(OperationReport report) => InvalidState();`
	`75`	`+ public virtual void Interrupt() => InvalidState();`
`76`	`76`
`77`	`77`	`public virtual void Report(OperationReport report) => InvalidState();`
`78`	`78`
Original file line number	Diff line number	Diff line change
`@@ -155,12 +155,9 @@ public void Report(IOperationData operationData, OperationReport report)`
`155`	`155`	`}`
`156`	`156`
`157`	`157`	`/// <inheritdoc />`
`158`		`- public void Interrupt(IOperationData operationData, OperationReport report)`
	`158`	`+ public void Interrupt(IOperationData operationData)`
`159`	`159`	`{`
`160`		`- if (!report.User.SignedIn)`
`161`		`- throw new InvalidOperationException("User for the interrupt of the operation was not signed in.");`
`162`		`-`
`163`		`- operationData.Interrupt(report);`
	`160`	`+ operationData.Interrupt();`
`164`	`161`	`}`
`165`	`162`
`166`	`163`	`/// <inheritdoc />`