tango-app-api-trax 3.4.0-flag-4 → 3.4.0-flag-5

package/app.js

@@ -0,0 +1,55 @@
+import express from 'express';
+import { traxRouter, mobileRouter, traxFlagRouter, traxDashboardRouter, galleryRouter, internalTraxRouter, downloadRouter, activityLogRouter } from './index.js';
+import responseMiddleware from './config/response/response.js';
+import errorMiddleware from './config/response/response.js';
+import dotenv from 'dotenv';
+import { logger } from 'tango-app-api-middleware';
+import { connectdb } from './config/database/database.js';
+import cors from 'cors';
+import pkg from 'body-parser';
+import fileupload from 'express-fileupload';
+import admin from 'firebase-admin';
+const serviceAccountPath = JSON.parse( process.env.FIREBASE );
+admin.initializeApp( {
+  credential: admin.credential.cert( serviceAccountPath ),
+} );
+
+const env=dotenv.config();
+
+const app = express();
+const PORT = process.env.PORT || 3000;
+
+const { json, urlencoded } =pkg;
+
+
+if ( env.error ) {
+  logger.error( '.env not found' );
+  process.exit( 1 );
+}
+
+app.use( cors() );
+app.use( responseMiddleware );
+app.use( errorMiddleware );
+app.use( json( { limit: '500mb' } ) );
+app.use( fileupload() );
+app.use(
+    urlencoded( {
+      extended: true,
+    } ),
+);
+
+app.use( '/trax', traxRouter );
+app.use( '/trax/flag', traxFlagRouter );
+app.use( '/trax/mobileAPI', mobileRouter );
+app.use( '/trax/dashboard', traxDashboardRouter );
+app.use( '/gallery', galleryRouter );
+app.use( '/trax/internalAPI', internalTraxRouter );
+app.use( '/trax/downloads', downloadRouter );
+app.use( '/activityLog', activityLogRouter );
+
+
+app.listen( PORT, () => {
+  console.log( `server is running on port= ${PORT} ` );
+  logger.info( `server is running on port= ${PORT} ` );
+  connectdb();
+} );

package/index.js

@@ -8,5 +8,5 @@ import { downloadRouter } from './src/routes/download.router.js';
 import { mobileRouter } from './src/routes/mobileTrax.routes.js';
 import { internalTraxRouter } from './src/routes/internalTraxApi.router.js';
 import { locusOrderRouter } from './src/routes/locus.router.js';
-
-export { traxDashboardRouter, traxFlagRouter, traxRouter, galleryRouter, downloadRouter, mobileRouter, internalTraxRouter, locusOrderRouter };
+import { activityLogRouter } from './src/routes/activityLog.router.js';
+export { traxDashboardRouter, traxFlagRouter, traxRouter, galleryRouter, downloadRouter, mobileRouter, internalTraxRouter, locusOrderRouter, activityLogRouter };

package/package.json

@@ -1,11 +1,11 @@
 {
     "name": "tango-app-api-trax",
-    "version": "3.4.0-flag-4",
+    "version": "3.4.0-flag-5",
     "description": "Trax",
-    "main": "index.js",
+    "main": "app.js",
     "type": "module",
     "scripts": {
-        "start": "nodemon --exec \"eslint --fix . && node index.js\""
+        "start": "nodemon --exec \"eslint --fix . && node app.js\""
     },
     "engines": {
         "node": ">=18.10.0"

package/src/controllers/activityLog.controller.js

@@ -0,0 +1,353 @@
+// import mongoose from 'mongoose';
+import { insertOpenSearchData, updateOpenSearchData, getOpenSearchData } from 'tango-app-api-middleware';
+import * as checklistService from '../services/checklist.service.js';
+
+export const insertLog = async ( req, res ) => {
+  try {
+    console.log( 'insertLog' );
+    // let currentDate = new Date();
+    let inserttraxlogs = {
+      'client_id': '11',
+      'createAt': new Date(),
+      'sourceCheckList_id': '668e3e1807d5312fa49b0046',
+      'checkListName': 'Daily Store Checklistnafi33',
+      'fromCheckListName': '',
+      'type': 'checklist',
+      'action': 'updated',
+      'storeName': 'LKST007',
+      'store_id': '',
+      'createdByEmail': 'lkst007bc1@lenskart.co.in',
+      'createdBy': 'lkst007bc1',
+      'coverage': 'store',
+      'logDetails': {
+        'schedule': {
+          'previous': {
+            'schedule': 'repeats',
+            // "repeats":"daily",
+            'time': '10:00 AM to 11:00 PM',
+            // "occurs":[],
+            'scheduleRepeatedDay': [ '01' ],
+            'scheduleRepeatedType': 'daily',
+            'scheduleStartTime_iso': '2025-02-10T23:30:00.000+00:00',
+            'scheduleEndTime_iso': '2025-02-10T23:30:00.000+00:00',
+            'configStartDate': '2025-03-11T00:00:00.000+00:00',
+            'configEndDate': '2025-03-12T00:00:00.000+00:00',
+            'scheduleWeekDays': [ 'Monday', 'Tuesday' ],
+            'scheduleRepeatedMonthWeek': '2 Tuesday',
+            'specificDate': [ '10', '11' ],
+
+          },
+          'new': {
+            'schedule': 'onetime',
+            // "repeats":"weekly",
+            'time': '10:00 AM to 11:00 PM',
+            // "occurs":["Mondy","Tuesday"],
+            'scheduleRepeatedDay': [ '01' ],
+            'scheduleRepeatedType': 'daily',
+            'configStartDate': '2025-03-11T00:00:00.000+00:00',
+            'configEndDate': '2025-03-12T00:00:00.000+00:00',
+            'scheduleStartTime_iso': '2025-02-10T23:30:00.000+00:00',
+            'scheduleEndTime_iso': '2025-02-10T23:30:00.000+00:00',
+            'scheduleWeekDays': [ 'Monday', 'Tuesday' ],
+            'scheduleRepeatedMonthWeek': '2 Tuesday',
+            'specificDate': [ '10', '11' ],
+          },
+        },
+        'response': {
+          'previous': [ 'Geo Facing', 'Allow Multiple response' ],
+          'new': [ 'Geo Facing 2', 'Allow Multiple response 2' ],
+        },
+        'owner': {
+          'previous': [ 'Ajinkya Malshe' ],
+          'new': [ 'Ajinkya Malshe' ],
+        },
+        'approver': {
+          'previous': [ 'raju', 'rajuapprover' ],
+          'new': [ 'raju 1', 'rajuapprover 2' ],
+        },
+        'storeAdded': [ 'LKST011', 'LKST022', 'LKST3444', 'LKST455', 'LKST566', 'LKST666', 'LKST766', 'LKST866', 'LkST966' ],
+        'storeRemoved': [ 'LKST1166', 'LKST1177', 'LKST1188', 'LKST1199', 'LKST1155', 'LKST1144', 'LKST1133', 'LKST1122', 'LkST1111' ],
+        'userAdded': [ 'LKST011@yopmail.com', 'LKST022@yopmail.com', 'LKST3444@yopmail.com', 'LKST455@yopmail.com', 'LKST566@yopmail.com', 'LKST666@yopmail.com', 'LKST766@yopmail.com', 'LKST866@yopmail.com', 'LkST966@yopmail.com' ],
+        'userRemoved': [ 'LKST1166@yopmail.com', 'LKST1177@yopmail.com', 'LKST1188@yopmail.com', 'LKST1199@yopmail.com', 'LKST1155@yopmail.com', 'LKST1144@yopmail.com', 'LKST1133@yopmail.com', 'LKST1122@yopmail.com', 'LkST1111@yopmail.com' ],
+      },
+    };
+    let insertOS = await insertOpenSearchData( 'test-traxlogs', inserttraxlogs );
+    console.log( 'insertOS', insertOS );
+    return res.sendSuccess( 'insert successfully' );
+    // if ( insertOS && insertOS.body.result == 'created' ) {
+    //   emailersIds.push( insertOS.body._id );
+    // }
+  } catch ( e ) {
+    // logger.error( 'insertLog =>', e );
+    console.log( 'insertLog =>', e );
+    return res.sendError( e, 500 );
+  }
+};
+export const updateLog = async ( req, res ) => {
+  try {
+    console.log( 'update' );
+    const document = {
+      doc: {
+        storeName: 'LKST008',
+        // fromDate: '2025-01-13',
+        // toDate: '2025-01-19',
+        // status: 'completed',
+        // storeIds: [ '347-1' ],
+      },
+    };
+    let updateResult = await updateOpenSearchData( 'test-traxlogs', '5DwBYZUBcRcpuflp5oek', document );
+    console.log( 'updateResult', updateResult );
+    if ( updateResult?.statusCode == 200 && updateResult?.body?.result == 'updated' ) {
+      return res.sendSuccess( 'Email Send Successfully' );
+    } else {
+      return res.sendSuccess( 'Email Send Successfully' );
+      // return res.sendError( { error: error }, 500 );
+    }
+  } catch ( e ) {
+    logger.error( 'updateLog =>', e );
+    return res.sendError( e, 500 );
+  }
+};
+export const listLogOld = async ( req, res ) => {
+  try {
+    console.log( 'list' );
+    const mustConditions = [];
+    // mustConditions.push( { match: { _id: '5DwBYZUBcRcpuflp5oek' } } );
+    let query = {
+      from: 1,
+      size: 2000,
+      query: {
+        bool: {
+          must: mustConditions,
+        },
+      },
+      sort: [
+        {
+          createAt: {
+            order: 'desc',
+          },
+        },
+      ],
+    };
+    let result = await getOpenSearchData( 'test-traxlogs', query );
+    console.log( 'result', result );
+    if ( !result || !result.body.hits.hits.length ) {
+      return res.sendError( 'no data found', 204 );
+    }
+    return res.sendSuccess( { count: result.body.hits.total.value, result: result.body.hits.hits } );
+  } catch ( e ) {
+    console.log( 'listLog', e );
+    // logger.error( 'listLog =>', e );
+    return res.sendError( e, 500 );
+  }
+};
+export const listLog = async ( req, res ) => {
+  try {
+    let requestBody = req.body;
+    let from = ( requestBody.offset ) * requestBody.limit;
+
+    // let start = new Date( requestBody.fromDate );
+    // let userTimezoneOffset = start.getTimezoneOffset() * 60000;
+    // start = new Date( start.getTime() - userTimezoneOffset );
+    // start.setUTCHours( 0, 0, 0, 0 );
+    // let end = new Date( requestBody.toDate );
+    // end = new Date( end.getTime() - userTimezoneOffset );
+    // end.setUTCHours( 23, 59, 59, 59 );
+
+    // console.log( 'list' );
+    const mustConditions = [];
+
+    if ( requestBody.clientId ) {
+      mustConditions.push( { term: { client_id: requestBody.clientId } } );
+    }
+
+    if ( requestBody.type ) {
+      mustConditions.push( { term: { type: requestBody.type } } );
+    }
+
+    if ( requestBody.action ) {
+      mustConditions.push( { terms: { action: requestBody.action } } );
+    }
+
+    if ( req.user.userType == 'client' && req.user.role == 'user' ) {
+      return res.sendError( 'no data found', 204 );
+    }
+
+    if ( req.user.userType == 'client' && req.user.role == 'admin' ) {
+      const sourceCheckListResult = await checklistService.aggregate( [
+        { $match: { 'owner.value': req.user.email } },
+        { $group: { _id: null, checklistIds: { $push: { $toString: '$_id' } } } },
+        { $project: { _id: 0, checklistIds: 1 } },
+      ] );
+      const sourceCheckListIds = sourceCheckListResult.length > 0 ? sourceCheckListResult[0].checklistIds : [];
+      console.log( 'sourceCheckListIds', sourceCheckListIds );
+      // mustConditions.push( { terms: { $or: [ { store_id: { $in: requestBody.storeId } }, { store_id: { $eq: '' }, userEmail: { $in: requestBody.userEmailes } }, { sourceCheckList_id: { $in: sourceCheckListIds } } ] } } );
+      mustConditions.push( {
+        'bool': {
+          'should': [
+            { 'terms': { 'store_id': requestBody.storeId } },
+            {
+              'bool': {
+                'must': [
+                  { 'term': { 'store_id': '' } },
+                  { 'terms': { 'userEmail': requestBody.userEmailes } },
+                ],
+              },
+            },
+            { 'terms': { 'sourceCheckList_id': sourceCheckListIds.map( String ) } },
+          ],
+          'minimum_should_match': 1,
+        },
+      } );
+    }
+
+    if ( requestBody.searchValue ) {
+      mustConditions.push( { multi_match: {
+        'query': requestBody.searchValue,
+        'fields': [ 'checkListName', 'storeName', 'userEmail' ],
+        'type': 'phrase_prefix',
+      },
+      } );
+    }
+    // console.log( 'Generated Query:', JSON.stringify( mustConditions, null, 2 ) );
+
+    // console.log( 'mustConditions =>', mustConditions );
+    // if ( requestBody.dateRange ) {
+    //   mustConditions.push( {
+    //     range: {
+    //       createdAt: {
+    //         gte: start, // Start date
+    //         lte: end, // End date
+    //       },
+    //     },
+    //   } );
+    // }
+    let sortCreatedAt = 'desc';
+    if ( requestBody.sortColumnName && requestBody.sortColumnName != '' ) {
+      if ( requestBody.sortBy == '1' ) {
+        sortCreatedAt = 'asc';
+      }
+    }
+    let query = {
+      from: parseInt( from ),
+      size: parseInt( requestBody.limit ),
+      query: {
+        bool: {
+          must: mustConditions,
+        },
+      },
+      sort: [
+        {
+          createAt: {
+            order: sortCreatedAt,
+          },
+        },
+      ],
+    };
+    let result = await getOpenSearchData( 'test-traxlogs', query );
+    // console.log( 'result', result );
+    if ( !result || !result.body.hits.hits.length ) {
+      return res.sendError( 'no data found', 204 );
+    }
+    return res.sendSuccess( { count: result.body.hits.total.value, result: result.body.hits.hits } );
+  } catch ( e ) {
+    console.log( 'listLog', e );
+    return res.sendError( e, 500 );
+  }
+};
+
+export const listLogNotwork = async ( req, res ) => {
+  try {
+    let requestBody = req.body;
+    let from = ( requestBody.offset ) * requestBody.limit;
+
+    // let start = new Date( requestBody.fromDate );
+    // let userTimezoneOffset = start.getTimezoneOffset() * 60000;
+    // start = new Date( start.getTime() - userTimezoneOffset );
+    // start.setUTCHours( 0, 0, 0, 0 );
+    // let end = new Date( requestBody.toDate );
+    // end = new Date( end.getTime() - userTimezoneOffset );
+    // end.setUTCHours( 23, 59, 59, 59 );
+
+    // console.log( 'list' );
+    const mustConditions = [];
+    // if user role is admin fetch checklist owners
+
+
+    if ( requestBody.clientId ) {
+      mustConditions.push( { term: { client_id: requestBody.clientId } } );
+    }
+
+    // if ( req.user.userType == 'client' && req.user.role == 'admin' ) {
+    //   const sourceCheckListIds = await checklistService.aggregate( [
+    //     { $match: { 'owner.value': req.user.email } },
+    //     { $group: { _id: null, checklistIds: { $push: { $toString: '$_id' } } } },
+    //     { $project: { _id: 0, checklistIds: 1 } },
+    //   ] );
+
+    //   mustConditions.push( { terms: { $or: [ { store_id: { $in: requestBody.storeId } }, { store_id: { $eq: '' }, userEmail: { $in: requestBody.userEmailes } }, { sourceCheckList_id: { $in: sourceCheckListIds } } ] } } );
+    // }
+
+    if ( requestBody.type ) {
+      mustConditions.push( { term: { type: requestBody.type } } );
+    }
+
+    if ( requestBody.action ) {
+      mustConditions.push( { terms: { action: { $in: requestBody.action } } } );
+    }
+
+    if ( requestBody.searchValue ) {
+      mustConditions.push( { multi_match: {
+        'query': requestBody.searchValue,
+        'fields': [ 'checkListName', 'storeName', 'userEmail' ],
+        'type': 'phrase_prefix',
+      },
+      } );
+    }
+    // console.log( 'Generated Query:', JSON.stringify( mustConditions, null, 2 ) );
+
+    // console.log( 'mustConditions =>', mustConditions );
+    // if ( requestBody.dateRange ) {
+    //   mustConditions.push( {
+    //     range: {
+    //       createdAt: {
+    //         gte: start, // Start date
+    //         lte: end, // End date
+    //       },
+    //     },
+    //   } );
+    // }
+    let sortCreatedAt = 'desc';
+    if ( requestBody.sortColumnName && requestBody.sortColumnName != '' ) {
+      if ( requestBody.sortBy == '1' ) {
+        sortCreatedAt = 'asc';
+      }
+    }
+    let query = {
+      from: parseInt( from ),
+      size: parseInt( requestBody.limit ),
+      query: {
+        bool: {
+          must: mustConditions,
+        },
+      },
+      sort: [
+        {
+          createAt: {
+            order: sortCreatedAt,
+          },
+        },
+      ],
+    };
+    let result = await getOpenSearchData( 'test-traxlogs', query );
+    console.log( 'result', result );
+    if ( !result || !result.body.hits.hits.length ) {
+      return res.sendError( 'no data found', 204 );
+    }
+    return res.sendSuccess( { count: result.body.hits.total.value, result: result.body.hits.hits } );
+  } catch ( e ) {
+    console.log( 'listLog', e );
+    logger.error( 'listLog =>', e );
+    return res.sendError( e, 500 );
+  }
+};

package/src/controllers/mobileTrax.controller.js

@@ -1,4 +1,4 @@
-import { logger, signedUrl, fileUpload, getOtp, sendEmailWithSES, getUuid } from 'tango-app-api-middleware';
+import { logger, signedUrl, fileUpload, getOtp, sendEmailWithSES, getUuid, insertOpenSearchData } from 'tango-app-api-middleware';
 import * as processedchecklist from '../services/processedchecklist.services.js';
 import * as processedtask from '../services/processedTaskList.service.js';
 import * as PCLconfig from '../services/processedchecklistconfig.services.js';
@@ -27,6 +27,7 @@ dayjs.extend( timeZone );
 import isSameOrBefore from 'dayjs/plugin/isSameOrBefore.js';
 dayjs.extend( isSameOrBefore );
 
+
 export async function storeList( req, res ) {
   try {
     if ( !req.query?.date ) {
@@ -262,6 +263,27 @@ export async function startChecklist( req, res ) {
           getchecklist[index].questionAnswers[secIndex].questions = questions;
         }
       }
+      let openSearch = JSON.parse( process.env.openSearch );
+      console.log( 'openSearch', openSearch );
+      let inserttraxlogs = {
+        client_id: req.user.clientId,
+        createAt: new Date(),
+        sourceCheckList_id: getBeforeChecklist[0]?.sourceCheckList_id || '',
+        checkListName: getBeforeChecklist[0]?.checkListName || '',
+        fromCheckListName: '',
+        type: 'checkList',
+        action: 'start',
+        storeName: getBeforeChecklist[0]?.storeName || '',
+        store_id: getBeforeChecklist[0]?.store_id || '',
+        createdByEmail: getBeforeChecklist[0]?.userEmail || '',
+        createdBy: getBeforeChecklist[0]?.userName || '',
+        coverage: getBeforeChecklist[0]?.coverage || '',
+        logDetails: {},
+      };
+      // let insertOS = await insertOpenSearchData( 'test-traxlogs', inserttraxlogs );
+      console.log( 'inserttraxlogs', inserttraxlogs );
+      let insertOS = await insertOpenSearchData( openSearch.traxActivityLog, inserttraxlogs );
+      console.log( 'insertOS', insertOS );
       return res.sendSuccess( getchecklist );
     } else {
       return res.sendError( 'something went wrong please try again', 500 );
@@ -433,6 +455,27 @@ export async function startTask( req, res ) {
     };
     await checklistLogs.create( logData );
 
+    let openSearch = JSON.parse( process.env.openSearch );
+    console.log( 'openSearch', openSearch );
+    let inserttraxlogs = {
+      client_id: req.user.clientId,
+      createAt: new Date(),
+      sourceCheckList_id: task.sourceCheckList_id || '',
+      checkListName: task.checkListName || '',
+      fromCheckListName: '',
+      type: 'task',
+      action: 'start',
+      storeName: task.storeName || '',
+      store_id: task.store_id || '',
+      createdByEmail: task.userEmail || '',
+      createdBy: task.userName || '',
+      coverage: task.coverage || '',
+      logDetails: {},
+    };
+    // let insertOS = await insertOpenSearchData( 'test-traxlogs', inserttraxlogs );
+    console.log( 'inserttraxlogs', inserttraxlogs );
+    let insertOS = await insertOpenSearchData( openSearch.traxActivityLog, inserttraxlogs );
+    console.log( 'insertOS', insertOS );
     return res.sendSuccess( getUpdatedTask );
   } catch ( error ) {
     logger.error( { function: 'startTask', error, body: req.body } );
@@ -1805,7 +1848,7 @@ export async function submitChecklist( req, res ) {
           userName: getchecklist[0].userName || '',
           coverage: getchecklist[0].coverage || '',
         };
-        console.log( 'logInsertData=>', logInsertData );
+        // console.log( 'logInsertData=>', logInsertData );s
         await checklistLogs.create( logInsertData );
         // let time = dayjs().format( 'HH:mm:ss' );
         // let [ hours, minutes ] = time.split( ':' ).map( Number );
@@ -1840,8 +1883,32 @@ export async function submitChecklist( req, res ) {
         // await detectionService.create( detectionData );
         if ( requestData.submittype == 'submit' ) {
           updateOpenSearch( req.user, requestData );
+
+          let openSearch = JSON.parse( process.env.openSearch );
+          console.log( 'openSearch', openSearch );
+          let inserttraxlogs = {
+            client_id: req.user.clientId,
+            createAt: new Date(),
+            sourceCheckList_id: getchecklist[0].sourceCheckList_id,
+            checkListName: getchecklist[0].checkListName,
+            type: 'checkList',
+            action: requestData?.submittype === 'draft' ? 'save' : 'submit',
+            storeName: getchecklist[0].storeName,
+            store_id: getchecklist[0].store_id,
+            userName: getchecklist[0].userName,
+            userEmail: getchecklist[0].userEmail,
+            createdByEmail: getchecklist[0].userEmail,
+            createdBy: getchecklist[0].userName,
+            coverage: getchecklist[0].coverage,
+            checkListType: getchecklist[0].checkListType,
+            logDetails: {},
+          };
+          console.log( 'inserttraxlogs', inserttraxlogs );
+          let insertOS = await insertOpenSearchData( openSearch.traxActivityLog, inserttraxlogs );
+          console.log( 'insertOS', insertOS );
         }
 
+
         return res.sendSuccess( 'Checklist Updated Successfully' );
       } else {
         return res.sendError( 'something went wrong please try again', 500 );
@@ -2006,6 +2073,29 @@ export async function submitTask( req, res ) {
 
       if ( submittype == 'submit' ) {
         updateOpenSearchTask( user, requestData );
+
+        let openSearch = JSON.parse( process.env.openSearch );
+        console.log( 'openSearch', openSearch );
+        let inserttraxlogs = {
+          client_id: req.user.clientId,
+          createAt: new Date(),
+          sourceCheckList_id: checklist.sourceCheckList_id,
+          checkListName: checklist.checkListName,
+          type: 'task',
+          action: requestData?.submittype === 'draft' ? 'save' : 'submit',
+          storeName: checklist.storeName,
+          store_id: checklist.store_id,
+          userName: checklist.userName,
+          userEmail: checklist.userEmail,
+          createdByEmail: checklist.userEmail,
+          createdBy: checklist.userName,
+          coverage: checklist.coverage,
+          checkListType: checklist.checkListType,
+          logDetails: {},
+        };
+        console.log( 'inserttraxlogs', inserttraxlogs );
+        let insertOS = await insertOpenSearchData( openSearch.traxActivityLog, inserttraxlogs );
+        console.log( 'insertOS', insertOS );
       }
 
       return res.sendSuccess( 'Task Updated Successfully' );

package/src/controllers/trax.controller.js

@@ -1,4 +1,4 @@
-import { signedUrl, fileUpload, chunkArray, logger, sendPushNotification } from 'tango-app-api-middleware';
+import { signedUrl, fileUpload, chunkArray, logger, sendPushNotification, insertOpenSearchData } from 'tango-app-api-middleware';
 import * as checklistService from '../services/checklist.service.js';
 import * as questionService from '../services/checklistQuestion.service.js';
 import * as assignedService from '../services/checklistAssign.service.js';
@@ -24,7 +24,6 @@ dayjs.extend( customParseFormat );
 import * as clusterServices from '../services/cluster.service.js';
 import * as teamsServices from '../services/teams.service.js';
 
-
 export const checklist = async ( req, res ) => {
   try {
     let limit = parseInt( req.query.limit ) || 10;
@@ -276,13 +275,29 @@ export const create = async ( req, res ) => {
             section: section.name,
             createdBy: req.user._id,
             createdByName: req.user.userName,
-            client_id: req.body.clientId,
+            client_id: inputBody.clientId,
             checkListId: checkListId,
             question: section.questions,
             checkList: inputBody.checklistName,
           };
           await questionService.create( sectionList ).then( async ( data ) => {
             if ( i == inputBody.sections.length - 1 ) {
+              let logObj = {
+                client_id: inputBody.clientId,
+                createAt: new Date(),
+                sourceCheckList_id: checkListId,
+                checkListName: inputBody.checklistName,
+                fromCheckListName: '',
+                type: 'checklist',
+                action: 'created',
+                storeName: '',
+                store_id: '',
+                createdByEmail: req.user.email,
+                createdBy: req.user.userName,
+                coverage: 'store',
+                logDetails: {},
+              };
+              await insertOpenSearchData( JSON.parse( process.env.OPENSEARCH ).traxActivityLog, logObj );
               return res.sendSuccess( { checklistId: checkListId, msg: 'CheckList Created Successfully' } );
             }
           } ).catch( ( e ) => {
@@ -715,6 +730,8 @@ export const update = async ( req, res ) => {
       return res.sendError( 'no data found', 204 );
     }
 
+    let getExistQuestions = await questionService.find( { checkListId: req.params.checklistId, client_id: req.body.clientId } );
+
     inputBody.sections.forEach( async ( element ) => {
       if ( !element.questions.length && inputBody.submitType == 'configure' ) {
         return res.sendError( { message: 'Question is Required' }, 400 );
@@ -725,116 +742,211 @@ export const update = async ( req, res ) => {
       }
     } );
 
-    checkListDetails.checkListName = inputBody.checklistName;
-    checkListDetails.checkListDescription = inputBody.checklistDescription;
-    checkListDetails.questionCount = questionCount;
+    let params = {
+      checkListName: inputBody.checklistName,
+      checkListDescription: inputBody.checklistDescription,
+      questionCount: questionCount,
+    };
 
-    checkListDetails.save().then( async () => {
-      let checkListId = req.params.checklistId;
-      let logInsertData = {
-        action: 'checklistUpdate',
-        checklistId: checkListId,
-        checkListName: inputBody.checklistName,
-        createdBy: req.user._id,
-        createdByName: req.user.userName,
-        client_id: req.body.clientId,
-        sections: inputBody?.sections,
-        createdByEmail: req.user.email,
-      };
-      await checklistLogs.create( logInsertData );
-      if ( inputBody.sections.length ) {
-        let sectionId =[];
-        for ( let i = 0; i < inputBody?.sections?.length; i++ ) {
-          let section = inputBody.sections[i];
-          section.questions.forEach( ( section ) => {
-            if ( section.questionReferenceImage && section.questionReferenceImage !='' ) {
-              let imgUrl = section.questionReferenceImage.split( '?' )[0];
+    checkListDetails.updateOne( { _id: req.params.checklistId }, params );
+    let checkListId = req.params.checklistId;
+    let logInsertData = {
+      action: 'checklistUpdate',
+      checklistId: checkListId,
+      checkListName: inputBody.checklistName,
+      createdBy: req.user._id,
+      createdByName: req.user.userName,
+      client_id: req.body.clientId,
+      sections: inputBody?.sections,
+      createdByEmail: req.user.email,
+    };
+    await checklistLogs.create( logInsertData );
+    let sectionList =[];
+    if ( inputBody.sections.length ) {
+      for ( let i = 0; i < inputBody?.sections?.length; i++ ) {
+        let section = inputBody.sections[i];
+        section.questions.forEach( ( section ) => {
+          if ( section.questionReferenceImage && section.questionReferenceImage !='' ) {
+            let imgUrl = section.questionReferenceImage.split( '?' )[0];
+            let url = imgUrl.split( '/' );
+            url.splice( 0, 3 );
+            section.questionReferenceImage = url.join( '/' );
+          }
+          section.answers.forEach( ( answer ) => {
+            if ( answer.referenceImage != '' ) {
+              let imgUrl = answer.referenceImage.split( '?' )[0];
               let url = imgUrl.split( '/' );
               url.splice( 0, 3 );
-              section.questionReferenceImage = url.join( '/' );
+              answer.referenceImage = url.join( '/' );
             }
-            // if (['image', 'descriptiveImage'].includes(section.answerType)) {
-            section.answers.forEach( ( answer ) => {
-              if ( answer.referenceImage != '' ) {
-                let imgUrl = answer.referenceImage.split( '?' )[0];
-                let url = imgUrl.split( '/' );
-                url.splice( 0, 3 );
-                answer.referenceImage = url.join( '/' );
-              }
-            } );
-            // }
           } );
+        } );
 
-          for ( let [ index, question ] of section.questions.entries() ) {
-            await processNested( index, question );
-          }
+        for ( let [ index, question ] of section.questions.entries() ) {
+          await processNested( index, question );
+        }
 
-          async function processNested( qIdx, question, nestedIndex=-1 ) {
-            if ( question?.answers?.length ) {
-              for ( let [ index, answer ] of question?.answers?.entries() ) {
-                if ( !section.questions[qIdx].answers[index]?.nestedQuestion && nestedIndex == -1 ) {
-                  section.questions[qIdx].answers[index].nestedQuestion = [];
-                }
-                if ( answer.showLinked ) {
-                  if ( nestedIndex != -1 ) {
-                    if ( !section.questions[qIdx].answers[nestedIndex].nestedQuestion.includes( answer.linkedQuestion ) ) {
-                      section.questions[qIdx].answers[nestedIndex].nestedQuestion.push( answer.linkedQuestion );
-                    }
-                  } else {
-                    if ( !section.questions[qIdx].answers[index].nestedQuestion.includes( answer.linkedQuestion ) ) {
-                      section.questions[qIdx].answers[index].nestedQuestion.push( answer.linkedQuestion );
-                    }
+        async function processNested( qIdx, question, nestedIndex=-1 ) {
+          if ( question?.answers?.length ) {
+            for ( let [ index, answer ] of question?.answers?.entries() ) {
+              if ( !section.questions[qIdx].answers[index]?.nestedQuestion && nestedIndex == -1 ) {
+                section.questions[qIdx].answers[index].nestedQuestion = [];
+              }
+              if ( answer.showLinked ) {
+                if ( nestedIndex != -1 ) {
+                  if ( !section.questions[qIdx].answers[nestedIndex].nestedQuestion.includes( answer.linkedQuestion ) ) {
+                    section.questions[qIdx].answers[nestedIndex].nestedQuestion.push( answer.linkedQuestion );
                   }
-                  let nestedLinkedQuestion = section.questions.find( ( item ) => item.qno == answer.linkedQuestion );
-                  if ( nestedLinkedQuestion ) {
-                    let findNestedAnswers = nestedLinkedQuestion.answers.find( ( item ) => item.showLinked );
-                    if ( findNestedAnswers ) {
-                      if ( nestedIndex != -1 ) {
-                        await processNested( qIdx, nestedLinkedQuestion, nestedIndex );
-                      } else {
-                        await processNested( qIdx, nestedLinkedQuestion, index );
-                      }
+                } else {
+                  if ( !section.questions[qIdx].answers[index].nestedQuestion.includes( answer.linkedQuestion ) ) {
+                    section.questions[qIdx].answers[index].nestedQuestion.push( answer.linkedQuestion );
+                  }
+                }
+                let nestedLinkedQuestion = section.questions.find( ( item ) => item.qno == answer.linkedQuestion );
+                if ( nestedLinkedQuestion ) {
+                  let findNestedAnswers = nestedLinkedQuestion.answers.find( ( item ) => item.showLinked );
+                  if ( findNestedAnswers ) {
+                    if ( nestedIndex != -1 ) {
+                      await processNested( qIdx, nestedLinkedQuestion, nestedIndex );
+                    } else {
+                      await processNested( qIdx, nestedLinkedQuestion, index );
                     }
                   }
                 }
               }
             }
           }
+        }
 
-          let sectionList = {
-            section: section.name,
-            sectionOldName: section.oldName,
-            createdBy: req.user._id,
-            createdByName: req.user.userName,
-            client_id: req.body.clientId,
-            checkListId: checkListId,
-            question: section.questions,
-            checkList: inputBody.checklistName,
-          };
-          await questionService.create( sectionList ).then( async ( data ) => {
-            sectionId.push( data._id );
-            if ( i == inputBody.sections.length - 1 ) {
-              await questionService.deleteMany( { checkListId: checkListId, client_id: req.body.clientId, _id: { $nin: sectionId } } );
-              await assignedService.updateMany( { checkListId: checkListId }, { checkListName: inputBody.checklistName } );
-              return res.sendSuccess( { checklistId: checkListId, msg: 'CheckList Created Successfully' } );
-            }
-          } ).catch( ( e ) => {
-            return res.sendError( e, 500 );
-          } );
+        sectionList.push( {
+          section: section.name,
+          sectionOldName: section.oldName,
+          createdBy: req.user._id,
+          createdByName: req.user.userName,
+          client_id: req.body.clientId,
+          checkListId: checkListId,
+          question: section.questions,
+          checkList: inputBody.checklistName,
+        } );
+      }
+    }
+    await questionService.deleteMany( { checkListId: checkListId, client_id: req.body.clientId } );
+    if ( sectionList.length ) {
+      await questionService.insertMany( sectionList );
+    }
+
+    let questionList = {
+      questionAdd: [],
+      questionEdit: [],
+      questionDelete: [],
+    };
+    let updateSection = [];
+
+    function findDifferences( obj1, obj2 ) {
+      return Object.keys( obj1 ).reduce( ( diff, key ) => {
+        if ( !isEqual( obj1[key], obj2[key] ) ) {
+          diff[key] = { previous: obj1[key], new: obj2[key] };
         }
-      } else {
-        if ( inputBody.submitType == 'save' ) {
-          await questionService.deleteMany( { checkListId: checkListId, client_id: req.body.clientId } );
-          return res.sendSuccess( { message: 'CheckList Updated Successfully' } );
+        return diff;
+      }, {} );
+    }
+
+    getExistQuestions.forEach( ( ele ) => {
+      let sectionDetails = inputBody.sections.find( ( sec ) => sec.oldName === ele.section );
+
+      if ( !sectionDetails ) {
+        questionList.questionDelete.push( { sectionName: ele.section, questions: ele.question } );
+        return;
+      }
+
+      if ( ele.section !== sectionDetails.name ) {
+        updateSection.push( { previous: ele.section, new: sectionDetails.name } );
+      }
+
+      ele.question.forEach( ( qn ) => {
+        let question = sectionDetails.questions.find( ( qns ) => qns.oldQname === qn.qname );
+
+        if ( question ) {
+          qn.answers.forEach( ( ans ) => {
+            delete ans.answeroptionNumber;
+          } );
+          question.answers.forEach( ( ans ) => {
+            delete ans.answeroptionNumber;
+          } );
+          let compare = findDifferences( qn, question );
+          if ( Object.keys( compare ).length && ( compare?.answerType || compare?.answers || compare?.linkType ) ) {
+            questionList.questionEdit.push( { sectionName: ele.section, questions: [ { previous: qn }, { new: question } ] } );
+          }
+        } else {
+          let sectionIndex = questionList.questionDelete.findIndex( ( sec ) => sec.sectionName === ele.section );
+
+          if ( sectionIndex !== -1 ) {
+            questionList.questionDelete[sectionIndex].questions.push( qn );
+          } else {
+            questionList.questionDelete.push( { sectionName: ele.section, questions: [ qn ] } );
+          }
         }
+      } );
+    } );
+
+    inputBody.sections.forEach( ( ele ) => {
+      let sectionDetails = getExistQuestions.find( ( sec ) => sec.section === ele.oldName );
+
+      if ( !sectionDetails ) {
+        questionList.questionAdd.push( { sectionName: ele.name, questions: ele.questions } );
+        return;
       }
-    } ).catch( ( e ) => {
-      logger.error( 'update =>', e );
-      return res.sendError( e, 500 );
+
+      ele.questions.forEach( ( qn ) => {
+        let question = sectionDetails.question.find( ( qns ) => qns.qname === qn.oldQname );
+
+        if ( !question ) {
+          let sectionIndex = questionList.questionAdd.findIndex( ( sec ) => sec.sectionName === ele.name );
+
+          if ( sectionIndex !== -1 ) {
+            questionList.questionAdd[sectionIndex].questions.push( qn );
+          } else {
+            questionList.questionAdd.push( { sectionName: ele.name, questions: [ qn ] } );
+          }
+        }
+      } );
     } );
+
+    if ( updateSection.length || questionList.questionAdd.length || questionList.questionEdit.length || questionList.questionDelete.length || inputBody.checklistName.toLowerCase() != checkListDetails.checkListName.toLowerCase() || inputBody.checklistDescription.toLowerCase() != checkListDetails.checkListDescription.toLowerCase() ) {
+      let insertLogData = {
+        client_id: req.body.clientId,
+        createAt: new Date(),
+        sourceCheckList_id: req.params.checklistId,
+        checkListName: inputBody.checklistName,
+        fromCheckListName: '',
+        type: 'checklist',
+        action: 'edited',
+        storeName: '',
+        store_id: '',
+        createdByEmail: req.user.email,
+        createdBy: req.user.userName,
+        coverage: checkListDetails.coverage,
+        logDetails: {
+          ...( inputBody.checklistName.toLowerCase() == checkListDetails.checkListName.toLowerCase() ) ? { updatedChecklistName: {} } :{ updatedChecklistName: {
+            previous: checkListDetails.checkListName,
+            new: inputBody.checklistName,
+          } },
+          ...( inputBody.checklistDescription.toLowerCase() == checkListDetails.checkListDescription.toLowerCase() ) ? { updatedChecklistDescription: {} } :{ updatedChecklistDescription: {
+            previous: checkListDetails.checkListDescription,
+            new: inputBody.checklistDescription,
+          } },
+          updatedSectionName: updateSection,
+          questionAdd: questionList.questionAdd,
+          questionEdit: questionList.questionEdit,
+          questionDelete: questionList.questionDelete,
+        },
+      };
+      await insertOpenSearchData( JSON.parse( process.env.OPENSEARCH ).traxActivityLog, insertLogData );
+    }
+    return res.sendSuccess( { message: 'CheckList Updated Successfully', checklistId: req.params.checklistId } );
   } catch ( e ) {
-    logger.error( 'update =>', e );
-    return res.sendError( e, 500 );
+    logger.error( { functionName: 'questionUpdate', error: e } );
+    res.sendError( e, 500 );
   }
 };
 
@@ -1613,6 +1725,109 @@ export const updateConfigurev1 =async ( req, res ) => {
         futureDaysDataRemove( currentDate, req.params.checklistId, checklistDetails.checkListName, '333' );
       }
     }
+    checklistDetails = checklistDetails.toObject();
+    checklistDetails.configStartDate = checklistDetails.configStartDate ? dayjs.utc( checklistDetails?.configStartDate ).format( 'YYYY-MM-DD' ) : '';
+    checklistDetails.configEndDate = checklistDetails.configEndDate ? dayjs.utc( checklistDetails?.configEndDate ).format( 'YYYY-MM-DD' ) : '';
+    checklistDetails.scheduleDate = checklistDetails.scheduleDate ? dayjs.utc( checklistDetails?.scheduleDate ).format( 'YYYY-MM-DD' ) : '';
+    checklistDetails.scheduleRepeatedDay = Array.isArray( checklistDetails.scheduleRepeatedDay ) ? checklistDetails.scheduleRepeatedDay[0] : checklistDetails.scheduleRepeatedDay;
+    configDetails.scheduleRepeatedDay = Array.isArray( configDetails.scheduleRepeatedDay ) ? configDetails?.scheduleRepeatedDay[0] : configDetails?.scheduleRepeatedDay;
+    configDetails.scheduleDate = configDetails.scheduleDate ? dayjs( configDetails?.scheduleDate ).format( 'YYYY-MM-DD' ) : '';
+    let removedKeys = [ 'publish', 'publishDate', 'storeCount', 'sections', 'createdAt', 'updatedAt', 'scheduleStartTimeISO', 'scheduleEndTimeISO' ];
+    removedKeys.forEach( ( item ) => {
+      delete configDetails?.[item];
+      delete checklistDetails?.[item];
+    } );
+    let differences = findObjectDifference( checklistDetails, configDetails );
+    if ( Object.keys( differences ).length || req.body.added.length || req.body.removed.length ) {
+      let insertData = {
+        client_id: req.body.clientId,
+        createAt: new Date(),
+        sourceCheckList_id: configDetails._id,
+        checkListName: configDetails.checkListName,
+        fromCheckListName: '',
+        type: 'checklist',
+        action: 'updated',
+        storeName: '',
+        store_id: '',
+        createdByEmail: req.user.email,
+        createdBy: req.user.userName,
+        coverage: configDetails.coverage,
+        logDetails: {
+          schedule: {
+            previous: {
+              ...( differences?.scheduleDate && ( differences?.scheduleDate.previous != '' && differences?.scheduleDate.previous != null ) ) ? { scheduleDate: dayjs( checklistDetails?.scheduleDate, 'YYYY-MM-DD' ).format( 'DD MMM, YYYY' ) } :{},
+              schedule: differences?.schedule ? checklistDetails.schedule : '',
+              time: ( ( differences?.scheduleEndTime || differences?.scheduleStartTime ) && ( checklistDetails.scheduleStartTime != '' || checklistDetails.scheduleEndTime != '' ) ) ? checklistDetails.scheduleStartTime + ' to ' + checklistDetails.scheduleEndTime : '',
+              scheduleRepeatedDay: differences?.scheduleRepeatedDay ? checklistDetails?.scheduleRepeatedDay : '',
+              scheduleRepeatedType: differences?.scheduleRepeatedType ? checklistDetails?.scheduleRepeatedType : '',
+              ...( differences?.configStartDate && checklistDetails?.configStartDate ) ? { configStartDate: dayjs( checklistDetails?.configStartDate, 'YYYY-MM-DD' ).format( 'DD MMM, YYYY' ) } :{},
+              ...( differences?.configEndDate && checklistDetails?.configEndDate ) ? { configEndDate: dayjs( checklistDetails?.configEndDate, 'YYYY-MM-DD' ).format( 'DD MMM, YYYY' ) } :{},
+              scheduleWeekDays: differences?.scheduleWeekDays ? checklistDetails?.scheduleWeekDays : [],
+              scheduleRepeatedMonthWeek: differences?.scheduleRepeatedMonthWeek ? checklistDetails?.scheduleRepeatedMonthWeek : '',
+              specificDate: differences?.specificDate ? checklistDetails?.specificDate : [],
+
+            },
+            new: {
+              ...( differences?.scheduleDate && ( differences?.scheduleDate.new != '' && differences?.scheduleDate.new != null ) ) ? { scheduleDate: dayjs( configDetails?.scheduleDate, 'YYYY-MM-DD' ).format( 'DD MMM, YYYY' ) } :{},
+              schedule: differences?.schedule ? configDetails.schedule : '',
+              time: ( ( differences?.scheduleEndTime || differences?.scheduleStartTime ) && ( configDetails.scheduleStartTime != '' || configDetails.scheduleEndTime != '' ) ) ? configDetails.scheduleStartTime + ' to ' + configDetails.scheduleEndTime : '',
+              scheduleRepeatedDay: differences?.scheduleRepeatedDay ? configDetails?.scheduleRepeatedDay : '',
+              scheduleRepeatedType: differences?.scheduleRepeatedType ? configDetails?.scheduleRepeatedType : '',
+              ...( differences?.configStartDate && configDetails?.configStartDate ) ? { configStartDate: dayjs( configDetails?.configStartDate, 'YYYY-MM-DD' ).format( 'DD MMM, YYYY' ) } :{},
+              ...( differences?.configEndDate && configDetails?.configEndDate ) ? { configEndDate: dayjs( configDetails?.configEndDate, 'YYYY-MM-DD' ).format( 'DD MMM, YYYY' ) } :{},
+              scheduleWeekDays: differences?.scheduleWeekDays ? configDetails?.scheduleWeekDays : [],
+              scheduleRepeatedMonthWeek: differences?.scheduleRepeatedMonthWeek ? configDetails?.scheduleRepeatedMonthWeek : '',
+              specificDate: differences?.specificDate ? configDetails?.specificDate : [],
+            },
+          },
+          response: {
+            previous: [
+              ...( differences?.allowedStoreLocation && checklistDetails.allowedStoreLocation ? [ 'Geo fencing' ] : [] ),
+              ...( differences?.allowedMultiSubmit && checklistDetails.allowedMultiSubmit? [ 'Allow multiple responses' ] : [] ),
+              ...( differences?.allowedOverTime && checklistDetails.allowedOverTime ? [ 'Fill response after configure time.' ] : [] ),
+              ...( differences?.allowOnce && checklistDetails.allowOnce ? [ 'Only one time' ] : [] ),
+            ],
+            new: [
+              ...( differences?.allowedStoreLocation && configDetails.allowedStoreLocation ? [ 'Geo fencing' ] : [] ),
+              ...( differences?.allowedMultiSubmit && configDetails.allowedMultiSubmit? [ 'Allow multiple responses' ] : [] ),
+              ...( differences?.allowedOverTime && configDetails.allowedOverTime ? [ 'Fill response after configure time' ] : [] ),
+              ...( differences?.allowOnce && configDetails.allowOnce ? [ 'Only one time' ] : [] ),
+            ],
+          },
+          ...( differences?.approver ) ? { approver:
+           { previous: differences?.approver?.previous.map( ( item ) => item.name ).toString(),
+             new: differences?.approver?.new.map( ( item ) => item.name ).toString() },
+          } : { approver: {} },
+          ...( differences?.owner ) ? { owner:
+           { previous: differences?.owner?.previous.map( ( item ) => item.name ).toString(),
+             new: differences?.owner?.new.map( ( item ) => item.name ).toString() },
+          } : { owner: {} },
+          ...( req.body.checkListDetails.coverage == 'store' ) ? { storeAdded: req.body.added } :{ storeAdded: [] },
+          ...( req.body.checkListDetails.coverage == 'store' ) ? { storeRemoved: req.body.removed } :{ storeRemoved: [] },
+          ...( req.body.checkListDetails.coverage == 'user' ) ? { userAdded: req.body.added } :{ userAdded: [] },
+          ...( req.body.checkListDetails.coverage == 'user' ) ? { userRemoved: req.body.removed } :{ userRemoved: [] },
+        },
+      };
+      await insertOpenSearchData( JSON.parse( process.env.OPENSEARCH ).traxActivityLog, insertData );
+    }
+
+    let logObj = {
+      client_id: inputBody.checkListDetails.client_id,
+      createAt: new Date(),
+      sourceCheckList_id: inputBody.checkListDetails._id,
+      checkListName: inputBody.checkListDetails.checkListName,
+      fromCheckListName: '',
+      type: 'checklist',
+      action: inputBody.checkListDetails.publish ? 'published' : 'unpublished',
+      storeName: '',
+      store_id: '',
+      createdByEmail: req.user.email,
+      createdBy: req.user.userName,
+      coverage: inputBody.checkListDetails.coverage,
+      logDetails: {},
+    };
+    await insertOpenSearchData( JSON.parse( process.env.OPENSEARCH ).traxActivityLog, logObj );
+
     if ( response?.modifiedCount || response?.matchedCount || response?.upsertedCount ) {
       return res.sendSuccess( { id, message: 'Configured Updated Successfully' } );
     }
@@ -1625,6 +1840,32 @@ export const updateConfigurev1 =async ( req, res ) => {
   }
 };
 
+function findObjectDifference( oldObj, newObj ) {
+  const isEqual = ( a, b ) => JSON.stringify( a ) === JSON.stringify( b );
+
+  const getArrayDiff = ( oldArr, newArr ) => {
+    const removed = oldArr.filter( ( item ) => !newArr.some( ( newItem ) => isEqual( newItem, item ) ) );
+    const added = newArr.filter( ( item ) => !oldArr.some( ( oldItem ) => isEqual( oldItem, item ) ) );
+    if ( removed.length || added.length ) {
+      return { previous: oldArr, new: newArr };
+    }
+    return [];
+  };
+  const difference = Object.keys( oldObj ).reduce( ( diff, key ) => {
+    oldObj[key] = oldObj[key] == null ? '' : oldObj[key];
+    if ( !isEqual( oldObj[key], newObj[key] ) ) {
+      if ( !Array.isArray( newObj[key] ) ) {
+        diff[key] = { previous: oldObj[key], new: newObj[key] };
+      } else {
+        diff[key] = getArrayDiff( oldObj[key] || [], newObj[key] || [] );
+      }
+    }
+    return diff;
+  }, {} );
+
+  return difference;
+}
+
 export const updatePublish = async ( req, res ) => {
   try {
     if ( typeof req?.body?.checklistId == 'undefined' && typeof req.body.type == 'undefined' ) {
@@ -1699,6 +1940,22 @@ export const updatePublish = async ( req, res ) => {
 
 
     await checklistService.updateOne( query, getCheckDetails );
+    let logObj = {
+      client_id: req.body.clientId,
+      createAt: new Date(),
+      sourceCheckList_id: req.body.checklistId,
+      checkListName: getCheckDetails.checkListName,
+      fromCheckListName: '',
+      type: 'checklist',
+      action: req.body.publish ? 'published' : 'unpublished',
+      storeName: '',
+      store_id: '',
+      createdByEmail: req.user.email,
+      createdBy: req.user.userName,
+      coverage: getCheckDetails.coverage,
+      logDetails: {},
+    };
+    await insertOpenSearchData( JSON.parse( process.env.OPENSEARCH ).traxActivityLog, logObj );
     if ( getCheckDetails.checkListType == 'custom' ) {
       let currentDate = dayjs.utc().format();
       let updatedscheduleEndTimeISO = dayjs.utc( getCheckDetails.scheduleEndTimeISO ).format( 'HH:mm:ss' );
@@ -3788,6 +4045,44 @@ export async function updateAssign( req, res ) {
     // req.body.assignedGroup = req.body.assignedGroup.map( ( ele ) => {
     //   return { id: ele };
     // } );
+    let getAssignedDetails = await assignedService.find( { checkListId: req.body.checkListId } );
+    if ( getAssignedDetails.length ) {
+      if ( req.body.coverage == 'store' ) {
+        getAssignedDetails = [ ...new Set( getAssignedDetails.map( ( ele ) => ele.storeName ) ) ];
+      } else {
+        getAssignedDetails = [ ...new Set( getAssignedDetails.map( ( ele ) => ele.userName ) ) ];
+      }
+    }
+
+    let added = req.body.assignedList.filter( ( item ) => {
+      let storeUsername;
+      if ( req.body.coverage == 'store' ) {
+        storeUsername = item.storeName;
+      } else {
+        storeUsername = item.userName;
+      }
+      if ( !getAssignedDetails.includes( storeUsername ) ) {
+        return item;
+      }
+    } ).map( ( ele ) => {
+      if ( req.body.coverage == 'store' ) {
+        return ele.storeName;
+      } else {
+        return ele.userName;
+      }
+    } );
+    let removed = getAssignedDetails.filter( ( item ) => {
+      let list;
+      if ( req.body.coverage == 'store' ) {
+        list = req.body.assignedList.map( ( item ) => item.storeName );
+      } else {
+        list = req.body.assignedList.map( ( item ) => item.userName ); ;
+      }
+      if ( !list.includes( item ) ) {
+        return item;
+      }
+    } );
+
     await assignedService.deleteMany( { checkListId: req.body.checkListId } );
     let assignedUserList = [];
     let userEmailList = req.body.assignedList.map( ( ele ) => ele.userEmail.toLowerCase() );
@@ -3851,7 +4146,7 @@ export async function updateAssign( req, res ) {
       }
     } ) );
     await assignedService.insertMany( assignedUserList );
-    return res.sendSuccess( 'Assign details updated successfully' );
+    return res.sendSuccess( { messgage: 'Assign details updated successfully', added, removed } );
   } catch ( e ) {
     logger.error( { functionName: 'updateAssign', error: e } );
     return res.sendError( e, 500 );

package/src/routes/activityLog.router.js

@@ -0,0 +1,18 @@
+import express from 'express';
+import { isAllowedInternalAPIHandler, isAllowedSessionHandler } from 'tango-app-api-middleware';
+
+export const activityLogRouter = express.Router();
+
+import {
+  insertLog,
+  updateLog,
+  listLog,
+} from '../controllers/activityLog.controller.js';
+
+activityLogRouter
+    .post( '/insertLog', isAllowedInternalAPIHandler, insertLog )
+    .post( '/updateLog', isAllowedInternalAPIHandler, updateLog )
+    .post( '/listLog', isAllowedSessionHandler, listLog );
+
+
+export default activityLogRouter;