tango-app-api-trax 3.7.91 → 3.7.93

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "tango-app-api-trax",
-    "version": "3.7.91",
+    "version": "3.7.93",
     "description": "Trax",
     "main": "index.js",
     "type": "module",

package/src/controllers/internalTrax.controller.js

@@ -18,7 +18,7 @@ import timeZone from 'dayjs/plugin/timezone.js';
 import utc from 'dayjs/plugin/utc.js';
 import { logger } from 'tango-app-api-middleware';
 import mongoose from 'mongoose';
-import { sendPushNotification, sendAiPushNotification, sendEmailWithSES, signedUrl, fileUpload } from 'tango-app-api-middleware';
+import { sendPushNotification, sendAiPushNotification, sendEmailWithSES, signedUrl, fileUpload, getOpenSearchData } from 'tango-app-api-middleware';
 // import * as planoService from '../services/planogram.service.js';
 import * as clusterServices from '../services/cluster.service.js';
 import * as teamsServices from '../services/teams.service.js';
@@ -30,6 +30,7 @@ import handlebars from './handlebar-helper.js';
 import { buildVisitChecklistTemplateData, getCompiledVisitChecklistTemplate, createImageCache, resolveTemplateUrls } from '../utils/visitChecklistPdf.utils.js';
 import archiver from 'archiver';
 import puppeteer from 'puppeteer';
+import { getBrowser as getBrowserInstance } from '../utils/browserPool.utils.js';
 import fs from 'fs';
 import path from 'path';
 
@@ -2711,9 +2712,9 @@ export async function getRunAIList( req, res ) {
             if ( qn.answers.some( ( ele ) => ele.runAI ) ) {
               let checkList = runAIList.findIndex( ( run ) => run.checklist.toString() == check._id.toString() );
               if ( checkList == -1 ) {
-                runAIList.push( { checklist: check._id, questions: [ qn.uniqueqid ] } );
+                runAIList.push( { checklist: check._id, checklistName: check.checkListName, questions: [ { name: qn.qname, qid: qn.uniqueqid } ] } );
               } else {
-                runAIList[checkList].questions.push( qn.uniqueqid );
+                runAIList[checkList].questions.push( { name: qn.qname, qid: qn.uniqueqid } );
               }
             }
           } );
@@ -3454,9 +3455,232 @@ async function getBrandInfo( clientId ) {
 }
 
 export const downloadInsertPdf = async ( req, res ) => {
+  let page = null;
   try {
-    res.sendSuccess( 'PDF generation started' );
+    if ( !req.body.checklistId ) {
+      return res.sendError( 'Checklist Id is required', 400 );
+    }
+    const cdnBase = JSON.parse( process.env.CDNURL )?.TraxAnswerCDN || '';
+    const pdfTemplate = getCompiledVisitChecklistTemplate();
+    const imageCache = createImageCache();
+
+    const safeName = ( str ) =>
+      ( str || '' ).toString().replace( /[<>:"/\\|?*]+/g, '_' );
+
+    const query = {
+      query: {
+        bool: {
+          must: [
+            {
+              term: {
+                _id: req.body.checklistId,
+              },
+            },
+          ],
+        },
+      },
+    };
+
+    // 1) Launch browser page + fetch OpenSearch data in parallel
+    const [ browser, aiDetails ] = await Promise.all( [
+      getBrowserInstance(),
+      getOpenSearchData( JSON.parse( process.env.OPENSEARCH ).traxIndex, query ),
+    ] );
+
+    if ( aiDetails?.statusCode != 200 || !aiDetails?.body?.hits?.hits.length ) {
+      return res.sendError( 'Checklist not found', 404 );
+    }
 
+    const doc = { ...aiDetails.body.hits.hits[0]._source };
+
+    // 2) Fetch brandInfo + compliance data in parallel
+    const complianceURL = JSON.parse( process.env.LAMBDAURL ).complianceHistory;
+    const detectionPayload = {
+      'storeId': [ doc.store_id ],
+      'userEmail': doc.userEmail,
+      'sourceChecklist_id': doc.sourceCheckList_id,
+    };
+
+    const [ brandInfo, complianceData ] = await Promise.all( [
+      getBrandInfo( doc.client_id ),
+      LamdaServiceCall( complianceURL, detectionPayload ),
+    ] );
+
+    if ( complianceData?.data?.length ) {
+      doc['historyData'] = complianceData.data;
+    }
+
+    // CDN fix
+    ( doc.questionAnswers || [] ).forEach( ( section ) => {
+      ( section.questions || [] ).forEach( ( question ) => {
+        ( question.userAnswer || [] ).forEach( ( answer ) => {
+          if ( answer?.referenceImage?.trim() ) {
+            answer.referenceImage = cdnBase + answer.referenceImage;
+          }
+        } );
+      } );
+    } );
+
+    const templateData = buildVisitChecklistTemplateData( doc, brandInfo );
+    const resolvedData = resolveTemplateUrls( templateData, cdnBase );
+    await imageCache.resolveAllImages( resolvedData );
+
+    const html = pdfTemplate( resolvedData );
+
+    // 3) Create page and render — images are already base64 so use domcontentloaded
+    page = await browser.newPage();
+    await page.setViewport( { width: 1280, height: 1800 } );
+
+    try {
+      await page.setContent( html, {
+        waitUntil: 'domcontentloaded',
+        timeout: 15000,
+      } );
+      await page.emulateMediaType( 'screen' );
+    } catch ( err ) {
+      logger.error( { functionName: 'downloadInsertPdf', message: 'setContent failed', error: err } );
+    }
+
+    let pdfBuffer;
+    try {
+      pdfBuffer = await page.pdf( {
+        format: 'A4',
+        printBackground: true,
+        margin: { top: '10mm', right: '10mm', bottom: '10mm', left: '10mm' },
+      } );
+    } catch ( err ) {
+      logger.error( { functionName: 'downloadInsertPdf', message: 'PDF generation failed', error: err } );
+      return res.sendError( 'PDF generation failed', 500 );
+    }
+
+    if ( !pdfBuffer || pdfBuffer.length === 0 ) {
+      logger.error( { functionName: 'downloadInsertPdf', message: 'Empty PDF', docId: doc._id } );
+      return res.sendError( 'PDF generation resulted in empty buffer', 500 );
+    }
+
+    const finalBuffer = Buffer.isBuffer( pdfBuffer ) ?
+      pdfBuffer :
+      Buffer.from( pdfBuffer );
+
+    const pdfName = `${safeName(
+        doc.store_id + '_' + ( doc.storeName || 'store' ),
+    )}.pdf`;
+
+    res.set( {
+      'Content-Type': 'application/pdf',
+      'Content-Disposition': `attachment; filename="${pdfName}"`,
+      'Content-Length': finalBuffer.length,
+    } );
+
+    return res.send( finalBuffer );
+  } catch ( e ) {
+    logger.error( { functionName: 'downloadInsertPdf', error: e } );
+    return res.sendError( e, 500 );
+  } finally {
+    if ( page ) {
+      await page.close().catch( () => {} );
+    }
+  }
+};
+
+export async function checklistAutoMailList( req, res ) {
+  try {
+    const checklistInfoList = await CLconfig.find( {
+      'autoEmail.type': { $exists: true },
+      '$expr': {
+        $gt: [ { $size: { $ifNull: [ '$autoEmail.type', [] ] } }, 0 ],
+      },
+    }, { _id: 1, autoEmail: 1 } );
+
+    let result = [];
+
+    await Promise.all( checklistInfoList.map( async ( ele ) => {
+      for ( let email of ele?.autoEmail?.users ) {
+        let stores = [];
+        let userDetails = await userService.findOne( { email: email.value } );
+        if ( userDetails ) {
+          if ( userDetails.userType === 'client' && userDetails.role !== 'superadmin' ) {
+            let storeIds = new Set( userDetails.assignedStores.map( ( store ) => store.storeId ) );
+
+            // Fetch clusters and teams in parallel
+            const [ clustersList, teamsList ] = await Promise.all( [
+              clusterServices.findcluster( { clientId: userDetails.clientId, Teamlead: { $elemMatch: { email: userDetails.email } } } ),
+              teamsServices.findteams( { clientId: userDetails.clientId, Teamlead: { $elemMatch: { email: userDetails.email } } } ),
+            ] );
+
+            // Process clusters
+            if ( clustersList.length > 0 ) {
+              for ( let cluster of clustersList ) {
+                cluster.stores.forEach( ( store ) => storeIds.add( store.storeId ) );
+              }
+            }
+
+            // Process teams
+            if ( teamsList.length > 0 ) {
+              for ( let team of teamsList ) {
+                for ( let user of team.users ) {
+                  let findUser = await userService.findOne( { _id: user.userId } );
+                  if ( findUser && findUser.assignedStores?.length > 0 ) {
+                    findUser.assignedStores.forEach( ( store ) => storeIds.add( store.storeId ) );
+                  }
+
+                  // Fetch clusters for the user
+                  let userClustersList = await clusterServices.findcluster( { clientId: userDetails.clientId, Teamlead: { $elemMatch: { email: findUser.email } } } );
+                  if ( userClustersList.length > 0 ) {
+                    for ( let cluster of userClustersList ) {
+                      cluster.stores.forEach( ( store ) => storeIds.add( store.storeId ) );
+                    }
+                  }
+                }
+              }
+            }
+            let TeamMember = await teamsServices.findteams( { clientId: userDetails.clientId, users: { $elemMatch: { email: userDetails.email } } } );
+            if ( TeamMember&&TeamMember.length>0 ) {
+              for ( let team of TeamMember ) {
+                let clusterList = await clusterServices.findcluster( { clientId: userDetails.clientId, teams: { $elemMatch: { name: team.teamName } } } );
+                if ( clusterList.length > 0 ) {
+                  for ( let cluster of clusterList ) {
+                    cluster.stores.forEach( ( store ) => storeIds.add( store.storeId ) );
+                  }
+                }
+              }
+            }
+            let TeamLeader = await teamsServices.findteams( { clientId: userDetails.clientId, Teamlead: { $elemMatch: { email: userDetails.email } } } );
+            if ( TeamLeader&&TeamLeader.length>0 ) {
+              for ( let team of TeamLeader ) {
+                let clusterList = await clusterServices.findcluster( { clientId: userDetails.clientId, teams: { $elemMatch: { name: team.teamName } } } );
+                if ( clusterList.length > 0 ) {
+                  for ( let cluster of clusterList ) {
+                    cluster.stores.forEach( ( store ) => storeIds.add( store.storeId ) );
+                  }
+                }
+              }
+            }
+            // Convert Set back to Array if needed
+            stores = Array.from( storeIds );
+          }
+          let data = {
+            id: ele._id,
+            email: email?.value,
+            stores,
+            role: userDetails.role,
+          };
+          result.push( data );
+        }
+      }
+    } ) );
+
+    return res.sendSuccess( result );
+  } catch ( e ) {
+    console.log( e );
+    logger.error( { functionName: 'checklistAutoMailList', error: e } );
+    return res.sendError( e, 500 );
+  }
+}
+
+
+export const downloadInsertPdfOld = async ( req, res ) => {
+  try {
     setImmediate( async () => {
       try {
         const cdnBase = JSON.parse( process.env.CDNURL )?.TraxAnswerCDN || '';
@@ -3596,11 +3820,10 @@ export const downloadInsertPdf = async ( req, res ) => {
 
                 try {
                   await page.setContent( html, {
-                    waitUntil: 'domcontentloaded',
-                    timeout: 0,
+                    waitUntil: 'networkidle0',
+                    timeout: 30000,
                   } );
 
-                  await new Promise( ( r ) => setTimeout( r, 300 ) );
                   await page.emulateMediaType( 'screen' );
                 } catch ( err ) {
                   logger.error( { functionName: 'setContent failed:', error: err } );

package/src/routes/internalTraxApi.router.js

@@ -38,6 +38,7 @@ internalTraxRouter
     .post( '/posblock', isAllowedInternalAPIHandler, internalController.getStoreTaskDetails )
     .post( '/runAIFlag', isAllowedInternalAPIHandler, internalController.runAIFlag )
     .post( '/downloadInsertPdf', isAllowedInternalAPIHandler, internalController.downloadInsertPdf )
+    .get( '/checklistAutoMailList', isAllowedInternalAPIHandler, internalController.checklistAutoMailList )
 ;
 
 

package/src/utils/browserPool.utils.js

@@ -0,0 +1,72 @@
+import puppeteer from 'puppeteer';
+
+
+const LAUNCH_ARGS = {
+
+  headless: 'new',
+
+  args: [ '--no-sandbox', '--disable-dev-shm-usage', '--disable-gpu' ],
+
+};
+
+
+let browserInstance = null;
+
+let launchPromise = null;
+
+
+async function launchBrowser() {
+  const browser = await puppeteer.launch( LAUNCH_ARGS );
+
+  browser.on( 'disconnected', () => {
+    if ( browserInstance === browser ) {
+      browserInstance = null;
+
+      launchPromise = null;
+    }
+  } );
+
+  return browser;
+}
+
+
+/**
+
+ * Returns a shared browser instance, launching one if needed.
+
+ * Callers must close their pages, NOT the browser.
+
+ */
+
+export async function getBrowser() {
+  if ( browserInstance ) {
+    try {
+      // verify browser is still alive
+
+      await browserInstance.version();
+
+      return browserInstance;
+    } catch {
+      browserInstance = null;
+
+      launchPromise = null;
+    }
+  }
+
+
+  if ( !launchPromise ) {
+    launchPromise = launchBrowser().then( ( b ) => {
+      browserInstance = b;
+
+      return b;
+    } ).catch( ( err ) => {
+      launchPromise = null;
+
+      throw err;
+    } );
+  }
+
+
+  return launchPromise;
+}
+