tango-app-api-store-builder 1.0.0-beta-178 → 1.0.0-beta-180

package/package.json

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

package/src/controllers/fixtureTemplate.controller.js

@@ -72,7 +72,14 @@ export async function updateTemplate( req, res ) {
     if ( !templateDetails ) {
       return res.sendError( 'No data found', 204 );
     }
-    inputData.isEdited = true;
+    let checkName = await fixtureConfigService.find( { _id: { $nin: req.params.templateId }, fixtureName: inputData.fixtureName } );
+    if ( checkName ) {
+      return res.sendError( 'Fixture name already exist', 400 );
+    }
+    let checkstoreMapped = await storeFixtureService.findOne( { fixtureConfigId: req.params.templateId } );
+    if ( checkstoreMapped ) {
+      inputData.isEdited = true;
+    }
     await fixtureConfigService.updateOne( { _id: req.params.templateId }, inputData );
     return res.sendSuccess( 'Fixture template details updated successfully' );
   } catch ( e ) {
@@ -1315,9 +1322,7 @@ export async function getTreeList( req, res ) {
         let storeFixtureCount = await storeFixtureService.count( { fixtureConfigId: fixt._id } );
         fixt.vmConfig = await Promise.all( fixt.vmConfig.map( async ( vm ) => {
           let vmDetails = await vmService.findOne( { _id: vm.vmId }, { _id: 0 } );
-          if ( vmDetails ) {
-            return { ...vm, ...vmDetails.toObject() };
-          }
+          return { ...vm, ...vmDetails?.toObject() };
         } ) );
         return { ...fixt, storeCount: storeFixtureCount };
       } ) );
@@ -1367,6 +1372,7 @@ export async function duplicateTemplate( req, res ) {
     delete templateDetails.templateGroupName;
     templateDetails.fixtureName = newFixtureName;
     templateDetails.status = 'complete';
+    templateDetails.isEdited = false;
     let duplicateDetails = await fixtureConfigService.create( templateDetails );
     return res.sendSuccess( { message: type == 'sub' ? 'Fixture template duplicated successfully' : 'Variant created successfully', id: duplicateDetails?._id } );
   } catch ( e ) {

package/src/controllers/managePlano.controller.js

@@ -8,7 +8,7 @@ import * as fixtureShelfService from '../service/fixtureShelf.service.js';
 import * as planoVmService from '../service/planoVm.service.js';
 // import * as planoMappingService from '../service/planoMapping.service.js';
 // import * as planoTaskService from '../service/planoTask.service.js';
-// import * as processedTaskService from '../service/processedTaskservice.js';
+import * as processedTaskService from '../service/processedTaskservice.js';
 import * as planoproductCategoryService from '../service/planoproductCategory.service.js';
 import * as fixtureConfigService from '../service/fixtureConfig.service.js';
 import * as fixtureLibraryService from '../service/planoLibrary.service.js';
@@ -23,14 +23,12 @@ export async function getplanoFeedback( req, res ) {
     const filterByApprovalStatus = req.body.filterByApprovalStatus || '';
     const resultMap = {};
     const commentMap = {};
-    console.log( taskTypes );
     await Promise.all(
         taskTypes.map( async ( type, index ) => {
           const pipeline = buildPipelineByType( type, req.body.planoId, req.body.floorId, filterByStatus, filterByApprovalStatus, req.body.showtask );
 
           let data = await planoTaskService.aggregate( pipeline );
           if ( filterByApprovalStatus && filterByApprovalStatus !== '' ) {
-            console.log( '-------------1', filterByApprovalStatus );
             data.forEach( ( element ) => {
               element.answers?.forEach( ( ans ) => {
                 ans.issues = ans.issues?.filter(
@@ -73,7 +71,7 @@ export async function getplanoFeedback( req, res ) {
     return res.sendError( e, 500 );
   }
 }
-function buildPipelineByType( type, planoId, floorId, filterByStatus, filterByApprovalStatus, showtask, taskId=0 ) {
+function buildPipelineByType( type, planoId, floorId, filterByStatus, filterByApprovalStatus, showtask, taskId = 0 ) {
   console.log( type, planoId, floorId, filterByStatus );
   const matchStage = {
     $match: {
@@ -312,7 +310,7 @@ function buildPipelineByType( type, planoId, floorId, filterByStatus, filterByAp
     pipeline.push( { $sort: { _id: -1 } } );
   }
 
-  console.log( pipeline );
+
   return pipeline;
 }
 
@@ -380,7 +378,6 @@ export async function getStoreFixturesfeedback( req, res ) {
 
 
     let findPlanoCompliance = await planoTaskService.aggregate( query );
-    console.log( findPlanoCompliance.length );
     res.sendSuccess( { count: findPlanoCompliance.length, data: findPlanoCompliance } );
   } catch ( e ) {
     logger.error( { functionName: 'getplanoFeedbackFixture', error: e, message: req.body } );
@@ -541,8 +538,6 @@ export async function fixtureVMList( req, res ) {
 }
 export async function updateFixtureStatus( req, res ) {
   try {
-    console.log( req.body );
-
     let comments = {
       userId: req.user._id,
       userName: req.user.userName,
@@ -550,7 +545,7 @@ export async function updateFixtureStatus( req, res ) {
       responsetype: req.body.type,
       comment: req.body.comments,
     };
-    console.log( comments );
+
 
     let updateResponse = await planoTaskService.updateOnefilters(
         { _id: new mongoose.Types.ObjectId( req.body._id ) },
@@ -564,11 +559,8 @@ export async function updateFixtureStatus( req, res ) {
 
         ] );
     if ( updateResponse && updateResponse.answers.length > 0 ) {
-      console.log( updateResponse.answers[0] );
       let findissuse = updateResponse.answers[0].issues.filter( ( data ) => data._id == req.body.issueId );
-      console.log( findissuse );
       let findDetails = findissuse[0].Details.filter( ( det ) => det.status === 'agree' );
-      console.log( '======', findDetails.length );
       if ( findissuse[0].Details.length === findDetails.length ) {
         await planoTaskService.updateOnefilters(
             { _id: new mongoose.Types.ObjectId( req.body._id ) },
@@ -581,9 +573,7 @@ export async function updateFixtureStatus( req, res ) {
             ] );
       }
       let findoneplanoData = await planoTaskService.findOne( { _id: new mongoose.Types.ObjectId( req.body._id ) } );
-      console.log( '************', findoneplanoData.answers[0].issues );
       let totalApproved = findoneplanoData.answers[0].issues.filter( ( data ) => data.status === 'pending' );
-      console.log( '---------->', totalApproved.length );
       if ( totalApproved.length === 0 ) {
         await planoTaskService.updateOne(
             {
@@ -652,6 +642,17 @@ export async function updateFixtureStatus( req, res ) {
   }
 }
 
+export async function updateApprovalStatus( req, res ) {
+  try {
+    await planoTaskService.updateOnefilters(
+        { _id: new mongoose.Types.ObjectId( req.body._id ) },
+        { $set: { approvalStatus: 'approved' } } );
+    res.sendSuccess( 'updated successfully' );
+  } catch ( e ) {
+    logger.error( { functionName: 'updateApprovalStatus', error: e } );
+    return res.sendError( e, 500 );
+  }
+}
 export async function updateRolloutStatus( req, res ) {
   try {
     let comments = {
@@ -662,40 +663,95 @@ export async function updateRolloutStatus( req, res ) {
       comment: req.body.comments,
     };
 
-    let updateResponse = await planoTaskService.updateOnefilters(
-        { _id: new mongoose.Types.ObjectId( req.body._id ) },
-        {
-          $set: { 'answers.$[ans].issues.$[iss].Details.$[det].status': req.body.type },
-        },
-        [
-          { 'ans._id': new mongoose.Types.ObjectId( req.body.answerId ) },
-          { 'iss._id': new mongoose.Types.ObjectId( req.body.issueId ) },
-          { 'det._id': new mongoose.Types.ObjectId( req.body.DetailsId ) },
-
-        ] );
-    if ( updateResponse && updateResponse.answers.length > 0 ) {
-      let findissuse = updateResponse.answers[0].issues.filter( ( data ) => data._id == req.body.issueId );
-      let findDetails = findissuse[0].Details.filter( ( det ) => det.status === 'agree' );
-      if ( findissuse[0].Details.length === findDetails.length ) {
-        await planoTaskService.updateOnefilters(
-            { _id: new mongoose.Types.ObjectId( req.body._id ) },
-            {
-              $set: { 'answers.$[ans].issues.$[iss].status': 'completed' },
+    if ( req.body.issueId && req.body.DetailsId ) {
+      let updateResponse = await planoTaskService.updateOnefilters(
+          { _id: new mongoose.Types.ObjectId( req.body._id ) },
+          {
+            $set: {
+              'answers.$[ans].issues.$[iss].Details.$[det].status': req.body.type,
+              'answers.$[ans].issues.$[iss].Details.$[det].adminStatus': req.body.type === 'agree' ? 'approved' : 'Unapproved',
             },
-            [
-              { 'ans._id': new mongoose.Types.ObjectId( req.body.answerId ) },
-              { 'iss._id': new mongoose.Types.ObjectId( req.body.issueId ) },
-            ] );
+          },
+          [
+            { 'ans._id': new mongoose.Types.ObjectId( req.body.answerId ) },
+            { 'iss._id': new mongoose.Types.ObjectId( req.body.issueId ) },
+            { 'det._id': new mongoose.Types.ObjectId( req.body.DetailsId ) },
+
+          ],
+      );
+      if ( updateResponse && updateResponse.answers.length > 0 ) {
+        let findissuse = updateResponse.answers[0].issues.filter( ( data ) => data._id == req.body.issueId );
+        let findDetails = findissuse[0].Details.filter( ( det ) => det.status === 'agree' );
+        if ( findissuse[0].Details.length === findDetails.length ) {
+          await planoTaskService.updateOnefilters(
+              { _id: new mongoose.Types.ObjectId( req.body._id ) },
+              {
+                $set: { 'answers.$[ans].issues.$[iss].status': 'completed' },
+              },
+              [
+                { 'ans._id': new mongoose.Types.ObjectId( req.body.answerId ) },
+                { 'iss._id': new mongoose.Types.ObjectId( req.body.issueId ) },
+              ] );
+        }
+        let findoneplanoData = await planoTaskService.findOne( { _id: new mongoose.Types.ObjectId( req.body._id ) } );
+        let totalApproved = findoneplanoData.answers[0].issues.filter( ( data ) => data.status === 'pending' );
+        if ( totalApproved.length === 0 ) {
+          await planoTaskService.updateOne(
+              {
+                _id: new mongoose.Types.ObjectId( req.body._id ),
+              },
+              {
+                'status': 'complete',
+                'approvalStatus': 'approved',
+              },
+          );
+          let data = {};
+          if ( req.body.taskType == 'vmRollout' ) {
+            data['isVmEdited'] = false;
+          } else {
+            data['isMerchEdited'] = false;
+          }
+          await storeFixtureService.updateOne( { _id: updateResponse.fixtureId }, data );
+        }
       }
-      let findoneplanoData = await planoTaskService.findOne( { _id: new mongoose.Types.ObjectId( req.body._id ) } );
-      let totalApproved = findoneplanoData.answers[0].issues.filter( ( data ) => data.status === 'pending' );
-      if ( totalApproved.length === 0 ) {
+      await planoTaskService.updateOnefilters(
+          { _id: new mongoose.Types.ObjectId( req.body._id ) },
+          {
+            $push: { 'answers.$[ans].issues.$[iss].comments': comments },
+          },
+          [
+            { 'ans._id': new mongoose.Types.ObjectId( req.body.answerId ) },
+            { 'iss._id': new mongoose.Types.ObjectId( req.body.issueId ) },
+          ],
+      );
+    } else {
+      let updateResponse = await planoTaskService.updateOnefilters(
+          { _id: new mongoose.Types.ObjectId( req.body._id ) },
+          {
+            $set: {
+              'answers.$[ans].status': req.body.type,
+            },
+          },
+          [
+            { 'ans._id': new mongoose.Types.ObjectId( req.body.answerId ) },
+          ],
+      );
+      await planoTaskService.updateOnefilters(
+          { _id: new mongoose.Types.ObjectId( req.body._id ) },
+          {
+            $push: { 'answers.$[ans].comments': comments },
+          },
+          [
+            { 'ans._id': new mongoose.Types.ObjectId( req.body.answerId ) },
+          ],
+      );
+      if ( req.body.type == 'agree' ) {
         await planoTaskService.updateOne(
             {
               _id: new mongoose.Types.ObjectId( req.body._id ),
             },
             {
-              'status': 'complete',
+              'approvalStatus': 'approved',
             },
         );
         let data = {};
@@ -707,15 +763,7 @@ export async function updateRolloutStatus( req, res ) {
         await storeFixtureService.updateOne( { _id: updateResponse.fixtureId }, data );
       }
     }
-    await planoTaskService.updateOnefilters(
-        { _id: new mongoose.Types.ObjectId( req.body._id ) },
-        {
-          $push: { 'answers.$[ans].issues.$[iss].comments': comments },
-        },
-        [
-          { 'ans._id': new mongoose.Types.ObjectId( req.body.answerId ) },
-          { 'iss._id': new mongoose.Types.ObjectId( req.body.issueId ) },
-        ] );
+
     res.sendSuccess( 'updated successfully' );
   } catch ( e ) {
     logger.error( { functionName: 'updateFixtureStatus', error: e } );
@@ -742,11 +790,11 @@ export async function updateStoreFixture( req, res ) {
 
       if ( typeof shelf?.productPerShelf === 'number' ) {
         if ( shelf?.shelfType === 'shelf' ) {
-          fixtureCapacity+=shelf.productPerShelf;
+          fixtureCapacity += shelf.productPerShelf;
         }
 
         if ( shelf?.shelfType === 'tray' ) {
-          fixtureCapacity+=( shelf?.productPerShelf * shelf?.trayRows );
+          fixtureCapacity += ( shelf?.productPerShelf * shelf?.trayRows );
         }
       }
 
@@ -827,7 +875,6 @@ export async function updateStoreFixture( req, res ) {
 
 export async function updateredostatus( req, res ) {
   try {
-    console.log( '------->', req.body );
     if ( req.body.type === 'layout' ) {
       await planoTaskService.updateOne(
           {
@@ -976,13 +1023,10 @@ export async function getRolloutFeedback( req, res ) {
     const commentMap = {};
     await Promise.all(
         taskTypes.map( async ( type, index ) => {
-          console.log( type );
           const pipeline = buildPipelineByType( type, req.body.planoId, req.body.floorId, filterByStatus, filterByApprovalStatus, req.body.showtask, req.body.taskId );
 
           let data = await planoTaskService.aggregate( pipeline );
-          console.log( data );
           if ( filterByApprovalStatus && filterByApprovalStatus !== '' ) {
-            console.log( '-------------1', filterByApprovalStatus );
             data.forEach( ( element ) => {
               element.answers?.forEach( ( ans ) => {
                 ans.issues = ans.issues?.filter(
@@ -1024,3 +1068,238 @@ export async function getRolloutFeedback( req, res ) {
 }
 
 
+export async function getRolloutFeedbackv2( req, res ) {
+  try {
+    const taskTypes = req.body.filterByTask && req.body.filterByTask.length > 0 ? req.body.filterByTask : [ 'merchRollout', 'vmRollout' ];
+    const filterByStatus = req.body.filterByStatus || [];
+    const filterByApprovalStatus = req.body.filterByApprovalStatus || '';
+    const resultMap = {};
+    const commentMap = {};
+    await Promise.all(
+        taskTypes.map( async ( type, index ) => {
+          const pipeline = pipelineStage( type, req.body.planoId, req.body.floorId, filterByStatus, filterByApprovalStatus, req.body.showtask );
+          const data = await processedTaskService.aggregate( pipeline );
+          resultMap[type] = data;
+        } ) );
+    const response = {
+      merchRolloutData: resultMap['merchRollout'] || [],
+      vmRolloutData: resultMap['vmRollout'] || [],
+      merchRolloutComment: commentMap['merchRollout'] || [],
+      vmRolloutComment: commentMap['vmRollout'] || [],
+    };
+    res.sendSuccess( response );
+  } catch ( e ) {
+    logger.error( { functionName: 'getRolloutFeedbackv2', error: e } );
+    return res.sendError( e, 500 );
+  }
+}
+
+
+function pipelineStage( type, planoId, floorId, filterByStatus, filterByApprovalStatus, showtask, taskId = 0 ) {
+  let matchStage = [ {
+    $match: {
+      'planoType': type,
+      'planoId': new mongoose.Types.ObjectId( planoId ),
+      'floorId': new mongoose.Types.ObjectId( floorId ),
+    },
+  },
+
+  {
+    $project: {
+      'planoId': 1,
+      'floorId': 1,
+      'planoType': 1,
+      'userName': 1,
+      'date_string': 1,
+      'createdByName': 1,
+      'createdAt': 1,
+      'submitTime_string': 1,
+      'redoStatus': 1,
+      'checklistStatus': 1,
+    },
+  },
+  ];
+  let taskLookup = {
+    $lookup: {
+      from: 'planotaskcompliances',
+      let: { taskId: '$_id' },
+      pipeline: [
+        {
+          $match: {
+            $expr: {
+              $eq: [ '$taskId', '$$taskId' ],
+            },
+          },
+        },
+
+      ],
+      as: 'planoData',
+    },
+  };
+  let unwindTask = {
+    $unwind: {
+      path: '$planoData',
+      preserveNullAndEmptyArrays: true,
+    },
+  };
+
+
+  const commonLookups = type === 'layout' ? [] : [
+    {
+      $lookup: {
+        from: 'storefixtures',
+        let: { fixtureId: '$planoData.fixtureId' },
+        pipeline: [
+          {
+            $match: { $expr: { $eq: [ '$_id', '$$fixtureId' ] } },
+          },
+        ],
+        as: 'FixtureData',
+      },
+    },
+    {
+      $unwind: { path: '$FixtureData', preserveNullAndEmptyArrays: true },
+    },
+    {
+      $lookup: {
+        from: 'fixtureshelves',
+        let: { fixtureId: '$FixtureData._id' },
+        pipeline: [
+          {
+            $match: { $expr: { $eq: [ '$fixtureId', '$$fixtureId' ] } },
+          },
+        ],
+        as: 'Fixtureshelves',
+      },
+    },
+
+    {
+      $set: {
+        'FixtureData.shelfConfig': '$Fixtureshelves',
+      },
+    },
+  ];
+
+  const vmStages = [ 'vm', 'vmRollout' ].includes( type ) ? [
+    {
+      $unwind: { path: '$FixtureData.vmConfig', preserveNullAndEmptyArrays: true },
+    },
+    {
+      $lookup: {
+        from: 'planovmdetails',
+        let: { vmId: '$FixtureData.vmConfig.vmId' },
+        pipeline: [
+          {
+            $match: { $expr: { $eq: [ '$_id', '$$vmId' ] } },
+          },
+          {
+            $project: { vmName: 1, vmType: 1 },
+          },
+        ],
+        as: 'vmDetails',
+      },
+    },
+    {
+      $unwind: { path: '$vmDetails', preserveNullAndEmptyArrays: true },
+    },
+    {
+      $set: {
+        'FixtureData.vmConfig.vmName': '$vmDetails.vmName',
+        'FixtureData.vmConfig.vmType': '$vmDetails.vmType',
+      },
+    },
+    {
+      $group: {
+        _id: {
+          taskId: '$taskId',
+          fixtureId: '$FixtureData._id',
+        },
+        rootDoc: { $first: '$$ROOT' },
+        vmConfigs: { $push: '$FixtureData.vmConfig' },
+      },
+    },
+    {
+      $addFields: {
+        'rootDoc.FixtureData.vmConfig': '$vmConfigs',
+      },
+    },
+    {
+      $replaceRoot: { newRoot: '$rootDoc' },
+    },
+
+
+  ] : [];
+  let finalGrouping = [
+    {
+      $group: {
+        '_id': '$_id',
+        'planoId': { $first: '$planoId' },
+        'floorId': { $first: '$floorId' },
+        'planoType': { $first: '$planoType' },
+        'userName': { $first: '$userName' },
+        'date_string': { $first: '$date_string' },
+        'createdByName': { $first: '$createdByName' },
+        'createdAt': { $first: '$createdAt' },
+        'submitTime_string': { $first: '$submitTime_string' },
+        'redoStatus': { $first: '$redoStatus' },
+        'checklistStatus': { $first: '$checklistStatus' },
+        'storeFixtureList': {
+          $push: {
+            $cond: [
+              {
+                $and: [
+                  {
+                    $or: [
+                      { $eq: [ '$redoStatus', true ] },
+                      {
+                        $and: [
+                          { $eq: [ '$redoStatus', false ] },
+                          { $eq: [ '$checklistStatus', 'submit' ] },
+                        ],
+                      },
+                    ],
+                  },
+                  { $gt: [ { $size: { $ifNull: [ '$Fixtureshelves', [] ] } }, 0 ] },
+                  { $gt: [ { $size: { $ifNull: [ '$FixtureData.shelfConfig', [] ] } }, 0 ] },
+                ],
+              },
+              {
+                FixtureData: '$FixtureData',
+                Fixtureshelves: '$Fixtureshelves',
+                approvalStatus: '$planoData.approvalStatus',
+                answers: '$planoData.answers',
+                createdAt: '$planoData.createdAt',
+                date_iso: '$planoData.date_iso',
+                date_string: '$planoData.date_string',
+                fixtureId: '$planoData.fixtureId',
+                floorId: '$planoData.floorId',
+                planoId: '$planoData.planoId',
+                status: '$planoData.status',
+                storeId: '$planoData.storeId',
+                storeName: '$planoData.storeName',
+                taskId: '$planoData.taskId',
+                taskType: '$planoData.taskType',
+                type: '$planoData.type',
+                updatedAt: '$planoData.updatedAt',
+                _id: '$planoData._id',
+              },
+              '$$REMOVE',
+            ],
+          },
+        },
+      },
+    },
+  ];
+  let pipeline = [
+    ...matchStage,
+    taskLookup,
+    unwindTask,
+    ...commonLookups,
+    ...vmStages,
+    ...finalGrouping,
+    { $sort: { _id: 1 } },
+  ];
+
+  console.log( JSON.stringify( pipeline, 'pipeline' ) );
+  return pipeline;
+}