reduce code duplications

Author: usavkov-epam

lib/utils/HoldingsAbandonmentAnalyzer/strategies/BaseStrategy.js

@@ -53,40 +53,83 @@ export class HoldingsAbandonmentBaseStrategy {
 
   /**
    * Helper to build standardized result object for a holding
-   * Handles tenantId extraction, explain mode, and result structure
+   * Handles abandonment logic, tenantId extraction, explain mode, and result structure
    *
    * @param {Object} params - Parameters for building result
-   * @param {boolean} params.abandoned - Whether the holding is abandoned
+   * @param {string} [params.actionType] - Optional action type for the operation
    * @param {boolean} params.explain - Whether to include detailed explanation
-   * @param {Object} [params.explainData] - Optional explain data (cleared, remaining, related, actionType)
    * @param {string} params.holdingId - The holding ID
    * @param {Array} params.items - All items in the holding
+   * @param {Array} params.itemsToClear - Items to be cleared
    * @param {Array} params.pieces - All pieces in the holding
+   * @param {Array} params.piecesToClear - Pieces to be cleared
+   * @param {Array} params.poLines - All PO lines in the holding
+   * @param {Array} params.poLinesToClear - PO lines to be cleared
+   * @param {Array} params.remainingItems - Remaining items
+   * @param {Array} params.remainingPieces - Remaining pieces
+   * @param {Array} params.remainingPoLines - Remaining PO lines
    * @returns {Object} Standardized result object
    */
   static buildResult({
-    abandoned,
+    actionType,
     explain,
-    explainData,
     holdingId,
     items,
+    itemsToClear,
     pieces,
+    piecesToClear,
+    poLines,
+    poLinesToClear,
+    remainingItems,
+    remainingPieces,
+    remainingPoLines,
   }) {
+    // Determine if holding is abandoned
+    const abandoned = (
+      remainingPieces.length === 0 &&
+      remainingItems.length === 0 &&
+      remainingPoLines.length === 0
+    );
+
     // Extract tenantId from pieces or items (optional field)
     // Try pieces first, then items
-    const tenantId = pieces.find((p) => p.tenantId)?.tenantId
-      || items.find((i) => i.tenantId)?.tenantId;
+    const tenantId = (
+      pieces.find((p) => p.tenantId)?.tenantId
+      || items.find((i) => i.tenantId)?.tenantId
+    );
 
     const result = {
-      id: holdingId,
       abandoned,
+      id: holdingId,
     };
 
     if (tenantId) {
       result.tenantId = tenantId;
     }
 
-    if (explain && explainData) {
+    if (explain) {
+      const explainData = {
+        cleared: {
+          items: itemsToClear.map((i) => i.id),
+          pieces: piecesToClear.map((p) => p.id),
+          poLines: poLinesToClear.map((pl) => pl.id),
+        },
+        related: {
+          items: items.map((i) => i.id),
+          pieces: pieces.map((p) => p.id),
+          poLines: poLines.map((pl) => pl.id),
+        },
+        remaining: {
+          items: remainingItems.map((i) => i.id),
+          pieces: remainingPieces.map((p) => p.id),
+          poLines: remainingPoLines.map((pl) => pl.id),
+        },
+      };
+
+      if (actionType) {
+        explainData.actionType = actionType;
+      }
+
       result.explain = explainData;
     }
 

lib/utils/HoldingsAbandonmentAnalyzer/strategies/PieceStrategy.js

@@ -149,41 +149,18 @@ export class HoldingsAbandonmentPieceStrategy extends HoldingsAbandonmentBaseStr
 
       const remainingPoLines = baseRemainingPoLines.concat(incomingPoLines);
 
-      const abandoned = (
-        remainingPieces.length === 0 &&
-        remainingItems.length === 0 &&
-        remainingPoLines.length === 0
-      );
-
-      const explainData = (
-        explain
-          ? {
-            cleared: {
-              items: items.filter((i) => closure.items.has(i.id)).map((i) => i.id),
-              pieces: piecesToClear.map((p) => p.id),
-              poLines: Array.from(poLinesToClearSet),
-            },
-            related: {
-              items: items.map((i) => i.id),
-              pieces: pieces.map((p) => p.id),
-              poLines: poLines.map((pl) => pl.id),
-            },
-            remaining: {
-              items: remainingItems.map((i) => i.id),
-              pieces: remainingPieces.map((p) => p.id),
-              poLines: remainingPoLines.map((pl) => pl.id),
-            },
-          }
-          : undefined
-      );
-
       return this.buildResult({
+        explain,
         holdingId,
-        abandoned,
-        pieces,
         items,
-        explain,
-        explainData,
+        itemsToClear: items.filter((i) => closure.items.has(i.id)),
+        pieces,
+        piecesToClear,
+        poLines,
+        poLinesToClear: Array.from(poLinesToClearSet).map((id) => ({ id })),
+        remainingItems,
+        remainingPieces,
+        remainingPoLines,
       });
     });
   }

lib/utils/HoldingsAbandonmentAnalyzer/strategies/PoLineStrategy.js

@@ -106,43 +106,19 @@ export class HoldingsAbandonmentPOLineStrategy extends HoldingsAbandonmentBaseSt
       const remainingItems = items.filter((i) => !itemsToClear.some((ci) => ci.id === i.id));
       const remainingPoLines = poLines.filter((pl) => !closure.poLines.has(pl.id));
 
-      // Holding is abandoned if nothing remains
-      const abandoned = (
-        remainingPieces.length === 0 &&
-        remainingItems.length === 0 &&
-        remainingPoLines.length === 0
-      );
-
-      const explainData = (
-        explain
-          ? {
-            actionType,
-            cleared: {
-              items: itemsToClear.map((i) => i.id),
-              pieces: piecesToClear.map((p) => p.id),
-              poLines: poLinesToClear.map((pl) => pl.id),
-            },
-            related: {
-              items: items.map((i) => i.id),
-              pieces: pieces.map((p) => p.id),
-              poLines: poLines.map((pl) => pl.id),
-            },
-            remaining: {
-              items: remainingItems.map((i) => i.id),
-              pieces: remainingPieces.map((p) => p.id),
-              poLines: remainingPoLines.map((pl) => pl.id),
-            },
-          }
-          : undefined
-      );
-
       return this.buildResult({
+        actionType,
+        explain,
         holdingId,
-        abandoned,
-        pieces,
         items,
-        explain,
-        explainData,
+        itemsToClear,
+        pieces,
+        piecesToClear,
+        poLines,
+        poLinesToClear,
+        remainingItems,
+        remainingPieces,
+        remainingPoLines,
       });
     });
   }