tango-app-api-store-builder 1.0.0-beta-206 → 1.0.0-beta-208

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "tango-app-api-store-builder",
-    "version": "1.0.0-beta-206",
+    "version": "1.0.0-beta-208",
     "description": "storeBuilder",
     "main": "index.js",
     "type": "module",
@@ -32,7 +32,7 @@
         "path": "^0.12.7",
         "selenium-webdriver": "^4.31.0",
         "sharp": "^0.34.1",
-        "tango-api-schema": "^2.3.32",
+        "tango-api-schema": "^2.4.3",
         "tango-app-api-middleware": "3.1.48",
         "url": "^0.11.4",
         "winston": "^3.17.0",

package/src/controllers/managePlano.controller.js

@@ -16,6 +16,7 @@ import * as planoTaskService from '../service/planoTask.service.js';
 import * as planoGlobalCommentService from '../service/planoGlobalComment.service.js';
 import mongoose from 'mongoose';
 import * as planoRevisionService from '../service/planoRevision.service.js';
+import * as planoVmDuplicateService from '../service/planoVmDuplicate.service.js';
 export async function getplanoFeedback( req, res ) {
   try {
     const taskTypes = req.body.filterByTask && req.body.filterByTask.length > 0 ? req.body.filterByTask : [ 'layout', 'fixture', 'vm' ];
@@ -71,6 +72,62 @@ export async function getplanoFeedback( req, res ) {
     return res.sendError( e, 500 );
   }
 }
+export async function getplanoFeedbackv1( req, res ) {
+  try {
+    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 = {};
+    await Promise.all(
+        taskTypes.map( async ( type, index ) => {
+          const pipeline = buildPipelineByType1( type, req.body.planoId, req.body.floorId, filterByStatus, filterByApprovalStatus, req.body.showtask );
+
+          let data = await planoTaskService.aggregate( pipeline );
+          if ( filterByApprovalStatus && filterByApprovalStatus !== '' ) {
+            data.forEach( ( element ) => {
+              element.answers?.forEach( ( ans ) => {
+                ans.issues = ans.issues?.filter(
+                    ( issue ) => issue.Details && issue.Details.length > 0,
+                );
+              } );
+              element.answers = element.answers?.filter(
+                  ( ans ) => ans.issues && ans.issues.length > 0,
+              );
+            } );
+            data = data.filter(
+                ( element ) => element.answers && element.answers.length > 0,
+            );
+          }
+
+
+          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'] || [],
+    };
+
+    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, showtask, taskId = 0 ) {
   console.log( type, planoId, floorId, filterByStatus );
   const matchStage = {
@@ -314,6 +371,249 @@ function buildPipelineByType( type, planoId, floorId, filterByStatus, filterByAp
   return pipeline;
 }
 
+function buildPipelineByType1( type, planoId, floorId, filterByStatus, filterByApprovalStatus, showtask, taskId = 0 ) {
+  console.log( type, planoId, floorId, filterByStatus );
+  const matchStage = {
+    $match: {
+      planoId: new mongoose.Types.ObjectId( planoId ),
+      floorId: new mongoose.Types.ObjectId( floorId ),
+      type: type,
+      ...( taskId && { taskId: new mongoose.Types.ObjectId( taskId ) } ),
+      ...( filterByStatus?.length ? { status: { $in: filterByStatus } } : {} ),
+    },
+  };
+
+
+  const conditionalMatchExpr = showtask ?
+    {
+      $eq: [ '$_id', '$$taskId' ],
+    } :
+    {
+      $and: [
+        {
+          $eq: [ '$_id', '$$taskId' ],
+        },
+        {
+          $or: [
+            { $eq: [ '$redoStatus', true ] },
+            {
+              $and: [
+                { $eq: [ '$redoStatus', false ] },
+                { $eq: [ '$checklistStatus', 'submit' ] },
+              ],
+            },
+          ],
+        },
+      ],
+    };
+
+  const taskLookup = {
+    $lookup: {
+      from: 'processedtasks',
+      let: { taskId: '$taskId' },
+      pipeline: [
+        {
+          $match: {
+            $expr: conditionalMatchExpr,
+          },
+        },
+        {
+          $project: {
+            userName: 1,
+            createdAt: 1,
+            createdByName: 1,
+            submitTime_string: 1,
+          },
+        },
+      ],
+      as: 'taskData',
+    },
+  };
+
+
+  const unwindTask = { $unwind: { path: '$taskData', preserveNullAndEmptyArrays: false } };
+
+  const commonLookups = type === 'layout' ? [] : [
+    {
+      $lookup: {
+        from: 'storefixtureduplicates',
+        let: { fixtureId: '$fixtureId' },
+        pipeline: [
+          {
+            $match: { $expr: { $eq: [ '$_id', '$$fixtureId' ] } },
+          },
+        ],
+        as: 'FixtureData',
+      },
+    },
+    {
+      $unwind: { path: '$FixtureData', preserveNullAndEmptyArrays: true },
+    },
+    {
+      $lookup: {
+        from: 'fixtureshelfduplicates',
+        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: 'planovmdetailduplicates',
+        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: '$_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' },
+        type: { $first: '$type' },
+        taskId: { $first: '$taskId' },
+        taskData: { $first: '$taskData' },
+        baseFixtureData: { $first: '$FixtureData' },
+        collectedVmConfigs: {
+          $push: {
+            $cond: [
+              { $ne: [ '$FixtureData.vmConfig', {} ] },
+              '$FixtureData.vmConfig',
+              '$$REMOVE',
+            ],
+          },
+        },
+      },
+    },
+    {
+      $set: {
+        FixtureData: {
+          $mergeObjects: [
+            '$baseFixtureData',
+            {
+              vmConfig: {
+                $reduce: {
+                  input: '$collectedVmConfigs',
+                  initialValue: [],
+                  in: {
+                    $cond: [
+                      { $isArray: '$$this' },
+                      { $concatArrays: [ '$$value', '$$this' ] },
+                      { $concatArrays: [ '$$value', [ '$$this' ] ] },
+                    ],
+                  },
+                },
+              },
+            },
+          ],
+        },
+      },
+    },
+  ] : [];
+
+
+  let pipeline = [
+    matchStage,
+    taskLookup,
+    unwindTask,
+    ...commonLookups,
+    ...vmStages,
+    { $sort: { _id: -1 } },
+  ];
+  if ( filterByApprovalStatus && filterByApprovalStatus != '' ) {
+    pipeline = [];
+    pipeline.push( matchStage );
+    pipeline.push(
+        {
+          $addFields: {
+            answers: {
+              $map: {
+                input: '$answers',
+                as: 'ans',
+                in: {
+                  $mergeObjects: [
+                    '$$ans',
+                    {
+                      issues: {
+                        $map: {
+                          input: '$$ans.issues',
+                          as: 'issue',
+                          in: {
+                            $mergeObjects: [
+                              '$$issue',
+                              {
+                                Details: {
+                                  $filter: {
+                                    input: '$$issue.Details',
+                                    as: 'detail',
+                                    cond: filterByApprovalStatus === 'pending' ?
+                                    { $eq: [ '$$detail.status', 'pending' ] } :
+                                    { $ne: [ '$$detail.status', 'pending' ] },
+                                  },
+                                },
+                              },
+                            ],
+                          },
+                        },
+                      },
+                    },
+                  ],
+                },
+              },
+            },
+          },
+        },
+    );
+    pipeline.push( taskLookup );
+    pipeline.push( unwindTask );
+    pipeline.push( ...commonLookups );
+    pipeline.push( ...vmStages );
+    pipeline.push( { $sort: { _id: -1 } } );
+  }
+
+
+  return pipeline;
+}
+
 export async function getStoreFixturesfeedback( req, res ) {
   try {
     let query = [];
@@ -536,6 +836,19 @@ export async function fixtureVMList( req, res ) {
     return res.sendError( e, 500 );
   }
 }
+
+export async function fixtureVMListv1( req, res ) {
+  try {
+    let findData = await planoVmDuplicateService.find( { clientId: req.query.clientId } );
+    if ( findData.length === 0 ) {
+      return res.sendError( 'nodata found', 204 );
+    }
+    res.sendSuccess( findData );
+  } catch ( e ) {
+    logger.error( { functionName: 'fixtureVMListv1', error: e } );
+    return res.sendError( e, 500 );
+  }
+}
 export async function updateFixtureStatus( req, res ) {
   try {
     let comments = {
@@ -933,7 +1246,7 @@ export async function updateGlobalComment( req, res ) {
     return res.sendError( e, 500 );
   }
 }
-export async function getGlobalComment(req, res) {
+export async function getGlobalComment( req, res ) {
   try {
     // let layoutComment = await planoGlobalCommentService.find( {
     //   planoId: new mongoose.Types.ObjectId( req.body.planoId ),
@@ -942,25 +1255,25 @@ export async function getGlobalComment(req, res) {
     // } );
 
     let taskId = [];
-    if (req.body?.taskId) {
-      taskId.push(new mongoose.Types.ObjectId(req.body.taskId));
+    if ( req.body?.taskId ) {
+      taskId.push( new mongoose.Types.ObjectId( req.body.taskId ) );
     }
 
-    if (req.body?.refTaskId) {
-      taskId.push(new mongoose.Types.ObjectId(req.body.refTaskId));
+    if ( req.body?.refTaskId ) {
+      taskId.push( new mongoose.Types.ObjectId( req.body.refTaskId ) );
     }
-    
-    let layoutComment = await planoGlobalCommentService.find({
-      planoId: new mongoose.Types.ObjectId(req.body.planoId),
-      floorId: new mongoose.Types.ObjectId(req.body.floorId),
-      ...(taskId.length && { taskId: { $in: taskId } }),
+
+    let layoutComment = await planoGlobalCommentService.find( {
+      planoId: new mongoose.Types.ObjectId( req.body.planoId ),
+      floorId: new mongoose.Types.ObjectId( req.body.floorId ),
+      ...( taskId.length && { taskId: { $in: taskId } } ),
       taskType: req.body.taskType,
-    });
+    } );
 
-    res.sendSuccess(layoutComment);
-  } catch (e) {
-    logger.error({ functionName: 'getGlobalComment', error: e });
-    return res.sendError(e, 500);
+    res.sendSuccess( layoutComment );
+  } catch ( e ) {
+    logger.error( { functionName: 'getGlobalComment', error: e } );
+    return res.sendError( e, 500 );
   }
 }