tango-app-api-store-builder 1.0.0-beta-126 → 1.0.0-beta-128

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "tango-app-api-store-builder",
-    "version": "1.0.0-beta-126",
+    "version": "1.0.0-beta-128",
     "description": "storeBuilder",
     "main": "index.js",
     "type": "module",

package/src/controllers/managePlano.controller.js

@@ -220,6 +220,142 @@ export async function getplanoFeedback( req, res ) {
     {
       $unwind: { path: '$FixtureData', preserveNullAndEmptyArrays: true },
     },
+    {
+      $unwind: { path: '$FixtureData.vmConfig', preserveNullAndEmptyArrays: true },
+    },
+    {
+      $lookup: {
+        from: 'planovmdetails',
+        let: { 'vmId': '$FixtureData.vmConfig.vmId' },
+        pipeline: [
+          {
+            $match: {
+              $expr: {
+                $and: [
+                  { $eq: [ '$_id', '$$vmId' ] },
+                ],
+              },
+            },
+          },
+          {
+            $project: {
+              vmName: 1,
+            },
+          },
+        ],
+        as: 'vmDetails',
+      },
+    },
+    {
+      $unwind: { path: '$vmDetails', preserveNullAndEmptyArrays: true },
+    },
+    {
+      $project: {
+        '_id': 1,
+        'answers': 1,
+        'createdAt': 1,
+        'date_iso': 1,
+        'date_string': 1,
+        'fixtureId': 1,
+        'floorId': 1,
+        'planoId': 1,
+        'status': 1,
+        'taskType': 1,
+        'FixtureData': 1,
+        'FixtureData': {
+          _id: '$FixtureData._id',
+          clientId: '$FixtureData.clientId',
+          clientId: '$FixtureData.clientId',
+          fixtureCapacity: '$FixtureData.fixtureCapacity',
+          fixtureCategory: '$FixtureData.fixtureCategory',
+          fixtureLength: '$FixtureData.fixtureLength',
+          fixtureLibraryId: '$FixtureData.fixtureLibraryId',
+          fixtureName: '$FixtureData.fixtureName',
+          fixtureStaticLength: '$FixtureData.fixtureStaticLength',
+          fixtureStaticWidth: '$FixtureData.fixtureStaticWidth',
+          fixtureType: '$FixtureData.fixtureType',
+          fixtureWidth: '$FixtureData.fixtureWidth',
+          footer: '$FixtureData.footer',
+          header: '$FixtureData.header',
+          isBodyEnabled: '$FixtureData.isBodyEnabled',
+          productBrandName: '$FixtureData.productBrandName',
+          productCategory: '$FixtureData.productCategory',
+          productResolutionLevel: '$FixtureData.productResolutionLevel',
+          productSubCategory: '$FixtureData.productSubCategory',
+          shelfConfig: '$FixtureData.shelfConfig',
+          status: '$FixtureData.status',
+          templateIndex: '$FixtureData.templateIndex',
+          shelfConfig: '$FixtureData.shelfConfig',
+          vmConfig: {
+            vmName: '$vmDetails.vmName',
+            endYPosition: '$FixtureData.vmConfig.endYPosition',
+            startYPosition: '$FixtureData.vmConfig.startYPosition',
+            vmId: '$FixtureData.vmConfig.vmId',
+            xZone: '$FixtureData.vmConfig.xZone',
+            yZone: '$FixtureData.vmConfig.yZone',
+            position: '$FixtureData.vmConfig.position',
+          },
+        },
+      },
+    },
+
+    {
+      $group: {
+        _id: '$_id',
+        answers: { $first: '$answers' },
+        createdAt: { $first: '$createdAt' },
+        date_iso: { $first: '$date_iso' },
+        date_string: { $first: '$date_string' },
+        fixtureId: { $first: '$fixtureId' },
+        floorId: { $first: '$floorId' },
+        planoId: { $first: '$planoId' },
+        status: { $first: '$status' },
+        taskType: { $first: '$taskType' },
+        baseFixtureData: { $first: '$FixtureData' },
+        collectedVmConfigs: {
+          $push: '$FixtureData.vmConfig',
+        },
+      },
+    },
+    {
+      $project: {
+        _id: 1,
+        answers: 1,
+        createdAt: 1,
+        date_iso: 1,
+        date_string: 1,
+        fixtureId: 1,
+        floorId: 1,
+        planoId: 1,
+        status: 1,
+        taskType: 1,
+        FixtureData: {
+          $mergeObjects: [
+            '$baseFixtureData',
+            {
+              vmConfig: {
+                $reduce: {
+                  input: '$collectedVmConfigs',
+                  initialValue: [],
+                  in: {
+                    $cond: [
+                      { $isArray: '$$this' },
+                      { $concatArrays: [ '$$value', '$$this' ] },
+                      { $concatArrays: [ '$$value', [ '$$this' ] ] },
+                    ],
+                  },
+                },
+              },
+            },
+          ],
+        },
+      },
+    },
+    {
+      $sort: { _id: -1 },
+    },
+
+
     );
 
 

package/src/controllers/planoLibrary.controller.js

@@ -217,10 +217,10 @@ export async function getFixture( req, res ) {
     if ( fixtureDetails ) {
       let planoStatus = await planoService.findOne( { planoId: fixtureDetails.planoId }, { status: 1 } );
       if ( planoStatus ) {
-        fixtureLibDetails.status = planoStatus.status == 'complete' ? 'Active' :'Inactive';
+        fixtureLibDetails.status = planoStatus.status == 'complete' ? 'active' :'inactive';
       }
     } else {
-      fixtureLibDetails.status = fixtureLibDetails.status == 'draft' ? 'Draft' : 'Inactive';
+      fixtureLibDetails.status = fixtureLibDetails.status == 'draft' ? 'draft' : 'inactive';
     }
     fixtureLibDetails = {
       ...fixtureLibDetails.toObject(),
@@ -1329,16 +1329,18 @@ export async function getVmDetails( req, res ) {
     getVmDetails = getVmDetails.toObject();
     getVmDetails.templateCount = 0;
     let templateDetails = await fixtureTemplateService.find( { 'vmConfig.vmId': { $in: req.query.vmId } } );
-    if ( templateDetails.length && getVmDetails.status != 'draft' ) {
-      getVmDetails.templateCount = templateDetails.length;
+    if ( getVmDetails.status != 'draft' ) {
       getVmDetails.status = 'inactive';
-      let fixtureDetails = await storeFixtureService.find( { 'vmConfig.vmId': { $in: req.query.vmId } }, { planoId: 1 } );
-      if ( fixtureDetails.length ) {
-        let planoList = fixtureDetails.map( ( ele ) => ele.planoId );
-        let planoDetails = await planoService.find( { _id: { $in: planoList } }, { status: 1 } );
-        planoDetails = planoDetails.map( ( ele ) => ele.status );
-        if ( planoDetails.includes( 'completed' ) ) {
-          getVmDetails.status = 'active';
+      if ( templateDetails.length ) {
+        getVmDetails.templateCount = templateDetails.length;
+        let fixtureDetails = await storeFixtureService.find( { 'vmConfig.vmId': { $in: req.query.vmId } }, { planoId: 1 } );
+        if ( fixtureDetails.length ) {
+          let planoList = fixtureDetails.map( ( ele ) => ele.planoId );
+          let planoDetails = await planoService.find( { _id: { $in: planoList } }, { status: 1 } );
+          planoDetails = planoDetails.map( ( ele ) => ele.status );
+          if ( planoDetails.includes( 'completed' ) ) {
+            getVmDetails.status = 'active';
+          }
         }
       }
     }

package/src/controllers/storeBuilder.controller.js

@@ -3205,6 +3205,43 @@ export async function planoList( req, res ) {
     let limit = inputData?.limit || 10;
     let page = inputData?.offset - 1 || 0;
     let skip = limit * page;
+    let planoList = await planoService.find( { clientId: req.body.clientId }, { _id: 1 } );
+    let idList = planoList?.map( ( ele ) => new mongoose.Types.ObjectId( ele._id ) );
+    let taskQuery = [
+      {
+        $match: {
+          planoId: { $in: idList },
+          isPlano: true,
+          date_iso: { $lte: new Date( dayjs().format( 'YYYY-MM-DD' ) ) },
+        },
+      },
+      {
+        $group: {
+          _id: { store: '$storeName', floorId: '$floorId', type: '$planoType' },
+          planoId: { $last: '$planoId' },
+          checklistStatus: { $last: '$checklistStatus' },
+          taskId: { $last: '$_id' },
+        },
+      },
+      {
+        $match: {
+          checklistStatus: 'submit',
+        },
+      },
+      {
+        $project: {
+          _id: 0,
+          type: '$_id.type',
+          planoId: 1,
+          checklistStatus: 1,
+          taskId: 1,
+          floorId: '$_id.floorId',
+        },
+      },
+    ];
+
+    let pendingDetails = await planotaskService.aggregate( taskQuery );
+    console.log( pendingDetails );
     let query = [
       {
         $match: {
@@ -3279,7 +3316,7 @@ export async function planoList( req, res ) {
             },
             {
               $group: {
-                _id: '$planoType',
+                _id: { type: '$planoType', floorId: '$floorId' },
                 dateString: { $last: '$date_string' },
                 checklistStatus: { $last: '$checklistStatus' },
                 taskId: { $last: '$_id' },
@@ -3290,9 +3327,10 @@ export async function planoList( req, res ) {
                 _id: null,
                 taskStatus: {
                   $push: {
-                    type: '$_id',
+                    type: '$_id.type',
                     status: '$checklistStatus',
                     date: '$dateString',
+                    floorId: '$_id.floorId',
                   },
                 },
                 taskIds: { $push: '$taskId' },
@@ -3302,23 +3340,21 @@ export async function planoList( req, res ) {
           as: 'planoTask',
         },
       },
-      {
-        $addFields: {
-          taskIds: { $ifNull: [ { $arrayElemAt: [ '$planoTask.taskIds', 0 ] }, [] ] },
-          taskStatus: { $ifNull: [ { $arrayElemAt: [ '$planoTask.taskStatus', 0 ] }, [] ] },
-        },
-      },
       {
         $lookup: {
           from: 'planotaskcompliances',
-          let: { plano: '$_id', taskId: '$taskIds' },
+          let: {
+            plano: '$_id',
+            task: { $ifNull: [ '$taskIds', [] ] },
+          },
           pipeline: [
             {
               $match: {
                 $expr: {
                   $and: [
                     { $eq: [ '$planoId', '$$plano' ] },
-                    { $in: [ '$taskId', '$$taskId' ] },
+                    { $in: [ '$taskId', pendingDetails.map( ( ele ) => ele.taskId ) ] },
+                    { $eq: [ '$taskType', 'initial' ] },
                   ],
                 },
               },
@@ -3326,7 +3362,7 @@ export async function planoList( req, res ) {
             { $sort: { _id: -1 } },
             {
               $group: {
-                _id: { type: '$type', planoId: '$planoId' },
+                _id: '$floorId',
                 layoutCount: {
                   $sum: {
                     $cond: {
@@ -3505,6 +3541,35 @@ export async function planoList( req, res ) {
                 },
               },
             },
+            {
+              $group: {
+                _id: null,
+                layoutCount: { $sum: '$layoutCount' },
+                fixtureCount: { $sum: '$fixtureCount' },
+                vmCount: { $sum: '$vmCount' },
+                completeLayout: {
+                  $sum: {
+                    $cond: {
+                      if: {
+                        $and: [
+                          { '$gt': [ '$layoutCount', 0 ] },
+                          { '$gt': [ '$layoutPending', 0 ] },
+                          { '$gt': [ '$fixtureCount', 0 ] },
+                          { '$gt': [ '$fixturePending', 0 ] },
+                          { '$gt': [ '$vmCount', 0 ] },
+                          { '$gt': [ '$fixturePending', 0 ] },
+                        ],
+                      },
+                      then: 1,
+                      else: 0,
+                    },
+                  },
+                },
+                layoutPending: { $sum: '$layoutPending' },
+                fixturePending: { $sum: '$fixturePending' },
+                vmPending: { $sum: '$vmPending' },
+              },
+            },
             {
               $project: {
                 _id: 0,
@@ -3602,6 +3667,7 @@ export async function planoList( req, res ) {
                 layoutCount: 1,
                 fixtureCount: 1,
                 vmCount: 1,
+                completeLayout: 1,
               },
             },
           ],
@@ -3673,12 +3739,12 @@ export async function planoList( req, res ) {
 
     if ( inputData.filter.status.length ) {
       if ( inputData.filter.status.includes( 'taskAssigned' ) ) {
-        orQuery.push( { 'planoTask.checklistStatus': { $in: [ 'open', 'inprogress' ] } } );
+        orQuery.push( { 'planoTask.taskStatus.status': { $in: [ 'open', 'inprogress' ] } } );
       }
       if ( inputData.filter.status.includes( 'reviewPending' ) ) {
-        orQuery.push( { $and: [ { 'taskDetails.layoutStatus': 'pending' }, { 'planoTask._id': 'layout' }, { 'planoTask.checklistStatus': 'submit' } ] } );
-        orQuery.push( { $and: [ { 'taskDetails.fixtureStatus': 'pending' }, { 'planoTask._id': 'fixture' }, { 'planoTask.checklistStatus': 'submit' } ] } );
-        orQuery.push( { $and: [ { 'taskDetails.vmStatus': 'pending' }, { 'planoTask._id': 'vm' }, { 'planoTask.checklistStatus': 'submit' } ] } );
+        orQuery.push( { $and: [ { 'taskDetails.layoutStatus': 'pending' }, { 'planoTask.taskStatus.type': 'layout' }, { 'planoTask.taskStatus.status': 'submit' } ] } );
+        orQuery.push( { $and: [ { 'taskDetails.fixtureStatus': 'pending' }, { 'planoTask.taskStatus.type': 'fixture' }, { 'planoTask.taskStatus.status': 'submit' } ] } );
+        orQuery.push( { $and: [ { 'taskDetails.vmStatus': 'pending' }, { 'planoTask.taskStatus.type': 'vm' }, { 'planoTask.taskStatus.status': 'submit' } ] } );
       }
       if ( inputData.filter.status.includes( 'complete' ) ) {
         orQuery.push( { 'taskDetails.layoutStatus': 'complete' } );
@@ -3710,53 +3776,17 @@ export async function planoList( req, res ) {
       },
     } );
 
-    console.log( JSON.stringify( query ) );
-
     let planoDetails = await planoService.aggregate( query );
 
     if ( !planoDetails[0].data.length ) {
       return res.sendError( 'No data found', 204 );
     }
 
-    let planoList = await planoService.find( { clientId: req.body.clientId }, { _id: 1 } );
-    let idList = planoList?.map( ( ele ) => new mongoose.Types.ObjectId( ele._id ) );
-    let taskQuery = [
-      {
-        $match: {
-          planoId: { $in: idList },
-          isPlano: true,
-          date_iso: { $lte: new Date( dayjs().format( 'YYYY-MM-DD' ) ) },
-        },
-      },
-      {
-        $group: {
-          _id: { store: '$storeName', type: '$planoType' },
-          planoId: { $last: '$planoId' },
-          checklistStatus: { $last: '$checklistStatus' },
-          taskId: { $last: '$_id' },
-        },
-      },
-      {
-        $match: {
-          checklistStatus: 'submit',
-        },
-      },
-      {
-        $project: {
-          _id: 0,
-          type: '$_id.type',
-          planoId: 1,
-          checklistStatus: 1,
-          taskId: 1,
-        },
-      },
-    ];
-
-    let pendingDetails = await planotaskService.aggregate( taskQuery );
     query = [
       {
         $match: {
           taskId: { $in: pendingDetails.map( ( ele ) => ele.taskId ) },
+          taskType: 'initial',
         },
       },
       {

package/src/controllers/task.controller.js

@@ -260,7 +260,7 @@ export async function createTask( req, res ) {
           let getUserEmail = req.body.stores.find( ( ele ) => ele.store.toLowerCase() == store.storeName.toLowerCase() );
           let planoDetails = await planoService.findOne( { storeName: store.storeName } );
           if ( planoDetails ) {
-            let floorDetails = await floorService.find( { planoId: planoDetails._id }, { _id: 1, floorName: 1 } );
+            let floorDetails = await floorService.find( { planoId: planoDetails._id, ...( req.body?.floorId ) ? { _id: req.body?.floorId }:{} }, { _id: 1, floorName: 1 } );
             for ( let i=0; i<floorDetails.length; i++ ) {
               if ( getUserEmail ) {
                 let query = [
@@ -290,11 +290,19 @@ export async function createTask( req, res ) {
               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' );
+              for ( let j=0; j<req.body.days; j++ ) {
+                let planoProgress = req.body.checkListName == 'Fixture Verification' ? 50 : req.body.checkListName == 'VM Verification' ? 75 : 25;
+                if ( req.body?.checkListName && req.body.checkListName == 'Layout Verification' ) {
+                  let taskIdList = await planoTaskService.find( { planoId: planoDetails?._id, floorId: taskData.floorId } );
+                  taskIdList = taskIdList.map( ( ele ) => ele.taskId );
+                  await planoTaskService.deleteMany( { planoId: planoDetails?._id, floorId: taskData.floorId } );
+                  planoProgress = 25;
+                  await processedService.deleteMany( { _id: taskIdList } );
+                }
+                await planoService.updateOne( { _id: planoDetails?._id }, { $set: { planoProgress } } );
+                let currDate = dayjs().add( j, '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, ...( taskData?.floorId ) ? { floorId: taskData.floorId }:{} }, insertData );
-                console.log( 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, ...( taskData?.floorId ) ? { floorId: taskData.floorId }:{} }, insertData );
               }
             }
           }

package/src/service/planoTask.service.js

@@ -26,3 +26,7 @@ export async function count( data ) {
 export async function aggregate( query ) {
   return model.planoTaskCompliance.aggregate( query );
 }
+
+export async function deleteMany( query ) {
+  return model.planoTaskCompliance.deleteMany( query );
+}