tango-app-api-store-builder 1.0.0-beta-85 → 1.0.0-beta-87

package/src/controllers/storeBuilder.controller.js

@@ -17,9 +17,6 @@ import * as fixtureConfigService from '../service/fixtureConfig.service.js';
 import * as planoStaticData from '../service/planoStaticData.service.js';
 
 
-import path from 'path';
-
-
 dayjs.extend( utc );
 dayjs.extend( customParseFormat );
 
@@ -556,7 +553,7 @@ export async function storeFixturesv1( req, res ) {
         {
           $or: [
             { _id: { $in: planoIds } },
-            { storeId: { $in: req.body.id } },
+            { storeName: { $in: req.body.id } },
           ],
         },
         { storeId: 1, storeName: 1, planoId: '$_id', productResolutionLevel: 1, scanType: 1, clientId: 1, validateShelfSections: 1 },
@@ -578,12 +575,12 @@ export async function storeFixturesv1( req, res ) {
                 let productCapacity = 0;
                 const layoutPolygonWithFixtures = await Promise.all(
                     floor.layoutPolygon.map( async ( element ) => {
-                      const fixtures = await storeFixtureService.find( {
+                      const fixtures = await storeFixtureService.findAndSort( {
                         floorId: floor._id,
                         associatedElementType: element.elementType,
                         associatedElementNumber: element.elementNumber,
                         fixtureType: 'wall',
-                      }, { shelfcount: 0 } );
+                      }, { shelfcount: 0 }, { fixtureNumber: 1 } );
 
                       const fixturesWithStatus = await Promise.all(
                           fixtures.map( async ( fixture ) => {
@@ -2023,12 +2020,12 @@ export async function storeFixturesTask( req, res ) {
                 let productCapacity = 0;
                 const layoutPolygonWithFixtures = await Promise.all(
                     floor.layoutPolygon.map( async ( element ) => {
-                      const fixtures = await storeFixtureService.find( {
+                      const fixtures = await storeFixtureService.findAndSort( {
                         floorId: floor._id,
                         associatedElementType: element.elementType,
                         associatedElementNumber: element.elementNumber,
                         fixtureType: 'wall',
-                      }, { shelfcount: 0 } );
+                      }, { shelfcount: 0 }, { fixtureNumber: 1 } );
 
                       const fixturesWithStatus = await Promise.all(
                           fixtures.map( async ( fixture ) => {

package/src/controllers/task.controller.js

@@ -4,7 +4,7 @@ import * as storeService from '../service/store.service.js';
 import * as processedChecklistService from '../service/processedchecklist.service.js';
 import * as userService from '../service/user.service.js';
 import dayjs from 'dayjs';
-import { logger, fileUpload, signedUrl } from 'tango-app-api-middleware';
+import { logger, fileUpload, signedUrl, download } from 'tango-app-api-middleware';
 import * as planoTaskService from '../service/planoTask.service.js';
 import * as planoService from '../service/planogram.service.js';
 import * as checklistService from '../service/checklist.service.js';
@@ -202,45 +202,47 @@ export async function createTask( req, res ) {
       await Promise.all( storeDetails.map( async ( store ) => {
         let getUserEmail = req.body.stores.find( ( ele ) => ele.store.toLowerCase() == store.storeName.toLowerCase() );
         let planoDetails = await planoService.findOne( { storeId: store.storeId } );
-        if ( getUserEmail ) {
-          let query = [
-            {
-              $addFields: {
-                emailLower: { $toLower: '$email' },
+        if ( planoDetails ) {
+          if ( getUserEmail ) {
+            let query = [
+              {
+                $addFields: {
+                  emailLower: { $toLower: '$email' },
+                },
               },
-            },
-            {
-              $match: {
-                clientId: req.body.clientId,
-                email: getUserEmail.email.toLowerCase(),
+              {
+                $match: {
+                  clientId: req.body.clientId,
+                  email: getUserEmail.email.toLowerCase(),
+                },
               },
-            },
-          ];
-          userDetails = await userService.aggregate( query );
-          // if ( !userDetails.length ) {
-          //   let userData = {
-          //     clientId: req.body.clientId,
-          //     mobileNumber: '',
-          //     email: getUserEmail.email,
-          //     userName: getUserEmail.email.split( '@' )[0],
-          //   };
-          //   userDetails = await createUser( userData );
-          // } else {
-          userDetails = userDetails[0];
-          // }
-        }
-        let taskData = { ...data };
-        taskData.store_id = store.storeId;
-        taskData.storeName = store.storeName;
-        taskData.userId = userDetails._id;
-        taskData.userName = userDetails.userName;
-        taskData.userEmail = userDetails.email;
-        taskData.planoId = planoDetails?._id;
-        for ( let i=0; i<req.body.days; i++ ) {
-          let currDate = dayjs().add( i, 'day' );
-          let insertData = { ...taskData, date_string: currDate.format( 'YYYY-MM-DD' ), date_iso: new Date( currDate.format( 'YYYY-MM-DD' ) ), scheduleStartTime_iso: dayjs.utc( `${currDate.format( 'YYYY-MM-DD' )} 12:00 AM`, 'YYYY-MM-DD hh:mm A' ).format() };
-          let response = await processedService.updateOne( { date_string: currDate.format( 'YYYY-MM-DD' ), store_id: insertData.store_id, userEmail: insertData.userEmail, planoId: insertData.planoId, sourceCheckList_id: task._id }, insertData );
-          console.log( insertData.store_id, response );
+            ];
+            userDetails = await userService.aggregate( query );
+            // if ( !userDetails.length ) {
+            //   let userData = {
+            //     clientId: req.body.clientId,
+            //     mobileNumber: '',
+            //     email: getUserEmail.email,
+            //     userName: getUserEmail.email.split( '@' )[0],
+            //   };
+            //   userDetails = await createUser( userData );
+            // } else {
+            userDetails = userDetails[0];
+            // }
+          }
+          let taskData = { ...data };
+          taskData.store_id = store.storeId;
+          taskData.storeName = store.storeName;
+          taskData.userId = userDetails._id;
+          taskData.userName = userDetails.userName;
+          taskData.userEmail = userDetails.email;
+          taskData.planoId = planoDetails?._id;
+          for ( let i=0; i<req.body.days; i++ ) {
+            let currDate = dayjs().add( i, 'day' );
+            let insertData = { ...taskData, date_string: currDate.format( 'YYYY-MM-DD' ), date_iso: new Date( currDate.format( 'YYYY-MM-DD' ) ), scheduleStartTime_iso: dayjs.utc( `${currDate.format( 'YYYY-MM-DD' )} 12:00 AM`, 'YYYY-MM-DD hh:mm A' ).format() };
+            let response = await processedService.updateOne( { date_string: currDate.format( 'YYYY-MM-DD' ), store_id: insertData.store_id, userEmail: insertData.userEmail, planoId: insertData.planoId, sourceCheckList_id: task._id }, insertData );
+            console.log( insertData.store_id, response );
+          }
         }
       } ) );
     } ) );
@@ -378,9 +380,9 @@ export async function getTaskDetails( req, res ) {
     if ( !req.query.storeId ) {
       return res.sendError( 'Store id is required', 400 );
     }
-    let date = req.query?.date || dayjs().format( 'YYYY-MM-DD' );
-    let getDetails = await processedService.find( { store_id: req.query.storeId, date_string: date, isPlano: true, checklistStatus: { $ne: 'submit' }, userId: req.user._id }, { checkListName: 1, taskType: '$planoType', checklistStatus: 1 } );
-    return res.sendSuccess( getDetails );
+    // let date = req.query?.date || dayjs().format( 'YYYY-MM-DD' );
+    // let getDetails = await processedService.find( { store_id: req.query.storeId, date_string: date, isPlano: true, checklistStatus: { $ne: 'submit' }, userId: req.user._id }, { checkListName: 1, taskType: '$planoType', checklistStatus: 1 } );
+    return res.sendSuccess( [] );
   } catch ( e ) {
     logger.error( { functionName: 'getTaskDetails', error: e } );
     return res.sendError( e, 500 );
@@ -491,6 +493,9 @@ export async function updateAnswers( req, res ) {
       }
     } );
 
+    let taskDetails = await processedService.findOne( { date_string: dayjs().format( 'YYYY-MM-DD' ), userId: req.user._id, isPlano: true, planoType: 'layout' } );
+
+
     let data = {
       fixtureId: req.body.fixtureId,
       answers: req.body.answers,
@@ -498,9 +503,12 @@ export async function updateAnswers( req, res ) {
       planoId: req.body.planoId,
       floorId: req.body.floorId,
       type: req.body.type,
+      date_iso: new Date( dayjs().format( 'YYYY-MM-DD' ) ),
+      taskId: taskDetails?._id,
+      storeName: taskDetails?.storeName,
     };
 
-    await planoTaskService.updateOne( { planoId: req.body.planoId, floorId: req.body.floorId, fixtureId: req.body.fixtureId, type: req.body.type, date_string: dayjs().format( 'YYYY-MM-DD' ) }, data );
+    await planoTaskService.updateOne( { planoId: req.body.planoId, floorId: req.body.floorId, fixtureId: req.body.fixtureId, type: req.body.type, date_string: dayjs().format( 'YYYY-MM-DD' ), ...( taskDetails?._id ) ? { taskId: taskDetails?._id } :{} }, data );
     return res.sendSuccess( 'Fixture details updated successfully' );
   } catch ( e ) {
     logger.error( { functionName: 'updateAnswers', error: e } );
@@ -608,3 +616,161 @@ export async function getVmDetails( req, res ) {
     return res.sendError( e, 500 );
   }
 }
+
+export async function generatetaskDetails( req, res ) {
+  try {
+    let query =[
+      {
+        $match: {
+          date_iso: { $gte: new Date( req.body.fromDate ), $lte: new Date( req.body.toDate ) },
+          isPlano: true,
+          planoType: 'layout',
+        },
+      },
+      {
+        $project: {
+          _id: 0,
+          storeName: 1,
+          store_id: 1,
+          userEmail: 1,
+          planoId: 1,
+          checklistStatus: 1,
+          date_string: 1,
+          storeStatus: {
+            $cond: {
+              if: { $eq: [ '$checklistStatus', 'submit' ] },
+              then: 'Yes',
+              else: '',
+
+            },
+          },
+        },
+      },
+      {
+        $group: {
+          _id: '$store_id',
+          count: { $sum: 1 },
+          storeName: { $first: '$storeName' },
+          checklistStatus: { $push: '$checklistStatus' },
+        },
+      },
+      {
+        $project: {
+          _id: 0,
+          storeName: 1,
+          checklistStatus: 1,
+          count: 1,
+        },
+      },
+    ];
+    console.log( JSON.stringify( query ) );
+    let taskDetails = await processedService.aggregate( query );
+    let processedTaskDetails = await planoTaskService.find( { date_string: { $gte: req.body.fromDate, $lte: req.body.toDate }, type: 'layout', status: 'incomplete' } );
+    processedTaskDetails.forEach( ( item ) => {
+      let taskIndex = taskDetails.findIndex( ( taskItem ) => taskItem.checklistStatus == 'submit' && item.date_string == taskItem.date_string && item.planoId.toString() == taskItem.planoId.toString() );
+      if ( taskIndex != -1 ) {
+        taskDetails[taskIndex].storeStatus = 'No';
+      }
+    } );
+
+    taskDetails.forEach( ( ele ) => {
+      delete ele.planoId;
+    } );
+    // console.log( taskDetails );
+    // let completeStore = [ ...new Set( taskDetails.filter( ( ele ) => ele.checklistStatus.includes( 'submit' ) ).map( ( ele ) => ele.storeName ) ) ];
+
+    // let incompleteStore = [ ...new Set( taskDetails.filter( ( ele ) => !ele.checklistStatus.includes( 'submit' ) ).map( ( ele ) => {
+    //   return { storeName: ele.storeName, checklistStatus: ele.checklistStatus[ele.checklistStatus.length-1] };
+    // } ) ) ];
+
+    // incompleteStore = incompleteStore.filter( ( ele ) => !completeStore.includes( ele ) );
+
+    if ( !taskDetails.length ) {
+      return res.sendError( 'No date found', 204 );
+    }
+
+    // return res.sendSuccess( { completeCount: completeStore.length, store: completeStore, incompleteStore: incompleteStore, incompleteStoreCount: incompleteStore.length } );
+
+    await download( taskDetails, res );
+  } catch ( e ) {
+    logger.error( { functioName: 'generatetaskDetails', error: e } );
+    return res.sendError( e, 500 );
+  }
+}
+
+export async function taskSubmitDetails( req, res ) {
+  try {
+    let query = [
+      {
+        $match: {
+          date_string: { $gte: req.body.fromDate, $lte: req.body.toDate },
+          type: 'layout',
+        },
+      },
+      {
+        $lookup: {
+          from: 'planograms',
+          let: { plano_id: '$planoId' },
+          pipeline: [
+            {
+              $match: {
+                $expr: {
+                  $and: [
+                    { $eq: [ '$_id', '$$plano_id' ] },
+                  ],
+                },
+              },
+            },
+            {
+              $project: {
+                storeName: 1,
+                _id: 0,
+              },
+            },
+          ],
+          as: 'planogram',
+        },
+      },
+      { $unwind: { path: '$planogram', preserveNullAndEmptyArrays: true } },
+      {
+        $project: {
+          storeName: '$planogram.storeName',
+          answers: 1,
+          type: 1,
+          status: 1,
+          planoId: 1,
+          floorId: 1,
+        },
+      },
+      {
+        $group: {
+          _id: '$planoId',
+          storeName: { $first: '$storeName' },
+          answers: { $last: '$answers' },
+          type: { $last: '$type' },
+          status: { $last: '$status' },
+          floorId: { $last: '$floorId' },
+        },
+      },
+      {
+        $project: {
+          storeName: 1,
+          answers: 1,
+          type: 1,
+          status: 1,
+          planoId: '$_id',
+          floorId: 1,
+        },
+      },
+    ];
+
+    let processedTaskDetails = await planoTaskService.aggregate( query );
+    let completeStore = [ ...new Set( processedTaskDetails.filter( ( ele ) => ele.status == 'complete' ).map( ( ele ) => ele.storeName ) ) ];
+    let incompleteStore = [ ...new Set( processedTaskDetails.filter( ( ele ) => ele.status == 'incomplete' ).map( ( ele ) => ele.storeName ) ) ];
+    incompleteStore = incompleteStore.filter( ( ele ) => !completeStore.includes( ele ) );
+    return res.sendSuccess( { complete: { count: completeStore.length, storeList: completeStore }, incompleteStore: { count: incompleteStore.length, storeList: incompleteStore }, data: processedTaskDetails } );
+  } catch ( e ) {
+    logger.error( { functioName: 'taskSubmitDetails', error: e } );
+    return res.sendError( e, 500 );
+  }
+}

package/src/routes/script.routes.js

@@ -23,5 +23,9 @@ scriptRouter
     .post( '/getVmTaskData', scriptController.getVmTaskData )
     .post( '/updateVmData', scriptController.updateVmData )
     .post( '/createCrestPlanogram', scriptController.createCrestPlanogram )
+    .post( '/updateCrestPlanogram', scriptController.updateCrestPlanogram )
     .post( '/updatelayout', scriptController.updatelayout )
-    .post( '/updateCrestVms', scriptController.updateCrestVms );
+    .post( '/updateCrestVms', scriptController.updateCrestVms )
+    .post( '/downloadPlanoImages', scriptController.downloadPlanoImage )
+    .post( '/getVideoUrls', scriptController.getVideoLinks )
+    .post( '/updateExcelPlanogram', scriptController.updateExcelPlanogram );

package/src/routes/storeBuilder.routes.js

@@ -10,7 +10,7 @@ export const storeBuilderRouter = express.Router();
 storeBuilderRouter
     .post( '/createStoreLayout', isAllowedSessionHandler, validate( validateDtos.createBuilder ), storeBuilderController.createStoreBuilder )
     .post( '/updateStoreLayout', isAllowedSessionHandler, validate( validateDtos.updateStoreLayout ), storeBuilderController.updateStoreLayout )
-    .post( '/storeLayoutList', isAllowedSessionHandler, validate( validateDtos.storeLayoutList ), storeBuilderController.getLayoutList )
+    .post( '/storeLayoutList', validate( validateDtos.storeLayoutList ), storeBuilderController.getLayoutList )
     .post( '/updateFloor', isAllowedSessionHandler, validate( validateDtos.updateFloor ), storeBuilderController.updateFloor )
     .post( '/uploadBulkStore', isAllowedSessionHandler, storeBuilderController.uploadBulkStore )
     .post( '/uploadFile', isAllowedSessionHandler, storeBuilderController.uploadFile )
@@ -23,7 +23,7 @@ storeBuilderRouter
     // .post( '/FixtureShelfDetails', storeBuilderController.fixtureShelfProduct )
     // .post( '/scan', storeBuilderController.scan )
     .post( '/storeLayout', isAllowedSessionHandler, validate( validateDtos.storeList ), storeBuilderController.storeLayout )
-    .post( '/storeFixtures', isAllowedSessionHandler, validate( validateDtos.storeList ), storeBuilderController.storeFixturesv1 )
+    .post( '/storeFixtures', validate( validateDtos.storeList ), storeBuilderController.storeFixturesv1 )
     .post( '/FixtureShelfDetails', isAllowedSessionHandler, validate( validateDtos.fixtureShelfProduct ), storeBuilderController.fixtureShelfProductv1 )
     .post( '/scan', isAllowedSessionHandler, storeBuilderController.scanv1 )
     .post( '/updateMissing', isAllowedSessionHandler, storeBuilderController.updateMissing )

package/src/routes/task.routes.js

@@ -12,4 +12,6 @@ storeBuilderTaskRouter
     .post( '/updateStatus', isAllowedSessionHandler, taskController.updateStatus )
     .post( '/updateAnswers', isAllowedSessionHandler, taskController.updateAnswers )
     .get( '/getFixtureDetails', isAllowedSessionHandler, taskController.getFixtureDetails )
-    .get( '/getVmDetails', isAllowedSessionHandler, taskController.getVmDetails );
+    .get( '/getVmDetails', isAllowedSessionHandler, taskController.getVmDetails )
+    .post( '/generateTaskExcel', taskController.generatetaskDetails )
+    .post( '/getSubmitDetails', taskController.taskSubmitDetails );

package/src/service/planoTask.service.js

@@ -19,3 +19,7 @@ export async function find( query={}, field={} ) {
 export async function count( data ) {
   return model.planoTaskCompliance.countDocuments( data );
 }
+
+export async function aggregate( query ) {
+  return model.planoTaskCompliance.aggregate( query );
+}

package/src/service/processedTaskservice.js

@@ -16,6 +16,10 @@ export async function deleteMany( query = {} ) {
   return model.taskProcessedModel.deleteMany( query );
 }
 
+export async function aggregate( query = {} ) {
+  return model.taskProcessedModel.aggregate( query );
+}
+
 export async function find( query = {}, field = {} ) {
   return model.taskProcessedModel.find( query, field );
 }