tango-app-api-client 3.6.5-vms.2 → 3.6.5-vms.20

package/index.js

@@ -2,6 +2,7 @@
 
 import { clientRouter } from './src/routes/client.routes.js';
 import { clientDocs } from './src/docs/client.docs.js';
+import { vmsauditRouter } from './src/routes/vmsAudit.routes.js';
 
-export { clientRouter, clientDocs };
+export { clientRouter, clientDocs, vmsauditRouter };
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tango-app-api-client",
-  "version": "3.6.5-vms.2",
+  "version": "3.6.5-vms.20",
   "description": "client",
   "main": "index.js",
   "type": "module",
@@ -31,7 +31,7 @@
     "npm": "^10.9.1",
     "sharp": "^0.34.3",
     "swagger-ui-express": "^5.0.0",
-    "tango-api-schema": "^2.4.19",
+    "tango-api-schema": "^2.5.2",
     "tango-app-api-middleware": "^3.6.0",
     "winston": "^3.11.0",
     "winston-daily-rotate-file": "^5.0.0"

package/src/controllers/client.controllers.js

@@ -2967,10 +2967,89 @@ export async function updateFDConfig( req, res ) {
 export async function getFDConfig( req, res ) {
   try {
     const inputData = req.query;
-    let result = await findOneClient( { clientId: inputData.clientId }, { footfallDirectoryConfigs: 1 } );
-    if ( result===null ) {
+    // let result = await findOneClient( { clientId: inputData.clientId }, { footfallDirectoryConfigs: 1 } );
+    const configQuery = [
+      {
+        $match: {
+          clientId: inputData?.clientId,
+        },
+      },
+
+      // Convert all effectiveFrom to proper Date
+      {
+        $addFields: {
+          taggingLimitationWithDate: {
+            $map: {
+              input: '$footfallDirectoryConfigs.taggingLimitation',
+              as: 'item',
+              in: {
+                effectiveFrom: { $toDate: '$$item.effectiveFrom' },
+                values: '$$item.values',
+              },
+            },
+          },
+        },
+      },
+
+      // Filter items <= input date
+      {
+        $addFields: {
+          matchedLimitation: {
+            $filter: {
+              input: '$taggingLimitationWithDate',
+              as: 'item',
+              cond: {
+                $lte: [
+                  '$$item.effectiveFrom',
+                  { $toDate: inputData.dateString },
+                ],
+              },
+            },
+          },
+        },
+      },
+
+      // Sort DESC and pick ONLY top 1 -> latest effective record
+      {
+        $addFields: {
+          effectiveLimitation: {
+            $arrayElemAt: [
+              {
+                $slice: [
+                  {
+                    $sortArray: {
+                      input: '$matchedLimitation',
+                      sortBy: { effectiveFrom: -1 },
+                    },
+                  },
+                  1,
+                ],
+              },
+              0,
+            ],
+          },
+        },
+      },
+
+      {
+        $project: {
+          'config': 1,
+          'effectiveLimitation': 1,
+          'footfallDirectoryConfigs': 1,
+
+        },
+      },
+    ];
+
+
+    const getData = await aggregateClient( configQuery );
+    let result = getData[0];
+    if ( !result || result===null ) {
       return res.sendError( 'no data found', 204 );
     }
+    result.footfallDirectoryConfigs.taggingLimitation = result?.effectiveLimitation?.values;
+    delete result.effectiveLimitation;
+
     return res.sendSuccess( result );
   } catch ( error ) {
     const err = error.message || 'Internal Server Error';
@@ -2983,38 +3062,38 @@ export async function getFDConfig( req, res ) {
 export async function updateTaggingType( req, res ) {
   try {
     const inputData = req.body;
-
-    const inputQuery = req.query; // up
-    const types = inputData?.taggingLimitation?.map( ( x ) => x.type );
-    // Step 1: remove existing items with same "type"
-    await clientModel.updateOne(
-        { clientId: inputQuery.clientId },
+    const newValues = inputData.taggingLimitation;
+    const today = new Date().toISOString().split( 'T' )[0];
+    logger.info( { today, newValues } );
+    const result = await clientModel.updateOne(
         {
-          $pull: {
-            'footfallDirectoryConfigs.taggingLimitation': {
-              type: { $in: types },
-            },
-          },
+          'clientId': inputData?.clientId,
+          'footfallDirectoryConfigs.taggingLimitation.effectiveFrom': today,
         },
-    );
-
-    // Remove duplicate entries by type
-    const uniqueData = uniqueByType( inputData.taggingLimitation );
-
-    // Step 2: insert fresh new items
-    let result =await clientModel.updateOne(
-        { clientId: inputQuery.clientId },
         {
-          $addToSet: {
-            'footfallDirectoryConfigs.taggingLimitation': {
-              $each: uniqueData,
-            },
+          $set: {
+            'footfallDirectoryConfigs.taggingLimitation.$.values': newValues,
           },
         },
     );
+    logger.info( { result } );
+    if ( result?.matchedCount === 0 ) {
+      await clientModel.updateOne(
+          { clientId: inputData.clientId },
+          {
+            $push: {
+              'footfallDirectoryConfigs.taggingLimitation': {
+                effectiveFrom: today,
+                values: newValues,
+              },
+            },
+          },
+      );
+    }
+
 
     if ( result?.acknowledged === true ) {
-      return res.sendSuccess( result );
+      return res.sendSuccess( 'Tagging limitation has been updated' );
     } else {
       return res.sendError( 'no data', 204 );
     }
@@ -3025,14 +3104,14 @@ export async function updateTaggingType( req, res ) {
   }
 }
 
-function uniqueByType( arr ) {
-  const seen = new Set();
-  return arr.filter( ( item ) => {
-    if ( seen.has( item.type ) ) return false;
-    seen.add( item.type );
-    return true;
-  } );
-}
+// function uniqueByType( arr ) {
+//   const seen = new Set();
+//   return arr.filter( ( item ) => {
+//     if ( seen.has( item.type ) ) return false;
+//     seen.add( item.type );
+//     return true;
+//   } );
+// }
 
 export async function createStoreRequest( req, res ) {
   try {
@@ -3050,11 +3129,11 @@ export async function createStoreRequest( req, res ) {
     const upsertRecord = await updateOneUpsertVmsStoreRequest( { storeId: inputData?.storeId, dateString: inputData?.dateString }, record );
     logger.info( { upsertRecord } );
     if ( upsertRecord?.upsertedCount === 1 ) {
-      return res.sendSuccess( 'The Request has been sent Successfully' );
+      return res.sendTemp( 'The Request has been sent Successfully' );
     } else if ( upsertRecord?.matchedCount === 1 && upsertRecord?.modifiedCount === 1 ) {
-      return res.sendSuccess( 'The Request has been updated Successfully' );
+      return res.sendTemp( 'The Request has been updated Successfully' );
     } else if ( upsertRecord?.matchedCount === 1 && upsertRecord?.modifiedCount === 0 ) {
-      return res.sendSuccess( 'The Request already exists and nothing to update' );
+      return res.sendTemp( 'The Request already exists and nothing to update' );
     } else {
       return res.sendError( 'Internal Server Error', 500 );
     }
@@ -3096,6 +3175,7 @@ export async function listStoreRequest( req, res ) {
       {
         $project: {
           _id: 0,
+          id: { $concat: [ '$storeId', '_', '$dateString' ] },
           storeName: 1,
           storeId: 1,
           dateString: 1,

package/src/controllers/vmsAudit.controller.js

@@ -0,0 +1,488 @@
+import { logger, searchOpenSearchData, getOpenSearchById, updateOpenSearchData } from 'tango-app-api-middleware';
+import { findOneStore } from '../service/store.service.js';
+import { aggregatevmsUserAudit, createvmsUserAudit, findOnevmsUserAudit, updateOnevmsUserAudit, updatemanyvmsUserAudit } from '../service/vmsuserAudit.service.js';
+import { createvmsAuditLog, findOnevmsAuditLog } from '../service/vmsauditLog.service.js';
+import { insertOpenSearchData, clearScroll, scrollResponse } from 'tango-app-api-middleware';
+import { findOneUser } from '../service/user.service.js';
+import dayjs from 'dayjs';
+import utc from 'dayjs/plugin/utc.js';
+import timezone from 'dayjs/plugin/timezone.js';
+
+dayjs.extend( utc );
+dayjs.extend( timezone );
+export async function getAuditFile( req, res ) {
+  try {
+    // const bucket = JSON.parse( process.env.BUCKET );
+    const url = JSON.parse( process.env.URL );
+    const openSearch = JSON.parse( process.env.OPENSEARCH );
+    const inputData = req.query;
+    const files = [];
+    const storeQuery = {
+      storeId: inputData.storeId,
+    };
+    const storeFields = {
+      storeName: 1,
+      clientId: 1,
+      address: '$storeProfile.address',
+    };
+    const storeInfo = await findOneStore( storeQuery, storeFields );
+
+    const userQuery = [
+      {
+        $match: {
+          $and: [
+            { userId: req.user._id },
+            { auditStatus: { $nin: [ 'completed', 'skipped' ] } },
+            { storeId: inputData.storeId },
+            { fileDate: inputData.Date },
+          ],
+        },
+      },
+      {
+        $sort: { createdAt: -1 },
+      },
+      {
+        $limit: 1,
+      },
+    ];
+
+    const userDetails = await aggregatevmsUserAudit( userQuery );
+    console.log( '🚀 ~ getAuditFile ~ userDetails:', userDetails );
+    const auditStatus = userDetails && userDetails.length > 0 ? userDetails[0].auditStatus : null;
+    if ( auditStatus === 'drafted' ) {
+      const log = await findOnevmsAuditLog(
+          {
+            userId: userDetails[0].userId,
+            fileDate: userDetails[0].fileDate,
+            storeId: userDetails[0].storeId,
+            totalCount: userDetails[0].beforeCount,
+          },
+          {},
+          { createdAt: -1 },
+      );
+      console.log( '🚀 ~ getAuditFile ~ log:', log );
+      if ( !log ) {
+        await updateOnevmsUserAudit(
+            { _id: userDetails[0]._id },
+            { $set: { isDraft: false, auditStatus: 'skipped' } },
+        );
+        logger.info( 'audit update in drafted', {
+          _id: userDetails[0]._id,
+          isDraft: false,
+          auditStatus: 'skipped',
+        } );
+        return res.sendError( 'User saved data has been deleted', 204 );
+      }
+
+      const file = {
+        auditId: userDetails[0]._id,
+        storeId: userDetails[0].storeId,
+        Date: userDetails[0].fileDate,
+        userId: log.userId,
+        timeSpent: log.timeSpent,
+        clientId: userDetails[0].clientId,
+      };
+      const userdata = await findOneUser( { _id: log.userId } );
+      if (
+        !inputData.nextId ||
+        inputData.nextId === '' ||
+        inputData.nextId == null
+      ) {
+        const logData = {
+          userId: log.userId,
+          userName: userdata.userName,
+          logType: 'vmsaudit',
+          logSubType: 'auditStart',
+          logData: {
+            fileDate: userDetails[0].fileDate,
+            storeId: userDetails[0].storeId,
+            auditId: userDetails[0]._id,
+            beforeCount: userDetails[0].beforeCount,
+          },
+          createdAt: new Date(),
+        };
+        await insertOpenSearchData( openSearch.vmsauditLog, logData );
+      }
+      const storeQuery = {
+        storeId: userDetails[0].storeId,
+      };
+      const storeFields = {
+        storeId: 1,
+        storeName: 1,
+        address: '$storeProfile.address',
+      };
+      const storeDetails = await findOneStore( storeQuery, storeFields );
+      let docId = `${inputData.storeId}_${inputData.Date}_footfall-directory-tagging`;
+      if ( inputData.tickettype === 'internal' ) {
+        docId = `${inputData.storeId}_${inputData.Date}_internal_footfall-directory-tagging`;
+      }
+      console.log( '🚀 ~ getAuditFile ~ docId:draft', docId );
+      const existinginternalDoc = await getOpenSearchById( openSearch.footfallDirectory, docId );
+      let ticketSource = existinginternalDoc?.body?._source;
+      const currentTime = new Date();
+      const updatePayload = {
+        doc: {
+
+          updatedAt: currentTime,
+          createdByRole: req?.user?.role || '',
+          createdByEmail: req?.user?.email || '',
+          createdByUserName: req?.user?.userName || '',
+          createdByUserId: req?.user?._id || '',
+        },
+      };
+      console.log( '🚀 ~ getAuditFile ~ updatePayload:', updatePayload );
+      console.log( '🚀 ~ getAuditFile ~ ticketSource:', ticketSource );
+      if ( ticketSource ) {
+        ticketSource.mappingInfo.map( ( data ) => {
+          if ( data.type === 'tangoreview' ) {
+            data.status = 'In-Progress';
+          }
+        } );
+        ticketSource.createdByRole = req?.user?.role || '';
+        ticketSource.createdByEmail = req?.user?.email || '';
+        ticketSource.createdByUserName = req?.user?.userName || '';
+        ticketSource.createdByUserId = req?.user?._id || '';
+        console.log( '🚀 ~ getAuditFile ~ ticketSource:', ticketSource );
+        await updateOpenSearchData(
+            openSearch.footfallDirectory,
+            docId,
+            { doc: ticketSource },
+
+        );
+      } else if ( ticketSource && inputData.tickettype === 'internal' ) {
+        await updateOpenSearchData(
+            openSearch.footfallDirectory,
+            docId,
+            updatePayload,
+        );
+      }
+      return res.sendSuccess( {
+        result: log.draftedData,
+        storeId: storeDetails?.storeId,
+        storeName: storeDetails?.storeName,
+        address: storeDetails?.address || '',
+        count: log.totalCount,
+        timeSpent: log.timeSpent,
+        file: file,
+        isDraft: userDetails[0].isDraft,
+      } );
+    }
+    console.log( inputData );
+
+    const query = {
+      size: inputData?.limit || 2,
+      _source: [ 'module', 'status', 'date', 'store_id', 'outputCluster', 'personPath', 'REIDCluster', 'isEmployee', 'isJunk', 'EmployeeStatusFinal' ], // Only fetch necessary fields
+
+      query: {
+        bool: {
+          'must': [
+            {
+              term: { 'store_id.keyword': inputData.storeId },
+            },
+            {
+              term: { 'date.keyword': dayjs( inputData.Date ).format( 'DD-MM-YYYY' ) },
+            },
+            {
+              term: { 'module.keyword': 'CUSTOMER' },
+            },
+            {
+              term: { 'status.keyword': 'PP_CLUSTER_FORMED' },
+            },
+            {
+              terms: { EmployeeStatusFinal: [ 1, 2 ] },
+            },
+          ],
+          'should': [
+            { 'term': { 'isJunk': false } },
+            { 'bool': { 'must_not': { 'exists': { 'field': 'isJunk' } } } },
+          ],
+          'minimum_should_match': 1,
+        },
+      },
+
+    };
+    console.log( openSearch.vmsAudit );
+    let list = inputData.nextId ? await scrollResponse( inputData.nextId ) : await searchOpenSearchData( openSearch.vmsAudit, query );
+
+    let docId = `${inputData.storeId}_${inputData.Date}_footfall-directory-tagging`;
+    if ( inputData.tickettype === 'internal' ) {
+      docId = `${inputData.storeId}_${inputData.Date}_internal_footfall-directory-tagging`;
+    }
+    console.log( '🚀 ~ getAuditFile ~ docId:draft', docId );
+    const existinginternalDoc = await getOpenSearchById( openSearch.footfallDirectory, docId );
+    let ticketSource = existinginternalDoc?.body?._source;
+    const currentTime = new Date();
+    const updatePayload = {
+      doc: {
+
+        updatedAt: currentTime,
+        createdByRole: req?.user?.role || '',
+        createdByEmail: req?.user?.email || '',
+        createdByUserName: req?.user?.userName || '',
+        createdByUserId: req?.user?._id || '',
+      },
+    };
+    console.log( '🚀 ~ getAuditFile ~ updatePayload:', updatePayload );
+    console.log( '🚀 ~ getAuditFile ~ ticketSource:', ticketSource );
+    if ( ticketSource ) {
+      ticketSource.mappingInfo.map( ( data ) => {
+        if ( data.type === 'tangoreview' ) {
+          data.status = 'In-Progress';
+          console.log( '🚀 ~ getAuditFile ~ data.status:', data.status );
+        }
+      } );
+      ticketSource.createdByRole = req?.user?.role || '';
+      ticketSource.createdByEmail = req?.user?.email || '';
+      ticketSource.createdByUserName = req?.user?.userName || '';
+      ticketSource.createdByUserId = req?.user?._id || '';
+      console.log( '🚀 ~ getAuditFile ~ ticketSource:', ticketSource );
+      await updateOpenSearchData(
+          openSearch.footfallDirectory,
+          docId,
+          { doc: ticketSource },
+      );
+    } else if ( ticketSource && inputData.tickettype === 'internal' ) {
+      await updateOpenSearchData(
+          openSearch.footfallDirectory,
+          docId,
+          updatePayload,
+      );
+    }
+    const folderPath = list?.body?.hits?.hits;
+    if ( list?.body?.hits?.hits?.length == 0 ) {
+      await clearScroll( list?.body?._scroll_id );
+    }
+    if ( folderPath?.length > 0 ) {
+      for ( let i = 0; i < folderPath.length; i++ ) {
+        const img = folderPath[i]?._source?.personPath?.split( '/' );
+        const image = img[3]?.split( '.' );
+        const indexes = folderPath[i]?._source?.outputCluster === 50000 ? folderPath[i]?._source?.REIDCluster : folderPath[i]?._source?.outputCluster;
+        // fetchData.file_path = folderPath[i]?._source?.personPath;
+        const data = `${url.trackInput}${folderPath[i]?._source?.personPath}`;
+        const mapimg = {
+          img_path: data,
+          img_name: indexes,
+          img_id: image[0],
+        };
+        addUniqueFile( files, {
+          img_path: data,
+          img_name: indexes,
+          img_id: image[0],
+          selected: false,
+          dropped: false,
+          demographic: '',
+          count: 1,
+          mappedid: [ mapimg ],
+        } );
+      }
+    } else if ( inputData.nextId !== '' && inputData.nextId !== null && inputData.nextId !== undefined ) {
+      if ( !list ) {
+        return res.sendError( 'token expired', 404 );
+      }
+      list.body._scroll_id = '';
+      // insertData = userDetails[0];
+    } else {
+      logger.error( {
+        error: { folderPath: folderPath, nextQuery: inputData.nextId },
+        function: 'getAuditFile',
+        message: 'Bucket image data not availale',
+      } );
+      return res.sendError( 'Bucket is Empty', 204 );
+    }
+    const [ year, month, day ] = inputData.Date.split( '-' );
+    const temp = `${year}-${month}-${day}`;
+    console.log( temp );
+    let start = new Date( temp );
+    const userTimezoneOffset = start.getTimezoneOffset() * 60000;
+    start = new Date( start.getTime() - userTimezoneOffset );
+    start.setUTCHours( 0, 0, 0, 0 );
+    console.log( start );
+    const record = {
+      userId: req.user._id,
+      storeId: inputData.storeId,
+      clientId: storeInfo?.clientId,
+      fileDate: inputData.Date,
+      beforeCount: inputData.count,
+      auditStatus: 'inprogress',
+      fileDateISO: start,
+      timeSpent: 0,
+      startTime: new Date(),
+    };
+    const insertData = await createvmsUserAudit( record );
+    if ( inputData.nextId !== '' && inputData.nextId !== null && inputData.nextId !== undefined && inputData.moduleType === 'track' ) {
+      if ( !list ) {
+        return res.sendError( 'token expired', 404 );
+      }
+      list.body._scroll_id = '';
+    }
+    return res.sendSuccess( {
+      result: files,
+      count: inputData.count,
+      storeId: inputData.storeId,
+      storeName: storeInfo?.storeName,
+      address: storeInfo?.address,
+      file: {
+        clientId: storeInfo?.clientId,
+        storeId: inputData.storeId,
+        Date: inputData.Date,
+        auditId: insertData._id,
+        userId: insertData.userId,
+        nextToken: list?.body?._scroll_id ? list?.body?._scroll_id : null,
+
+      },
+      isDraft: insertData.isDraft,
+    } );
+  } catch ( error ) {
+    const err = error.message || 'Internal Server Error';
+    logger.error( {
+      error: error,
+      message: req.query,
+      function: 'getAuditFile',
+    } );
+    return res.sendError( err, 500 );
+  }
+}
+function addUniqueFile( files, newFile ) {
+  const exists = files.some( ( file ) => file.img_name === newFile.img_name );
+  if ( !exists ) {
+    files.push( newFile );
+  }
+}
+export async function saveDraft( req, res ) {
+  try {
+    const openSearch = JSON.parse( process.env.OPENSEARCH );
+    const inputData = req.body;
+    inputData.userId = req.user._id;
+    const getUserAuditData = await findOnevmsUserAudit( { _id: inputData.auditId } );
+    if ( !getUserAuditData ) {
+      return res.sendError( 'No Data Found', 204 );
+    }
+    if ( getUserAuditData.auditStatus == 'skipped' ) {
+      return res.sendError( 'File Assigned to Someone else', 203 );
+    }
+
+    const userQuery = {
+      _id: inputData.auditId,
+    };
+    let userRecord = {
+      isDraft: true,
+      auditStatus: 'drafted',
+    };
+
+
+    if ( getUserAuditData?.startTime ) {
+      userRecord.timeSpent = inputData.timeSpent;
+    }
+
+    if ( inputData.userCommands ) {
+      userRecord.userCommands = inputData.userCommands;
+      const logData = {
+        userId: req.user._id,
+        userName: req.user.userName,
+        logType: 'vmsaudit',
+        logSubType: 'auditDraft',
+        logData: {
+          fileDate: inputData.fileDate,
+          storeId: inputData.storeId,
+          beforeCount: inputData.totalCount,
+          afterCount: inputData.customerCount,
+          timeSpent: inputData.timeSpent,
+          auditId: inputData.auditId,
+        },
+        createdAt: new Date(),
+      };
+      await insertOpenSearchData( openSearch.vmsauditLog, logData );
+    }
+    await createvmsAuditLog( inputData );
+    await updateOnevmsUserAudit( userQuery, userRecord );
+    console.log( '🚀 ~ saveDraft ~ userRecord:', userRecord );
+    return res.sendSuccess( {
+      result: 'The file has been drafted successfully',
+    } );
+  } catch ( error ) {
+    const err = error.message || 'Internal Server Error';
+    logger.error( { error: error, message: req.body, function: 'saveDraft' } );
+    return res.sendError( err, 500 );
+  }
+}
+export async function getDraftedData( req, res ) {
+  try {
+    const inputData = req.query;
+    const userId = inputData.userId || req.user._id;
+    const query = {
+      fileDate: inputData.fileDate,
+      storeId: inputData.storeId,
+      userId: userId,
+      auditId: inputData.auditId,
+    };
+    console.log( query );
+    const result = await findOnevmsAuditLog( query, {}, { createdAt: -1 }, 1 );
+
+    if ( !result ) {
+      return res.sendError( 'No Data Found', 204 );
+    }
+    return res.sendSuccess( { result: result } );
+  } catch ( error ) {
+    const err = error.message || 'Internal Server Error';
+    logger.error( {
+      error: error,
+      message: req.query,
+      function: 'getDraftedData',
+    } );
+    return res.sendError( err, 500 );
+  }
+}
+
+
+export async function reAssignAudit( req, res ) {
+  try {
+    const openSearch = JSON.parse( process.env.OPENSEARCH );
+    let inputData = req.body;
+    let docId = `${inputData.storeId}_${inputData.dateString}_internal_footfall-directory-tagging`;
+    if ( inputData.tickettype ==='store' ) {
+      docId = `${inputData.storeId}_${inputData.dateString}_footfall-directory-tagging`;
+    }
+    console.log( '🚀 ~ getAuditFile ~ docId:draft', docId );
+    const existingDoc = await getOpenSearchById( openSearch.footfallDirectory, docId );
+    const ticketSource = existingDoc?.body?._source;
+    const currentTime = new Date();
+    const userdata = await findOneUser( { email: inputData.email } );
+    const updatePayload = {
+      doc: {
+        status: 'In-Progress',
+        updatedAt: currentTime,
+        createdByRole: userdata?.role || '',
+        createdByEmail: userdata?.email || '',
+        createdByUserName: userdata?.userName || '',
+        createdByUserId: userdata?._id || '',
+      },
+    };
+    console.log( '🚀 ~ getAuditFile ~ updatePayload:', updatePayload );
+    console.log( '🚀 ~ getAuditFile ~ ticketSource:', ticketSource );
+    if ( ticketSource ) {
+      await updateOpenSearchData(
+          openSearch.footfallDirectory,
+          docId,
+          updatePayload,
+      );
+    }
+
+    console.log( '🚀 ~ reAssignAudit ~ inputData.dateString:', inputData.dateString );
+    await updatemanyvmsUserAudit(
+        { auditStatus: { $ne: 'completed' }, storeId: inputData.storeId, fileDate: inputData.dateString },
+        { status: 'skipped' } );
+
+
+    return res.sendSuccess( 'Ticket Reassigned Successfully' );
+  } catch ( error ) {
+    const err = error.message || 'Internal Server Error';
+    logger.error( {
+      error: error,
+      message: req.query,
+      function: 'reAssignAudit',
+    } );
+    return res.sendError( err, 500 );
+  }
+}
+
+

package/src/dtos/client.dtos.js

@@ -360,12 +360,15 @@ export const updateFDConfigBodySchema = joi.object( {
   tangoReview: joi.string().optional(),
   revision: joi.array().items( joi.object( {
     actionType: joi.string().required(),
-    isChecked: joi.boolean().required(),
+    isChecked: joi.boolean().optional().default( false ),
   } ) ).optional(),
   taggingLimitation: joi.array().items( joi.object( {
+    iconName: joi.string().optional(),
+    name: joi.string().optional(),
     type: joi.string().required(),
     value: joi.number().required(),
     unit: joi.string().required(),
+    key: joi.string().required(),
   } ) ).optional(),
 
 } );
@@ -374,8 +377,12 @@ export const updateFDConfigQuerySchema = joi.object( {
   clientId: joi.string().required(),
 } );
 
+
+const todayDate = () => new Date().toISOString().split( 'T' )[0];
+
 export const getFDConfigSchema = joi.object( {
   clientId: joi.string().required(),
+  dateString: joi.string().optional().default( () => todayDate() ),
 } );
 
 export const updateFDConfigValid = {
@@ -392,6 +399,9 @@ export const updateTaggingTypeSchema = joi.object( {
     type: joi.string().required(),
     value: joi.number().required(),
     unit: joi.string().required(),
+    name: joi.string().required(),
+    iconName: joi.string().required(),
+    key: joi.string().required(),
   } ) ).required(),
 
 } );

package/src/dtos/vmsAudit.dtos.js

@@ -0,0 +1,25 @@
+
+import joi from 'joi';
+export const getDraftedDataSchema = joi.object( {
+  storeId: joi.string().required(),
+  fileDate: joi.string().required(),
+  userId: joi.string().optional(),
+  auditId: joi.string().required(),
+} );
+export const getFileSchema = joi.object( {
+  nextId: joi.string().optional().allow( '' ),
+  limit: joi.number().optional(),
+  storeId: joi.string().required(),
+  Date: joi.string().required(),
+  count: joi.string().required(),
+  tickettype: joi.string().required(),
+} );
+
+
+export const getDraftedDataValid = {
+  query: getDraftedDataSchema,
+};
+
+export const getFileValid = {
+  query: getFileSchema,
+};

package/src/routes/vmsAudit.routes.js

@@ -0,0 +1,11 @@
+import express from 'express';
+import { accessVerification, isAllowedSessionHandler, validate } from 'tango-app-api-middleware';
+import { getDraftedDataValid, getFileValid } from '../dtos/vmsAudit.dtos.js';
+import { getAuditFile, getDraftedData, saveDraft, reAssignAudit } from '../controllers/vmsAudit.controller.js';
+export const vmsauditRouter = express.Router();
+
+
+vmsauditRouter.get( '/get-file', isAllowedSessionHandler, accessVerification( { userType: [ 'tango' ] } ), validate( getFileValid ), getAuditFile );
+vmsauditRouter.post( '/save-draft', isAllowedSessionHandler, accessVerification( { userType: [ 'tango' ] } ), saveDraft );
+vmsauditRouter.get( '/get-drafted-data', isAllowedSessionHandler, accessVerification( { userType: [ 'tango' ] } ), validate( getDraftedDataValid ), getDraftedData );
+vmsauditRouter.post( '/reAssign-audit', isAllowedSessionHandler, accessVerification( { userType: [ 'tango' ] } ), reAssignAudit );

package/src/service/vmsauditLog.service.js

@@ -0,0 +1,10 @@
+import vmsauditLogsModel from 'tango-api-schema/schema/vmsauditLogs.model.js';
+
+
+export function createvmsAuditLog( record ) {
+  return vmsauditLogsModel.create( record );
+}
+
+export function findOnevmsAuditLog( query, fields={}, sort={ createdAt: -1 }, limit=10 ) {
+  return vmsauditLogsModel.findOne( query, fields ).sort( sort ).limit( limit );
+}

package/src/service/vmsuserAudit.service.js

@@ -0,0 +1,25 @@
+import vmsuserAuditModel from 'tango-api-schema/schema/vmsuserAudit.model.js';
+
+
+export function aggregatevmsUserAudit( query ) {
+  return vmsuserAuditModel.aggregate( query, { collation: { locale: 'en', strength: 2 } } );
+}
+
+export function updateOnevmsUserAudit( query, record ) {
+  return vmsuserAuditModel.updateOne( query, { $set: record } );
+}
+export function updatemanyvmsUserAudit( query, record ) {
+  return vmsuserAuditModel.updateMany( query, { $set: record } );
+}
+
+export function createvmsUserAudit( record ) {
+  return vmsuserAuditModel.create( record );
+}
+
+export function findOnevmsUserAudit( query, fields ) {
+  return vmsuserAuditModel.findOne( query, fields );
+}
+
+export function aggregatevmsUserAuditCount( query ) {
+  return vmsuserAuditModel.aggregate( query );
+}