tango-app-api-store-builder 1.0.0-beta-134 → 1.0.0-beta-136

package/package.json

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

package/src/controllers/fixtureTemplate.controller.js

@@ -26,7 +26,7 @@ export async function createTemplate( req, res ) {
         ( acc, ele ) => ele.trayRows ? acc + ( ele.trayRows * ele.productPerShelf ) : ( acc + ele.productPerShelf ),
         0,
     );
-    let templateId = await getTemplateId();
+    let templateId = await getTemplateId( getLibDetails.fixtureCategory, getLibDetails.fixtureWidth );
     let templateData = {
       clientId: inputData.clientId,
       fixtureLibraryId: inputData.fixtureLibraryId,
@@ -49,6 +49,7 @@ export async function createTemplate( req, res ) {
         value: 1220,
         unit: 'mm',
       },
+      templateIndex: parseInt( templateId.split( '-' )[1] ),
     };
     let fixtureData = await fixtureConfigService.create( templateData );
     return res.sendSuccess( { message: 'Fixture template created successfully', fixtureData } );
@@ -58,15 +59,11 @@ export async function createTemplate( req, res ) {
   }
 }
 
-async function getTemplateId() {
-  let templateId = 'Template01';
-  let fixtureTemplateData = await fixtureConfigService.find( { fixtureName: { $exists: true } }, { fixtureName: 1 } );
-  let fixtureData = fixtureTemplateData.map( ( ele ) => ele.fixtureName.split( '-' )[0] );
-  let count = 1;
-  while ( fixtureData.includes( templateId ) ) {
-    count = count + 1;
-    let countId = String( count ).padStart( 2, '0' );
-    templateId =`Template${countId}`;
+async function getTemplateId( name, width ) {
+  let templateId = 'Template-1';
+  let fixtureTemplateData = await fixtureConfigService.sortAndFindOne( { 'fixtureCategory': name, 'fixtureWidth.unit': width.unit, 'fixtureWidth.value': width.value }, { templateIndex: 1 }, { _id: -1 } );
+  if ( fixtureTemplateData.length ) {
+    templateId= `Template-${fixtureTemplateData[0].templateIndex + 1}`;
   }
   return templateId;
 }
@@ -164,7 +161,7 @@ export async function deleteTemplate( req, res ) {
 
 export async function duplicateTemplate( req, res ) {
   try {
-    let templateDetails = await fixtureConfigService.findOne( { _id: req.body.templateId } );
+    let templateDetails = await fixtureConfigService.findOne( { _id: req.body.templateId }, { createdAt: 0, updatedAt: 0 } );
     if ( !templateDetails ) {
       return res.sendError( 'No data found', 204 );
     }
@@ -282,12 +279,14 @@ export async function getTemplateList( req, res ) {
               $group: {
                 _id: null,
                 planoId: { $addToSet: '$planoId' },
+                storeList: { $addToSet: '$storeName' },
               },
             },
             {
               $project: {
                 _id: 0,
                 planoId: 1,
+                storeList: 1,
               },
             },
           ],
@@ -301,6 +300,42 @@ export async function getTemplateList( req, res ) {
           fixtureWidth: 1,
           productBrandName: 1,
           productCategory: 1,
+          shelfProduct: {
+            $reduce: {
+              input: '$shelfConfig',
+              initialValue: [],
+              in: {
+                $concatArrays: [
+                  '$$value',
+                  { $ifNull: [ '$$this.productBrandName', [] ] },
+                ],
+              },
+            },
+          },
+          shelfProductCategory: {
+            $reduce: {
+              input: '$shelfConfig',
+              initialValue: [],
+              in: {
+                $concatArrays: [
+                  '$$value',
+                  { $ifNull: [ '$$this.productCategory', [] ] },
+                ],
+              },
+            },
+          },
+          shelfProductSubCategory: {
+            $reduce: {
+              input: '$shelfConfig',
+              initialValue: [],
+              in: {
+                $concatArrays: [
+                  '$$value',
+                  { $ifNull: [ '$$this.productSubCategory', [] ] },
+                ],
+              },
+            },
+          },
           clientId: 1,
           productSubCategory: 1,
           status: 1,
@@ -316,6 +351,7 @@ export async function getTemplateList( req, res ) {
             },
           },
           planoId: { $ifNull: [ { $arrayElemAt: [ '$storeFixtureDetails.planoId', 0 ] }, [] ] },
+          storeList: { $ifNull: [ { $arrayElemAt: [ '$storeFixtureDetails.storeList', 0 ] }, [] ] },
         },
       },
       {
@@ -345,16 +381,18 @@ export async function getTemplateList( req, res ) {
           fixtureCategory: 1,
           fixtureName: 1,
           fixtureWidth: 1,
-          productBrandName: 1,
-          productCategory: 1,
+          productBrandName: { $concatArrays: [ '$productBrandName', '$shelfProduct' ] },
+          productCategory: { $concatArrays: [ '$productCategory', '$shelfProductCategory' ] },
           clientId: 1,
           fixtureType: 1,
-          productSubCategory: 1,
+          productSubCategory: { $concatArrays: [ '$productSubCategory', '$shelfProductSubCategory' ] },
           status: 1,
           templateId: 1,
           planoId: 1,
           vmCapacity: 1,
           productCapacity: 1,
+          storeList: 1,
+          storeCount: { $size: '$storeList' },
           planoStatus: { $ifNull: [ { $arrayElemAt: [ '$planoStatus.statusList', 0 ] }, [] ] },
           status: {
             $cond: {

package/src/controllers/managePlano.controller.js

@@ -18,180 +18,103 @@ import mongoose from 'mongoose';
 import * as planoRevisionService from '../service/planoRevision.service.js';
 export async function getplanoFeedback( req, res ) {
   try {
-    let query = [];
-
-    query.push( {
-      $match: {
-        planoId: new mongoose.Types.ObjectId( req.body.planoId ),
-        floorId: new mongoose.Types.ObjectId( req.body.floorId ),
-        type: 'layout',
-      },
-    },
-    {
-      $lookup: {
-        from: 'processedtasks',
-        let: { 'taskId': '$taskId' },
-        pipeline: [
-          {
-            $match: {
-              $expr: {
-                $and: [
-                  { $eq: [ '$_id', '$$taskId' ] },
-                ],
-              },
-            },
-          },
-          {
-            $project: {
-              'userName': 1,
-              'createdAt': 1,
-              'createdByName': 1,
-              'submitTime_string': 1,
-            },
-          },
-        ],
-        as: 'taskData',
-      },
-
-    }, { $unwind: { path: '$taskData', preserveNullAndEmptyArrays: true } },
-    { $sort: { _id: -1 } },
+    const taskTypes = req.body.filterByTask && req.body.filterByTask.length > 0 ? req.body.filterByTask : [ 'layout', 'fixture', 'vm' ];
+    const filterByStatus = req.body.filterByStatus || [];
+    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 );
+
+          const data = await planoTaskService.aggregate( pipeline );
+          console.log( '-------', data );
+          resultMap[type] = data;
+
+          const comments = await planoGlobalCommentService.find( {
+            planoId: new mongoose.Types.ObjectId( req.body.planoId ),
+            floorId: new mongoose.Types.ObjectId( req.body.floorId ),
+            taskType: type,
+          } );
+          commentMap[type] = comments;
+        } ),
     );
 
+    const response = {
+      layoutData: resultMap['layout'] || [],
+      fixtureData: resultMap['fixture'] || [],
+      VmData: resultMap['vm'] || [],
+      layoutComment: commentMap['layout'] || [],
+      fixtureComment: commentMap['fixture'] || [],
+      vmComment: commentMap['vm'] || [],
+    };
 
-    let findPlanoCompliance = await planoTaskService.aggregate( query );
-    let queryfixture = [];
-
-
-    queryfixture.push( {
-      $match: {
-        planoId: new mongoose.Types.ObjectId( req.body.planoId ),
-        floorId: new mongoose.Types.ObjectId( req.body.floorId ),
-        type: 'fixture',
-      },
+    res.sendSuccess( response );
+  } catch ( e ) {
+    logger.error( { functionName: 'getplanoFeedback', error: e, message: req.body } );
+    return res.sendError( e, 500 );
+  }
+}
+function buildPipelineByType( type, planoId, floorId, filterByStatus, filterByApprovalStatus ) {
+  console.log( type, planoId, floorId, filterByStatus );
+  const matchStage = {
+    $match: {
+      planoId: new mongoose.Types.ObjectId( planoId ),
+      floorId: new mongoose.Types.ObjectId( floorId ),
+      type: type,
+      ...( filterByStatus?.length ? { status: { $in: filterByStatus } } : {} ),
     },
-    {
-      $lookup: {
-        from: 'processedtasks',
-        let: { 'taskId': '$taskId' },
-        pipeline: [
-          {
-            $match: {
-              $expr: {
-                $and: [
-                  { $eq: [ '$_id', '$$taskId' ] },
-                ],
-              },
-            },
-          },
-          {
-            $project: {
-              'userName': 1,
-              'createdAt': 1,
-              'createdByName': 1,
-              'submitTime_string': 1,
-            },
-          },
-        ],
-        as: 'taskData',
-      },
+  };
 
-    }, { $unwind: { path: '$taskData', preserveNullAndEmptyArrays: true } },
-    {
-      $lookup: {
-        from: 'storefixtures',
-        let: { 'fixtureId': '$fixtureId' },
-        pipeline: [
-          {
-            $match: {
-              $expr: {
-                $and: [
-                  { $eq: [ '$_id', '$$fixtureId' ] },
-                ],
-              },
+  const taskLookup = {
+    $lookup: {
+      from: 'processedtasks',
+      let: { taskId: '$taskId' },
+      pipeline: [
+        {
+          $match: {
+            $expr: {
+              $and: [
+                { $eq: [ '$_id', '$$taskId' ] },
+                {
+                  $or: [
+                    { $eq: [ '$redoStatus', true ] },
+                    {
+                      $and: [
+                        { $eq: [ '$redoStatus', false ] },
+                        { $eq: [ '$checklistStatus', 'submit' ] },
+                      ],
+                    },
+                  ],
+                },
+              ],
             },
           },
-        ],
-        as: 'storeFixtureData',
-      },
-    },
-    {
-      $unwind: { path: '$storeFixtureData', preserveNullAndEmptyArrays: true },
-    },
-    {
-      $lookup: {
-        from: 'fixtureconfigs',
-        let: { 'fixtureConfigId': '$storeFixtureData.fixtureConfigId' },
-        pipeline: [
-          {
-            $match: {
-              $expr: {
-                $and: [
-                  { $eq: [ '$_id', '$$fixtureConfigId' ] },
-                ],
-              },
-            },
+        },
+        {
+          $project: {
+            userName: 1,
+            createdAt: 1,
+            createdByName: 1,
+            submitTime_string: 1,
           },
-        ],
-        as: 'FixtureData',
-      },
-    },
-    {
-      $unwind: { path: '$FixtureData', preserveNullAndEmptyArrays: true },
+        },
+      ],
+      as: 'taskData',
     },
-    );
+  };
 
+  const unwindTask = { $unwind: { path: '$taskData', preserveNullAndEmptyArrays: false } };
 
-    let findfixtureCompliance = await planoTaskService.aggregate( queryfixture );
-    let queryVm = [];
-
-
-    queryVm.push( {
-      $match: {
-        planoId: new mongoose.Types.ObjectId( req.body.planoId ),
-        floorId: new mongoose.Types.ObjectId( req.body.floorId ),
-        type: 'vm',
-      },
-    },
-    {
-      $lookup: {
-        from: 'processedtasks',
-        let: { 'taskId': '$taskId' },
-        pipeline: [
-          {
-            $match: {
-              $expr: {
-                $and: [
-                  { $eq: [ '$_id', '$$taskId' ] },
-                ],
-              },
-            },
-          },
-          {
-            $project: {
-              'userName': 1,
-              'createdAt': 1,
-              'createdByName': 1,
-              'submitTime_string': 1,
-            },
-          },
-        ],
-        as: 'taskData',
-      },
-
-    }, { $unwind: { path: '$taskData', preserveNullAndEmptyArrays: true } },
+  const commonLookups = type === 'layout' ? [] : [
     {
       $lookup: {
         from: 'storefixtures',
-        let: { 'fixtureId': '$fixtureId' },
+        let: { fixtureId: '$fixtureId' },
         pipeline: [
           {
-            $match: {
-              $expr: {
-                $and: [
-                  { $eq: [ '$_id', '$$fixtureId' ] },
-                ],
-              },
-            },
+            $match: { $expr: { $eq: [ '$_id', '$$fixtureId' ] } },
           },
         ],
         as: 'storeFixtureData',
@@ -203,16 +126,10 @@ export async function getplanoFeedback( req, res ) {
     {
       $lookup: {
         from: 'fixtureconfigs',
-        let: { 'fixtureConfigId': '$storeFixtureData.fixtureConfigId' },
+        let: { fixtureConfigId: '$storeFixtureData.fixtureConfigId' },
         pipeline: [
           {
-            $match: {
-              $expr: {
-                $and: [
-                  { $eq: [ '$_id', '$$fixtureConfigId' ] },
-                ],
-              },
-            },
+            $match: { $expr: { $eq: [ '$_id', '$$fixtureConfigId' ] } },
           },
         ],
         as: 'FixtureData',
@@ -221,27 +138,22 @@ export async function getplanoFeedback( req, res ) {
     {
       $unwind: { path: '$FixtureData', preserveNullAndEmptyArrays: true },
     },
+  ];
+
+  const vmStages = type === 'vm' ? [
     {
       $unwind: { path: '$FixtureData.vmConfig', preserveNullAndEmptyArrays: true },
     },
     {
       $lookup: {
         from: 'planovmdetails',
-        let: { 'vmId': '$FixtureData.vmConfig.vmId' },
+        let: { vmId: '$FixtureData.vmConfig.vmId' },
         pipeline: [
           {
-            $match: {
-              $expr: {
-                $and: [
-                  { $eq: [ '$_id', '$$vmId' ] },
-                ],
-              },
-            },
+            $match: { $expr: { $eq: [ '$_id', '$$vmId' ] } },
           },
           {
-            $project: {
-              vmName: 1,
-            },
+            $project: { vmName: 1 },
           },
         ],
         as: 'vmDetails',
@@ -251,59 +163,10 @@ export async function getplanoFeedback( req, res ) {
       $unwind: { path: '$vmDetails', preserveNullAndEmptyArrays: true },
     },
     {
-      $project: {
-        '_id': 1,
-        'type': 1,
-        'type': 1,
-        'taskId': 1,
-        'taskData': 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',
-          },
-        },
+      $set: {
+        'FixtureData.vmConfig.vmName': '$vmDetails.vmName',
       },
     },
-
     {
       $group: {
         _id: '$_id',
@@ -332,20 +195,7 @@ export async function getplanoFeedback( req, res ) {
       },
     },
     {
-      $project: {
-        _id: 1,
-        answers: 1,
-        createdAt: 1,
-        date_iso: 1,
-        date_string: 1,
-        fixtureId: 1,
-        floorId: 1,
-        planoId: 1,
-        status: 1,
-        taskType: 1,
-        type: 1,
-        taskId: 1,
-        taskData: 1,
+      $set: {
         FixtureData: {
           $mergeObjects: [
             '$baseFixtureData',
@@ -368,39 +218,114 @@ export async function getplanoFeedback( req, res ) {
         },
       },
     },
-    {
-      $sort: { _id: -1 },
-    },
-
+  ] : [];
 
-    );
 
+  let pipeline = [
+    matchStage,
+    taskLookup,
+    unwindTask,
+    ...commonLookups,
+    ...vmStages,
+    { $sort: { _id: -1 } },
+  ];
+  if ( filterByApprovalStatus && filterByApprovalStatus != '' ) {
+    let filterByApprovalCond = { $eq: filterByApprovalStatus };
+    if ( filterByApprovalStatus != 'pending' ) {
+      filterByApprovalCond = { $ne: 'pending' };
+    }
+    console.log( '*********************' );
+    pipeline = [];
+    pipeline.push( matchStage );
+    pipeline.push(
+        { $unwind: '$answers' },
+        { $unwind: '$answers.issues' },
+        { $unwind: '$answers.issues.Details' },
+        {
+          $match: {
+            'answers.issues.Details.status': filterByApprovalCond,
+          },
+        },
+        {
+          $group: {
+            _id: '$_id',
+            doc: { $first: '$$ROOT' },
+          },
+        },
+        {
+          $replaceRoot: {
+            newRoot: {
+              $mergeObjects: [ '$doc', { answers: '$doc.originalAnswers' } ],
+            },
+          },
+        },
+        {
+          $project: {
+            originalAnswers: 0, // remove the temp field
+          },
+        },
+        {
+          $addFields: {
+            answers: {
+              $map: {
+                input: {
+                  $cond: [
+                    { $isArray: '$answers' },
+                    '$answers',
+                    { $cond: [ { $gt: [ { $type: '$answers' }, 'missing' ] }, [ '$answers' ], [] ] },
+                  ],
+                },
+                as: 'ans',
+                in: {
+                  $mergeObjects: [
+                    '$$ans',
+                    {
+                      issues: {
+                        $map: {
+                          input: {
+                            $cond: [
+                              { $isArray: '$$ans.issues' },
+                              '$$ans.issues',
+                              { $cond: [ { $gt: [ { $type: '$$ans.issues' }, 'missing' ] }, [ '$$ans.issues' ], [] ] },
+                            ],
+                          },
+                          as: 'issue',
+                          in: {
+                            $mergeObjects: [
+                              '$$issue',
+                              {
+                                Details: {
+                                  $cond: [
+                                    { $isArray: '$$issue.Details' },
+                                    '$$issue.Details',
+                                    { $cond: [ { $gt: [ { $type: '$$issue.Details' }, 'missing' ] }, [ '$$issue.Details' ], [] ] },
+                                  ],
+                                },
+                              },
+                            ],
+                          },
+                        },
+                      },
+                    },
+                  ],
+                },
+              },
+            },
+          },
+        },
 
-    let findvmCompliance = await planoTaskService.aggregate( queryVm );
 
+    );
+    pipeline.push( taskLookup );
+    pipeline.push( unwindTask );
+    pipeline.push( ...commonLookups );
+    pipeline.push( ...vmStages );
+  }
 
-    let layoutComment = await planoGlobalCommentService.find( {
-      planoId: new mongoose.Types.ObjectId( req.body.planoId ),
-      floorId: new mongoose.Types.ObjectId( req.body.floorId ),
-      taskType: 'layout',
-    } );
-    let fixtureComment = await planoGlobalCommentService.find( {
-      planoId: new mongoose.Types.ObjectId( req.body.planoId ),
-      floorId: new mongoose.Types.ObjectId( req.body.floorId ),
-      taskType: 'fixture',
-    } );
-    let vmComment = await planoGlobalCommentService.find( {
-      planoId: new mongoose.Types.ObjectId( req.body.planoId ),
-      floorId: new mongoose.Types.ObjectId( req.body.floorId ),
-      taskType: 'vm',
-    } );
 
-    res.sendSuccess( { layoutData: findPlanoCompliance, layoutComment: layoutComment, fixtureComment: fixtureComment, vmComment: vmComment, fixtureData: findfixtureCompliance, VmData: findvmCompliance } );
-  } catch ( e ) {
-    logger.error( { functionName: 'getplanoFeedback', error: e, message: req.body } );
-    return res.sendError( e, 500 );
-  }
+  return pipeline;
 }
+
 export async function getStoreFixturesfeedback( req, res ) {
   try {
     let query = [];
@@ -671,6 +596,18 @@ export async function updateFixtureStatus( req, res ) {
               'status': 'complete',
             },
         );
+        if ( req.body.taskType === 'layout' ) {
+          await planoTaskService.updateMany(
+              {
+                planoId: new mongoose.Types.ObjectId( req.body.planoId ),
+                floorId: new mongoose.Types.ObjectId( req.body.floorId ),
+                type: 'layout',
+              },
+              {
+                'status': 'complete',
+              },
+          );
+        }
       }
     }