Fixing Work Instruction Update Logic by Not Calling the Part Node Resolver but instead resolving part definitions directly in the WorkInstructionUpdater

Author: EyeBrawler

MESS/MESS.Services/CRUD/WorkInstructions/WorkInstructionService.cs

@@ -824,9 +824,9 @@ public async Task<bool> UpdateWorkInstructionAsync(WorkInstructionFormDTO dto)
 
                 if (!await ValidateUniquenessAsync(dto, existing))
                     return false;
-
+                
                 await _workInstructionUpdater.ApplyAsync(dto, existing, context);
-
+                
                 await context.SaveChangesAsync();
                 await transaction.CommitAsync();
 

MESS/MESS.Services/CRUD/WorkInstructions/WorkInstructionUpdater.cs

@@ -24,21 +24,17 @@ namespace MESS.Services.CRUD.WorkInstructions;
 public class WorkInstructionUpdater : IWorkInstructionUpdater
 {
     private readonly IProductResolver _productResolver;
-    private readonly IPartNodeResolver _partNodeResolver;
     private readonly IPartDefinitionResolver _partDefinitionResolver;
 
     /// <summary>
     /// Initializes a new instance of the <see cref="WorkInstructionUpdater"/> class.
     /// </summary>
     /// <param name="productResolver">The service used for resolving products from product names.</param>
     /// <param name="partDefinitionResolver">The service used for resolving the part definition that a work instruction produces.</param>
-    /// <param name="partNodeResolver">The service used for resolving part nodes in a work instruction.</param>
-    public WorkInstructionUpdater(IProductResolver productResolver, IPartDefinitionResolver partDefinitionResolver,
-        IPartNodeResolver partNodeResolver)
+    public WorkInstructionUpdater(IProductResolver productResolver, IPartDefinitionResolver partDefinitionResolver)
     {
         _productResolver = productResolver;
         _partDefinitionResolver = partDefinitionResolver;
-        _partNodeResolver = partNodeResolver;
     }
 
     /// <summary>
@@ -91,9 +87,7 @@ public async Task ApplyAsync(
         await SyncPartProducedAsync(dto, entity, context);
         await SyncProductsAsync(dto, entity, context);
 
-        SyncNodes(dto.Nodes, entity, context);
-        
-        await _partNodeResolver.ResolvePendingNodesAsync(context, entity.Nodes);
+        await SyncNodes(dto.Nodes, entity, context);
     }
 
     private void ApplyScalars(WorkInstructionFormDTO dto, WorkInstruction entity)
@@ -113,7 +107,7 @@ private async Task SyncProductsAsync(
         entity.Products = await _productResolver.ResolveProductsAsync(context, dto.ProductNames);
     }
 
-    private void SyncNodes(
+    private async Task SyncNodes(
         List<WorkInstructionNodeFormDTO> formNodes,
         WorkInstruction entity,
         ApplicationContext context)
@@ -138,11 +132,11 @@ private void SyncNodes(
         {
             if (dto.Id != 0 && existingById.TryGetValue(dto.Id, out var existing))
             {
-                ApplyToExisting(dto, existing);
+                await ApplyToExistingAsync(dto, existing, context);
             }
             else
             {
-                var newNode = CreateNew(dto);
+                var newNode = await CreateNewAsync(dto, context);
                 entity.Nodes.Add(newNode);
             }
         }
@@ -179,9 +173,10 @@ private async Task SyncPartProducedAsync(
             null);
     }
 
-    private void ApplyToExisting(
+    private async Task ApplyToExistingAsync(
         WorkInstructionNodeFormDTO dto,
-        WorkInstructionNode entity)
+        WorkInstructionNode entity,
+        ApplicationContext context)
     {
         entity.Position = dto.Position;
 
@@ -192,15 +187,17 @@ private void ApplyToExisting(
                 break;
 
             case PartNodeFormDTO partDto when entity is PartNode part:
-                ApplyPartNode(partDto, part);
+                await ApplyPartNodeAsync(partDto, part, context);
                 break;
 
             default:
                 throw new InvalidOperationException("Node type mismatch.");
         }
     }
 
-    private WorkInstructionNode CreateNew(WorkInstructionNodeFormDTO dto)
+    private async Task<WorkInstructionNode> CreateNewAsync(
+        WorkInstructionNodeFormDTO dto,
+        ApplicationContext context)
     {
         return dto switch
         {
@@ -215,7 +212,7 @@ private WorkInstructionNode CreateNew(WorkInstructionNodeFormDTO dto)
                 SecondaryMedia = stepDto.SecondaryMedia.ToList()
             },
 
-            PartNodeFormDTO partDto => CreatePartNode(partDto),
+            PartNodeFormDTO partDto => await CreatePartNodeAsync(partDto, context),
 
             _ => throw new NotSupportedException()
         };
@@ -231,34 +228,42 @@ private void ApplyStep(StepNodeFormDTO dto, Step entity)
         entity.SecondaryMedia = dto.SecondaryMedia.ToList();
     }
 
-    private void ApplyPartNode(PartNodeFormDTO dto, PartNode entity)
+    private async Task ApplyPartNodeAsync(
+        PartNodeFormDTO dto,
+        PartNode entity,
+        ApplicationContext context)
     {
         entity.InputType = dto.InputType;
 
-        // Store part info in a "pending resolution" way
-        entity.PartDefinitionId = 0; // Leave FK unset
-        entity.PartDefinition = new PartDefinition
-        {
-            Name = dto.Name,
-            Number = dto.Number
-        };
+        var part = await _partDefinitionResolver.ResolveAsync(
+                       context,
+                       dto.Name,
+                       dto.Number)
+                   ?? throw new InvalidOperationException(
+                       $"Failed to resolve PartDefinition '{dto.Name}' '{dto.Number}'.");
+
+        entity.PartDefinitionId = part.Id;
+        entity.PartDefinition = part;
     }
 
-    private PartNode CreatePartNode(PartNodeFormDTO partDto)
+    private async Task<PartNode> CreatePartNodeAsync(
+        PartNodeFormDTO dto,
+        ApplicationContext context)
     {
+        var part = await _partDefinitionResolver.ResolveAsync(
+                       context,
+                       dto.Name,
+                       dto.Number)
+                   ?? throw new InvalidOperationException(
+                       $"Failed to resolve PartDefinition '{dto.Name}' '{dto.Number}'.");
+
         return new PartNode
         {
             NodeType = WorkInstructionNodeType.Part,
-            Position = partDto.Position,
-            InputType = partDto.InputType,
-
-            // Store part info without FK; will be resolved later
-            PartDefinitionId = 0,
-            PartDefinition = new PartDefinition
-            {
-                Name = partDto.Name,
-                Number = partDto.Number
-            }
+            Position = dto.Position,
+            InputType = dto.InputType,
+            PartDefinitionId = part.Id,
+            PartDefinition = part
         };
     }
 }