tango-app-api-audit 1.0.1 → 1.0.3

package/src/controllers/audit.controllers.js

@@ -0,0 +1,744 @@
+import { chunkArray, getJsonFileData, getUTC, listFileByPath, listFileWithoutLimit, signedUrl } from 'tango-app-api-middleware';
+import { aggregateUserAudit, createUserAudit } from '../service/userAudit.service.js';
+import { aggregateAssignAudit, updateOneAssignAudit } from '../service/assignAudit.service.js';
+import { findOneUser } from '../service/user.service.js';
+import dayjs from 'dayjs';
+import { aggregateClient } from '../service/client.service.js';
+import { logger } from 'tango-app-api-middleware';
+import { sqsReceive } from 'tango-app-api-middleware/src/utils/aws/sqs.js';
+import { createStoreAudit } from '../service/storeAudit.service.js';
+
+export async function getAuditFile( req, res ) {
+  try {
+    const bucket = JSON.parse( process.env.BUCKET );
+    const inputData = req.query;
+    const data = await getUTC( new Date(), new Date() );
+    const start = data.start;
+    const end = data.end;
+    const fetchData = {};
+    let msg = {};
+    const userQuery = [
+      {
+        $match: {
+          $and: [
+            { userId: req.user._id },
+            { queueName: inputData.queueName },
+            { auditStatus: { $nin: [ 'completed', 'skipped' ] } },
+            { createdAt: { $gte: start } },
+            { createdAt: { $lte: end } },
+          ],
+
+        },
+
+      },
+      {
+        $sort: { createdAt: -1 },
+      },
+      {
+        $limit: 1,
+      },
+    ];
+
+    const userDetails = await aggregateUserAudit( userQuery );
+    const auditStatus = userDetails && userDetails.length > 0 ? userDetails[0].auditStatus : null;
+
+    switch ( auditStatus ) {
+      case null:
+        const query = [
+          {
+            $match: {
+              $and: [
+                { userId: { $eq: req.user._id } },
+                { isCompleted: { $eq: false } },
+                { queueName: inputData.queueName },
+              ],
+            },
+          },
+        ];
+        const userAssign = await aggregateAssignAudit( query );
+        if ( userAssign.length > 0 ) {
+          logger.info( 'Hit in user assign', { inputData } );
+            userAssign[0].fileType == 'Audit' ?
+            msg = {
+              store_id: userAssign[0].storeId,
+              curr_date: userAssign[0].fileDate,
+              total_count: userAssign[0].fileCount,
+            } : msg = {
+              store_id: userAssign[0].storeId,
+              curr_date: userAssign[0].fileDate,
+              audit_type: userAssign[0].fileType,
+              total_count: userAssign[0].fileCount,
+            };
+            await updateOneAssignAudit( { _id: userAssign[0]._id }, { isCompleted: true } );
+            logger.info( 'Hit in auditUserAssignModel updateOne', { _id: userAssign[0]._id, isCompleted: true } );
+        } else {
+          logger.info( 'Hit in new file', { inputData } );
+          const consumer = await sqsReceive( inputData.queueName );
+          if ( !consumer ) {
+            logger.error( { error: consumer, function: 'getAuditFile', message: 'SQS Receive queue is empty' } );
+            return res.sendError( `${inputData.queueName} is Empty`, 204 );
+          }
+          msg = JSON.parse( consumer );
+        }
+        break;
+
+        // case 'drafted':
+        //   logger.info( 'userDetails drafted', { inputData } );
+        //   const log = await findOneUser( {
+        //     userId: userDetails[0].userId,
+        //     fileDate: userDetails[0].fileDate,
+        //     storeId: userDetails[0].storeId,
+        //     totalCount: userDetails[0].beforeCount,
+        //   }, {}, { createdAt: -1 } );
+        //   if ( log.length == 0 ) {
+        //     await audit.updateOne( { _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,
+        //     store_id: userDetails[0].storeId,
+        //     file_date: userDetails[0].fileDate,
+        //     type: userDetails[0].auditType,
+        //     queueName: log[0].queueName,
+        //     userId: log[0].userId,
+        //   };
+        //   const result = {
+        //     junk: log[0].junk,
+        //     junk_count: log[0].junkCount,
+        //     employee: log[0].employee,
+        //     employee_count: log[0].employeeCount,
+        //     customer: log[0].customer,
+        //     customer_count: log[0].customerCount,
+        //     retag_image: log[0].retagImage,
+        //     retag_count: log[0].retagCount,
+        //     total_count: log[0].totalCount,
+        //   };
+
+        //   const userdata = await findOneUser( { _id: log[0].userId } );
+        //   if ( !inputData.nextId || inputData.nextId === '' || inputData.nextId == null ) {
+        //     const logData = {
+        //       userId: log[0].userId,
+        //       userName: userdata.name,
+        //       logType: 'audit',
+        //       logSubType: 'auditStart',
+        //       logData: {
+        //         file_date: userDetails[0].fileDate,
+        //         auditType: userDetails[0].auditType,
+        //         storeId: userDetails[0].storeId,
+        //         clientName: log[0].queueName,
+        //         auditId:  userDetails[0]._id ,
+        //       },
+        //     };
+        //     logger.info( { logData: logData } );
+        //   //   await savelogs( logData );  Note : insert to os
+        //   }
+        //   return res.sendSuccess( {
+        //     result: result,
+        //     count: log[0].totalCount,
+        //     file: file,
+        //     isDraft: userDetails[0].isDraft,
+        //   } );
+        //   break;
+
+      default:
+        msg = {
+          store_id: userDetails[0].storeId,
+          curr_date: userDetails[0].fileDate,
+          audit_type: userDetails[0].auditType,
+          total_count: userDetails[0].beforeCount,
+        };
+        break;
+    }
+    if ( msg.audit_type === 'ReAudit' ) {
+      logger.info(
+          'Hit in user ReAudit'
+          , { inputData },
+      );
+      let reauditInsert = {};
+      const [ filterData, auditImage ] = await Promise.all( [
+        getFilterData( msg ),
+        getAuditImage( msg ),
+      ] );
+      if ( filterData.statusCode == 404 || auditImage.statusCode == 404 ) {
+        return res.sendError( 'No Data found', 204 );
+      }
+      const reauditImg = await getReauditImg( filterData, auditImage );
+      if ( userDetails.length === 0 ) {
+        const [ day, month, year ] = msg.curr_date.split( '-' );
+        const temp = `${year}-${month}-${day}`;
+        let start = new Date( temp );
+        const userTimezoneOffset = start.getTimezoneOffset() * 60000;
+        start = new Date( start.getTime() - userTimezoneOffset );
+        start.setUTCHours( 0, 0, 0, 0 );
+        const record = {
+          userId: req.user._id,
+          storeId: msg.store_id,
+          clientId: msg.store_id.split( '-' )[0],
+          auditType: msg.audit_type || 'ReAudit',
+          fileDate: msg.curr_date,
+          queueName: inputData.queueName,
+          beforeCount: reauditImg.length,
+          auditStatus: 'inprogress',
+          fileDateISO: start,
+          timeSpent: 0,
+          startTime: new Date(),
+        };
+        const storeRecord = {
+          userId: req.user._id,
+          storeId: msg.store_id,
+          clientId: msg.store_id.split( '-' )[0],
+          auditType: msg.audit_type || 'ReAudit',
+          fileDate: msg.curr_date,
+          queueName: inputData.queueName,
+          beforeCount: reauditImg.length,
+          status: 'inprogress',
+          fileDateISO: start,
+          timeSpent: 0,
+        };
+        reauditInsert = await createUserAudit( record );
+        await createStoreAudit( storeRecord );
+      } else {
+        reauditInsert = userDetails[0];
+      }
+      const userdata = await findOneUser( { _id: req.user._id } );
+      if ( inputData.nextId ) {
+        const logData = {
+          userId: req.user._id,
+          userName: userdata.name,
+          logType: 'audit',
+          logSubType: 'auditStart',
+          logData: {
+            fileDate: msg.curr_date,
+            auditType: msg.audit_type,
+            storeId: msg.store_id,
+            clientName: inputData.queueName,
+            auditId: reauditInsert._id,
+          },
+        };
+        logger.info( { logData: logData } );
+        // await savelogs( logData );   need to change
+      }
+
+      return res.sendSuccess(
+          {
+            result: reauditImg,
+            count: reauditImg.length,
+            file: {
+              store_id: msg.store_id,
+              file_date: msg.curr_date,
+              type: msg.audit_type || 'ReAudit',
+              queueName: inputData.queueName,
+              auditId: reauditInsert._id,
+              userId: reauditInsert.userId,
+            },
+            isDraft: reauditInsert.isDraft,
+          },
+      );
+    }
+    const storeId = msg.store_id;
+    const fileDate = msg.curr_date;
+    const files = [];
+    let insertData = {};
+    fetchData.Bucket = bucket.auditInput; // need to change
+    fetchData.file_path = `${fileDate}/${storeId}/`;
+    if ( inputData.limit ) {
+      fetchData.MaxKeys = inputData.limit;
+    }
+    if ( inputData.nextId ) {
+      fetchData.ContinuationToken = decodeURIComponent( inputData.nextId );
+    }
+    const [ folderPath, nextQuery ] = await listFileByPath( fetchData );
+    logger.info( { nextQuery: nextQuery } );
+    if ( folderPath?.length > 0 ) {
+      for ( let i = 0; i < folderPath.length; i++ ) {
+        const img = folderPath[i].Key.split( '/' );
+        const image = img[2].split( '.' );
+        const indexes = image[0].split( '_' );
+        fetchData.file_path = folderPath[i].Key;
+        const data = await signedUrl( fetchData );
+        const mapimg = {
+          img_path: data,
+          img_name: indexes[1],
+          img_id: image[0],
+        };
+        files.push( {
+          img_path: data,
+          img_name: indexes[1],
+          img_id: image[0],
+          selected: false,
+          dropped: false,
+          count: 1,
+          mappedid: [ mapimg ],
+        } );
+      }
+      if ( userDetails.length === 0 ) {
+        const [ day, month, year ] = msg.curr_date.split( '-' );
+        const temp = `${year}-${month}-${day}`;
+        let start = new Date( temp );
+        logger.info( { start: start, date: msg.curr_date } );
+        const userTimezoneOffset = start.getTimezoneOffset() * 60000;
+        start = new Date( start.getTime() - userTimezoneOffset );
+        start.setUTCHours( 0, 0, 0, 0 );
+        const record = {
+          userId: req.user._id,
+          storeId: msg.store_id,
+          clientId: msg.store_id.split( '-' )[0],
+          auditType: 'Audit',
+          fileDate: msg.curr_date,
+          queueName: inputData.queueName,
+          beforeCount: msg.total_count || files.length,
+          auditStatus: 'inprogress',
+          fileDateISO: start,
+          timeSpent: 0,
+          startTime: new Date(),
+        };
+        const storeRecord = {
+          userId: req.user._id,
+          storeId: msg.store_id,
+          clientId: msg.store_id.split( '-' )[0],
+          auditType: 'Audit',
+          fileDate: msg.curr_date,
+          queueName: inputData.queueName,
+          beforeCount: msg.total_count || files.length,
+          status: 'inprogress',
+          fileDateISO: start,
+          timeSpent: 0,
+        };
+
+        insertData = await createUserAudit( record );
+        await createStoreAudit( storeRecord );
+      } else {
+        insertData = userDetails[0];
+      }
+    } else {
+      logger.error( { error: { folderPath: folderPath, nextQuery: nextQuery }, function: 'getAuditFile', message: 'Bucket image data not availale' } );
+      return res.sendError( 'Bucket is Empty', 204 );
+    }
+    const userdata = await findOneUser( { _id: insertData.userId } );
+    if ( inputData.nextId ) {
+      const logData = {
+        userId: insertData.userId,
+        userName: userdata.name,
+        logType: 'audit',
+        logSubType: 'auditStart',
+        logData: {
+          fileDate: insertData.fileDate,
+          auditType: insertData.auditType,
+          storeId: storeId,
+          clientName: inputData.queueName,
+          auditId: insertData._id,
+        },
+      };
+      logger.info( logData );
+      // await savelogs( logData );
+    }
+
+    return res.sendSuccess( {
+      result: files,
+      count: msg.total_count,
+      file: {
+        queueName: inputData.queueName,
+        store_id: storeId,
+        file_date: fileDate,
+        type: 'Audit',
+        auditId: insertData._id,
+        userId: insertData.userId,
+        nextToken: nextQuery ? encodeURIComponent( nextQuery ) : null,
+      },
+      isDraft: insertData.isDraft,
+    } );
+  } catch ( error ) {
+    logger.error( { error: error, message: req.query, function: 'getAuditFile' } );
+    return res.sendError( error, 500 );
+  }
+}
+
+export async function getFilterData( msg ) {
+  try {
+    const bucket = JSON.parse( process.env.BUCKET );
+    const params = {
+      Bucket: `${bucket.auditOutput}`,
+      Key: `${msg.store_id}/${msg.curr_date}/${bucketName.masterJsonFile}`,
+    };
+    const mappingFile = await getJsonFileData( params );
+    if ( mappingFile.statusCode ) {
+      return mappingFile;
+    } else {
+      const mappingData = await JSON.parse( mappingFile.toString( 'utf-8' ) );
+      const filterData = await mappingData.person_data.filter( ( item ) => item.temp_ids < 20000 && item.temp_ids > 0 && item.person_status === '' );
+      const finalResult = await filterData.map( ( i ) => {
+        return { ...i, img: i.index.concat( '_', i.temp_ids ) };
+      } );
+      return finalResult;
+    }
+  } catch ( error ) {
+    logger.error( { error: error, type: 'MAPPING JSON getFilterData', function: 'getFilterData' } );
+    return error;
+  }
+};
+
+export async function getAuditImage( msg ) {
+  try {
+    const bucket = JSON.parse( process.env.BUCKET );
+    const storeId = msg.store_id;
+    const fileDate = msg.curr_date;
+    const files = [];
+    const fetchData = {};
+    fetchData.Bucket = `${bucket.auditInput}`;
+    fetchData.filePath = `${fileDate}/${storeId}/`;
+    const folderPath = await listFileWithoutLimit( fetchData );
+    if ( folderPath.statusCode == 404 ) {
+      return folderPath;
+    }
+    const auditImages = folderPath;
+    if ( auditImages && auditImages?.length > 0 ) {
+      for ( let i = 0; i < auditImages.length; i++ ) {
+        const img = auditImages[i].Key.split( '/' );
+        const image = img[2].split( '.' );
+        const indexes = image[0].split( '_' );
+        const params = {
+          file_path: auditImages[i].Key,
+          Bucket: fetchData.Bucket,
+        };
+        const data = await signedUrl( params );
+        const mapimg = {
+          img_path: data,
+          img_name: indexes[1],
+          img_id: image[0],
+        };
+        files.push( {
+          img_path: data,
+          img_name: indexes[1],
+          img_id: image[0],
+          selected: false,
+          dropped: false,
+          count: 1,
+          mappedid: [ mapimg ],
+        } );
+      }
+      return files;
+    }
+  } catch ( error ) {
+    logger.error( { error: error, type: 'GCP BUCKET --getAuditImage' } );
+    return error;
+  }
+};
+
+export const getReauditImg = async ( filter, image ) => {
+  const chunkedMappingData = await chunkArray( image, 10 );
+  const promises = chunkedMappingData.map( async ( chunk ) => {
+    return mapFunction( chunk, filter );
+  } );
+  const mappedArrays = await Promise.all( promises );
+  return mappedArrays.flat();
+};
+
+export const mapFunction = async ( chunk, filter ) => {
+  const temp = [];
+  for ( let i = 0; i < chunk.length; i++ ) {
+    filter.some( ( item ) => {
+      if ( chunk[i].img_name === item.temp_ids ) {
+        return temp.push( chunk[i] );
+      }
+    } );
+  }
+  return temp;
+};
+
+export async function getQueueDetailList( req, res ) {
+  try {
+    const inputData = req.query;
+    const data = await getUTC( new Date(), new Date() );
+
+    const temp = [];
+    const clientQuery = [
+      {
+        $match: {
+          $and: [
+            { active: { $in: [ 'active', 'hold' ] } },
+            { 'auditConfigs.audit': { $eq: true } },
+          ],
+        },
+      },
+      {
+        $project: {
+          clientName: '$clientName',
+          clientId: '$clientId',
+        },
+      },
+    ];
+
+    if ( inputData.searchValue ) {
+      clientQuery.push( {
+        $match: {
+          $or: [
+            { clientName: { $regex: inputData.searchValue, $options: 'i' } },
+            { clientId: { $regex: inputData.searchValue, $options: 'i' } },
+          ],
+        },
+      } );
+    }
+    const count = await aggregateClient( clientQuery );
+    if ( inputData.limit && inputData.offset && !inputData.export ) {
+      const skip = ( inputData.offset - 1 ) * inputData.limit;
+      clientQuery.push( { $skip: skip }, { $limit: inputData.limit } );
+    }
+
+    const clientDetails = await aggregateClient( clientQuery );
+    if ( clientDetails && clientDetails.length === 0 ) {
+      return res.sendError( 'No Data Found', 204 );
+    }
+
+    const clientList = clientDetails.map( ( i ) => i.clientId );
+    const query = [
+      {
+        $match: {
+          clientId: { $in: clientList },
+        },
+      },
+      {
+        $group: {
+          _id: '$clientId',
+          clientId: { $last: '$clientId' },
+          totalFilesCount: { $last: '$totalFilesCount' },
+          clientName: { $last: '$clientName' },
+          queueName: { $last: '$queueName' },
+
+        },
+      },
+      {
+        $project: {
+          clientId: 1,
+          totalFilesCount: 1,
+          clientName: 1,
+          queueName: 1,
+        },
+      },
+    ];
+
+    const fileDate = dayjs( data.start ).subtract( 1, 'days' );
+
+    const completedFiles = [
+      {
+        $match: {
+          $and: [
+            { clientId: { $in: clientList } },
+            { fileDateISO: { $eq: new Date( fileDate ) } },
+          ],
+        },
+      },
+      {
+        $project: {
+          clientId: 1,
+          completed: {
+            $cond: [ { $eq: [ '$storeStatus', 'completed' ] }, 1, 0 ],
+          },
+        },
+      },
+      {
+        $group: {
+          _id: { clientId: '$clientId', storeId: '$storeId' },
+          clientId: { $first: '$clientId' },
+          completedCount: { $sum: '$completed' },
+
+        },
+      },
+      {
+        $group: {
+          _id: '$clientId',
+          clientId: { $first: '$clientId' },
+          completedCount: { $first: '$completedCount' },
+        },
+      },
+    ];
+
+    const auditFiles = [
+      {
+        $match: {
+          $and: [
+            { clientId: { $in: clientList } },
+            { createdAt: { $gte: data.start } },
+            { createdAt: { $lte: data.end } },
+          ],
+        },
+      },
+      {
+        $project: {
+          clientId: 1,
+          pending: {
+            $cond: [ { $or: [ { $in: [ '$auditStatus', [ 'inprogress', 'drafted' ] ] }, { $in: [ '$storeStatus', [ 'skipped' ] ] } ] }, 1, 0 ],
+          },
+        },
+      },
+      {
+        $group: {
+          _id: { clientId: '$clientId', storeId: '$storeId' },
+          clientId: { $first: '$clientId' },
+          pendingCount: { $sum: '$pending' },
+          totalCount: { $sum: 1 },
+
+        },
+      },
+      {
+        $group: {
+          _id: '$clientId',
+          clientId: { $first: '$clientId' },
+          pendingCount: { $first: { $ifNull: [ '$pendingCount', 0 ] } },
+          totalCount: { $first: '$totalCount' },
+        },
+      },
+
+    ];
+
+    const draftedFiles = [
+      {
+        $match: {
+          $and: [
+            { clientId: { $in: clientList } },
+            { userId: { $eq: inputData.userId } },
+            { createdAt: { $gte: data.start } },
+            { createdAt: { $lte: data.end } },
+          ],
+        },
+      },
+      {
+        $sort: {
+          updatedAt: -1,
+        },
+      },
+      {
+        $project: {
+          clientId: 1,
+          isDraft: 1,
+          draft: {
+            $cond: [ { $eq: [ '$auditStatus', 'drafted' ] }, 1, 0 ],
+          },
+          inprogress: {
+            $cond: [ { $eq: [ '$auditStatus', 'inprogress' ] }, 1, 0 ],
+          },
+        },
+      },
+      {
+        $group: {
+          _id: '$clientId',
+          clientId: { $first: '$clientId' },
+          isDrafted: { $first: '$isDraft' },
+          draftCount: { $sum: '$draft' },
+          inprogressCount: { $sum: '$inprogress' },
+        },
+      },
+    ];
+
+    const userAsign = [
+      {
+        $match: {
+          $and: [
+            { userId: { $eq: req.user._id } },
+            { isCompleted: false },
+            { clientId: { $in: clientList } },
+          ],
+        },
+
+      },
+      {
+        $group: {
+          _id: '$clientId',
+          clientId: { $first: '$clientId' },
+          asignedCount: { $sum: 1 },
+        },
+      },
+      {
+        $project: {
+          _id: 0,
+          clientId: 1,
+          asignedCount: 1,
+        },
+      },
+    ];
+
+    const clientAssign = [
+      {
+        $match: {
+          $and: [
+
+            { isCompleted: false },
+            { clientId: { $in: clientList } },
+          ],
+        },
+
+      },
+      {
+        $group: {
+          _id: '$clientId',
+          clientId: { $first: '$clientId' },
+          ClientAsignedCount: { $sum: 1 },
+        },
+      },
+      {
+        $project: {
+          _id: 0,
+          clientId: 1,
+          ClientAsignedCount: { $ifNull: [ '$ClientAsignedCount', 0 ] },
+        },
+      },
+    ];
+
+    const auditDetails = await AuditFilesModel.aggregate( query );
+    const auditCount = await audit.aggregate( auditFiles );
+    const draftedCount = await audit.aggregate( draftedFiles );
+    const CompletedCount = await audit.aggregate( completedFiles );
+
+    const clientAssignresult = await auditUserAssignModel.aggregate( clientAssign );
+
+    const userAsignCount = await auditUserAssignModel.aggregate( userAsign );
+    const mergeAll = _.merge( _.keyBy( clientDetails, 'clientId' ), _.keyBy( auditCount, 'clientId' ), _.keyBy( draftedCount, 'clientId' ), _.keyBy( clientAssignresult, 'clientId' ) );
+    const finalResult = _.values( mergeAll );
+    const merge = _.values( _.merge( _.keyBy( finalResult, 'clientId' ), _.keyBy( auditDetails, 'clientId' ), _.keyBy( userAsignCount, 'clientId' ), _.keyBy( CompletedCount, 'clientId' ) ) );
+
+    let totalStores = 0;
+    for ( let i = 0; i < merge.length; i++ ) {
+      totalStores = totalStores + merge[i].totalFilesCount;
+
+      const pending = await listQueue( merge[i].queueName );
+      if ( !pending.statusCode ) {
+        temp.push( {
+          client_id: merge[i].clientId,
+          client_name: merge[i].clientName,
+          completedCount: merge[i].completedCount ? Number( merge[i].completedCount ) : 0,
+          pendingByQueue: Number( pending ),
+          pendingByUser: ( merge[i].pendingCount >= 0 ) ? Number( merge[i].pendingCount )+( merge[i].ClientAsignedCount ? Number( merge[i].ClientAsignedCount ) : 0 ) : 0,
+          totalCount: merge[i].totalFilesCount,
+          queue_name: merge[i].queueName,
+          isDraft: merge[i].isDrafted ? merge[i].isDrafted : false,
+          isEnable: Number( pending ) > 0 || merge[i].isDrafted || ( merge[i].asignedCount && merge[i].asignedCount > 0 ) || ( merge[i].inprogressCount && merge[i].inprogressCount > 0 ) ? true : false,
+          completedRatio: merge[i].totalFilesCount ? merge[i].completedCount ? Math.round( ( Number( merge[i].completedCount ) / Number( merge[i].totalFilesCount ) ) * 100 ) : 0 : 0,
+          isAssigned: merge[i].asignedCount && merge[i].asignedCount > 0 ? true : false,
+          Assignedcount: merge[i].asignedCount && merge[i].asignedCount > 0 ? merge[i].asignedCount : 0,
+        } );
+      }
+    }
+
+    if ( inputData.export == 'true' ) {
+      const exportdata = [];
+      temp.forEach( ( element ) => {
+        exportdata.push( {
+          'Client Name': element.client_name,
+          'Client Id': element.client_id,
+          'Completed Percentage': element.completedRatio + ' %',
+          'Pending Queue': element.pendingByQueue,
+          'Pending User': element.pendingByUser,
+          'Completed': element.completedCount,
+          'Draft': element.isDraft ? 1 : 0,
+          'Assigned': element.Assignedcount,
+        } );
+      } );
+      await download( exportdata, res );
+      return;
+    } else {
+      return res.sendSuccess( { result: temp, count: count.length, totalStores: totalStores } );
+    }
+  } catch ( error ) {
+    return res.sendError( error );
+  }
+}