tango-app-api-store-builder 1.1.14 → 1.1.15

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "tango-app-api-store-builder",
-    "version": "1.1.14",
+    "version": "1.1.15",
     "description": "storeBuilder",
     "main": "index.js",
     "type": "module",
@@ -33,7 +33,7 @@
         "path": "^0.12.7",
         "selenium-webdriver": "^4.31.0",
         "sharp": "^0.34.1",
-        "tango-api-schema": "^2.5.45",
+        "tango-api-schema": "^2.5.49",
         "tango-app-api-middleware": "3.1.48",
         "url": "^0.11.4",
         "winston": "^3.17.0",

package/src/controllers/planoAI.controller.js

@@ -10,6 +10,7 @@ import * as storeBuilderService from '../service/storeBuilder.service.js';
 import * as planoRevisionService from '../service/planoRevision.service.js';
 import * as storeBuilderController from './storeBuilder.controller.js';
 import * as taskController from './task.controller.js';
+import * as processedService from '../service/processedTaskservice.js';
 import mongoose from 'mongoose';
 import fetch from 'node-fetch';
 import fs from 'fs';
@@ -1673,6 +1674,9 @@ export async function approveReplace( req, res ) {
       skipped: [],
     };
 
+    // Map to track task IDs for each store
+    const storeTaskIds = new Map();
+
     for ( const store of storesToProcess ) {
       try {
         const replaceResponseData = store.replaceResponseData;
@@ -1833,11 +1837,27 @@ export async function approveReplace( req, res ) {
                     body: taskPayload,
                     user: req.user || {},
                   };
+                  let taskId = null;
                   const mockTaskRes = {
-                    sendSuccess: () => {},
+                    sendSuccess: ( data ) => {
+                      taskId = data?.taskId || null;
+                    },
                     sendError: () => {},
                   };
                   await taskController.createTask( mockTaskReq, mockTaskRes );
+                  
+                  // Store the task ID based on the checklist name
+                  if ( taskId ) {
+                    if ( !storeTaskIds.has( store.storeName ) ) {
+                      storeTaskIds.set( store.storeName, { merchRolloutId: null, vmRolloutId: null } );
+                    }
+                    const taskIds = storeTaskIds.get( store.storeName );
+                    if ( taskPayload.checkListName === 'Merchandise Rollout' ) {
+                      taskIds.merchRolloutId = taskId;
+                    } else if ( taskPayload.checkListName === 'Visual Merch Rollout' ) {
+                      taskIds.vmRolloutId = taskId;
+                    }
+                  }
                 }
               } else {
                 logger.info( { 
@@ -1873,6 +1893,25 @@ export async function approveReplace( req, res ) {
       }
     }
 
+    // Update stores in findReplaceDoc with task IDs
+    const updatedStores = findReplaceDoc.stores.map( ( store ) => {
+      const taskIds = storeTaskIds.get( store.storeName );
+      if ( taskIds ) {
+        return {
+          ...store,
+          merchRolloutId: taskIds.merchRolloutId || store.merchRolloutId,
+          vmRolloutId: taskIds.vmRolloutId || store.vmRolloutId,
+        };
+      }
+      return store;
+    } );
+
+    // Update findReplaceAiModel with task IDs
+    await findReplaceAiService.updateOne(
+        { _id: findReplaceId },
+        { stores: updatedStores },
+    );
+
     const allStoresProcessed = storesToProcess.length === results.success.length + results.failed.length + results.skipped.length;
     if ( allStoresProcessed ) {
       await findReplaceAiService.updateOne(
@@ -1897,6 +1936,119 @@ export async function approveReplace( req, res ) {
   }
 }
 
+export async function processScheduledFindReplace( req, res ) {
+  try {
+    const today = dayjs();
+    const startOfDay = today.startOf( 'day' ).toDate();
+    const endOfDay = today.endOf( 'day' ).toDate();
+
+    // Find all scheduled entries for today
+    const scheduledEntries = await findReplaceAiService.find( {
+      schedule: true,
+      scheduleDate: {
+        $gte: startOfDay,
+        $lte: endOfDay,
+      },
+      status: { $in: [ 'scheduled', 'yet-to-approve' ] },
+    } );
+
+    if ( !scheduledEntries || scheduledEntries.length === 0 ) {
+      return res.sendSuccess( {
+        message: 'No scheduled entries found for today',
+        processed: 0,
+        results: [],
+      } );
+    }
+
+    const results = {
+      processed: [],
+      failed: [],
+    };
+
+    // Process each scheduled entry
+    for ( const entry of scheduledEntries ) {
+      try {
+        const findReplaceId = entry._id.toString();
+        const entryDoc = entry.toObject ? entry.toObject() : entry;
+
+        // Verify the schedule date matches today (double check)
+        const scheduleDate = dayjs( entryDoc.scheduleDate );
+        if ( !scheduleDate.isSame( today, 'day' ) ) {
+          logger.warn( {
+            functionName: 'processScheduledFindReplace',
+            findReplaceId: findReplaceId,
+            message: 'Schedule date does not match today, skipping',
+            scheduleDate: scheduleDate.format( 'YYYY-MM-DD' ),
+            today: today.format( 'YYYY-MM-DD' ),
+          } );
+          continue;
+        }
+
+        // Call approveReplace internally
+        const mockApproveReq = {
+          body: {
+            findReplaceId: findReplaceId,
+            sendRollout: true,
+          },
+          user: req.user || {},
+        };
+
+        let approveResult = null;
+        let approveError = null;
+
+        const mockApproveRes = {
+          sendSuccess: ( data ) => {
+            approveResult = data;
+          },
+          sendError: ( error, statusCode ) => {
+            approveError = { error, statusCode };
+          },
+        };
+
+        await approveReplace( mockApproveReq, mockApproveRes );
+
+        if ( approveError ) {
+          results.failed.push( {
+            findReplaceId: findReplaceId,
+            name: entryDoc.name || 'Unknown',
+            error: approveError.error || approveError,
+          } );
+        } else {
+          results.processed.push( {
+            findReplaceId: findReplaceId,
+            name: entryDoc.name || 'Unknown',
+            result: approveResult,
+          } );
+        }
+      } catch ( entryError ) {
+        logger.error( {
+          functionName: 'processScheduledFindReplace',
+          findReplaceId: entry._id.toString(),
+          error: entryError,
+        } );
+        results.failed.push( {
+          findReplaceId: entry._id.toString(),
+          name: ( entry.toObject ? entry.toObject() : entry ).name || 'Unknown',
+          error: entryError.message || 'Unknown error',
+        } );
+      }
+    }
+
+    return res.sendSuccess( {
+      message: 'Scheduled entries processed',
+      summary: {
+        total: scheduledEntries.length,
+        processed: results.processed.length,
+        failed: results.failed.length,
+      },
+      results: results,
+    } );
+  } catch ( e ) {
+    logger.error( { functionName: 'processScheduledFindReplace', error: e } );
+    return res.sendError( e, 500 );
+  }
+}
+
 export async function cancelFindReplace( req, res ) {
   try {
     const { findReplaceId } = req.body;
@@ -1996,6 +2148,168 @@ export async function cancelFindReplace( req, res ) {
   }
 }
 
+export async function revokeFindReplace( req, res ) {
+  try {
+    const { findReplaceId } = req.body;
+
+    if ( !findReplaceId || !mongoose.isValidObjectId( findReplaceId ) ) {
+      return res.sendError( 'Valid findReplaceId is required', 400 );
+    }
+
+    const findReplaceData = await findReplaceAiService.findOne( { _id: findReplaceId } );
+    if ( !findReplaceData ) {
+      return res.sendError( 'FindReplace document not found', 404 );
+    }
+
+    const findReplaceDoc = findReplaceData.toObject ? findReplaceData.toObject() : findReplaceData;
+
+    if ( !Array.isArray( findReplaceDoc.stores ) || findReplaceDoc.stores.length === 0 ) {
+      return res.sendError( 'No stores found in the document', 400 );
+    }
+
+    const results = {
+      success: [],
+      failed: [],
+    };
+
+    // Map to track which task IDs were successfully revoked
+    const revokedTaskIds = new Set();
+
+    // Process each store to revoke tasks
+    for ( const store of findReplaceDoc.stores ) {
+      try {
+        const tasksToRevoke = [];
+
+        // Check for merchRolloutId
+        if ( store.merchRolloutId ) {
+          tasksToRevoke.push( {
+            taskId: store.merchRolloutId,
+            type: 'merchRollout',
+            fieldName: 'merchRolloutId',
+          } );
+        }
+
+        // Check for vmRolloutId
+        if ( store.vmRolloutId ) {
+          tasksToRevoke.push( {
+            taskId: store.vmRolloutId,
+            type: 'vmRollout',
+            fieldName: 'vmRolloutId',
+          } );
+        }
+
+        let revokedCount = 0;
+
+        // Revoke each task
+        for ( const task of tasksToRevoke ) {
+          try {
+            // Get task details to retrieve floorId and planoId
+            const taskDetails = await processedService.findOne( { _id: new mongoose.Types.ObjectId( task.taskId ) } );
+            
+            if ( !taskDetails ) {
+              logger.warn( { 
+                functionName: 'revokeFindReplace', 
+                storeName: store.storeName, 
+                taskId: task.taskId,
+                message: 'Task not found, skipping revocation' 
+              } );
+              continue;
+            }
+
+            const taskData = taskDetails.toObject ? taskDetails.toObject() : taskDetails;
+            const floorId = taskData.floorId ? taskData.floorId.toString() : null;
+            const planoId = taskData.planoId ? taskData.planoId.toString() : store.planoId || null;
+
+            if ( !floorId || !planoId ) {
+              logger.warn( { 
+                functionName: 'revokeFindReplace', 
+                storeName: store.storeName, 
+                taskId: task.taskId,
+                message: 'Missing floorId or planoId, skipping revocation' 
+              } );
+              continue;
+            }
+
+            // Call revokeTask internally
+            const mockRevokeReq = {
+              body: {
+                taskId: task.taskId,
+                floorId: floorId,
+                planoId: planoId,
+                type: task.type,
+              },
+            };
+            const mockRevokeRes = {
+              sendSuccess: () => {},
+              sendError: ( error ) => {
+                throw new Error( error );
+              },
+            };
+
+            await taskController.revokeTask( mockRevokeReq, mockRevokeRes );
+            
+            // Mark task as successfully revoked
+            revokedTaskIds.add( task.taskId );
+            revokedCount++;
+          } catch ( taskError ) {
+            logger.error( { 
+              functionName: 'revokeFindReplace', 
+              storeName: store.storeName, 
+              taskId: task.taskId,
+              taskError: taskError 
+            } );
+            // Continue with other tasks even if one fails
+          }
+        }
+
+        if ( revokedCount > 0 ) {
+          results.success.push( {
+            storeName: store.storeName,
+            revokedTasks: revokedCount,
+          } );
+        }
+      } catch ( storeError ) {
+        logger.error( { functionName: 'revokeFindReplace', storeName: store.storeName, error: storeError } );
+        results.failed.push( {
+          storeName: store.storeName,
+          reason: storeError.message || 'Unknown error',
+        } );
+      }
+    }
+
+    // Update stores to remove only successfully revoked task IDs
+    const updatedStores = findReplaceDoc.stores.map( ( store ) => {
+      const updatedStore = { ...store };
+      if ( store.merchRolloutId && revokedTaskIds.has( store.merchRolloutId ) ) {
+        delete updatedStore.merchRolloutId;
+      }
+      if ( store.vmRolloutId && revokedTaskIds.has( store.vmRolloutId ) ) {
+        delete updatedStore.vmRolloutId;
+      }
+      return updatedStore;
+    } );
+
+    // Update findReplaceAiModel to remove task IDs
+    await findReplaceAiService.updateOne(
+        { _id: findReplaceId },
+        { stores: updatedStores },
+    );
+
+    return res.sendSuccess( {
+      message: 'Tasks revoked successfully',
+      results: results,
+      summary: {
+        total: findReplaceDoc.stores.length,
+        success: results.success.length,
+        failed: results.failed.length,
+      },
+    } );
+  } catch ( e ) {
+    logger.error( { functionName: 'revokeFindReplace', error: e } );
+    return res.sendError( e, 500 );
+  }
+}
+
 export async function deleteFindReplaceAi( req, res ) {
   try {
     const { id } = req.body;

package/src/routes/planoAI.routes.js

@@ -1,5 +1,5 @@
 import express from 'express';
-import { isAllowedSessionHandler } from 'tango-app-api-middleware';
+import { isAllowedSessionHandler, isAllowedInternalAPIHandler } from 'tango-app-api-middleware';
 import * as planoAIController from '../controllers/planoAI.controller.js';
 
 
@@ -18,5 +18,7 @@ planoAIRouter
     .post( '/batchFindReplace', isAllowedSessionHandler, planoAIController.batchFindReplace )
     .post( '/updateBatchProgress', isAllowedSessionHandler, planoAIController.updateBatchProgress )
     .post( '/approveReplace', isAllowedSessionHandler, planoAIController.approveReplace )
+    .post( '/processScheduledFindReplace', planoAIController.processScheduledFindReplace )
     .post( '/cancelFindReplace', isAllowedSessionHandler, planoAIController.cancelFindReplace )
+    .post( '/revokeFindReplace', isAllowedSessionHandler, planoAIController.revokeFindReplace )
     .post( '/deleteFindReplaceAi', isAllowedSessionHandler, planoAIController.deleteFindReplaceAi );