tango-app-api-store-builder 1.0.0-beta-142 → 1.0.0-beta-144

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "tango-app-api-store-builder",
-    "version": "1.0.0-beta-142",
+    "version": "1.0.0-beta-144",
     "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.2.185",
+        "tango-api-schema": "^2.2.186",
         "tango-app-api-middleware": "3.1.48",
         "url": "^0.11.4",
         "winston": "^3.17.0",

package/src/controllers/fixtureTemplate.controller.js

@@ -539,3 +539,32 @@ export async function getAllTemplates( req, res ) {
     logger.error( { functionName: 'getAllTemplates', error: e } );
   }
 }
+
+export async function getFixtureTemplate( req, res ) {
+  try {
+    let fixtureTemplate = await fixtureConfigService.findOne( { _id: new mongoose.Types.ObjectId( req.query.templateId ) } );
+
+    if ( !fixtureTemplate ) {
+      return res.sendError( 'No data found', 204 );
+    }
+
+    const templateDoc = fixtureTemplate.toObject();
+
+
+    if ( templateDoc?.vmConfig?.length ) {
+      templateDoc.vmConfig = await Promise.all( templateDoc.vmConfig.map( async ( vm ) => {
+        let vmDetails = await vmService.findOne( { _id: vm.vmId } );
+        console.log( vmDetails );
+        if ( vmDetails ) {
+          vm = { ...vm, ...vmDetails.toObject() };
+          return vm;
+        }
+      } ) );
+    }
+
+
+    res.sendSuccess( templateDoc );
+  } catch ( e ) {
+    logger.error( { functionName: 'getFixtureTemplate', error: e } );
+  }
+}

package/src/controllers/managePlano.controller.js

@@ -26,7 +26,7 @@ export async function getplanoFeedback( req, res ) {
     console.log( taskTypes );
     await Promise.all(
         taskTypes.map( async ( type, index ) => {
-          const pipeline = buildPipelineByType( type, req.body.planoId, req.body.floorId, filterByStatus, filterByApprovalStatus );
+          const pipeline = buildPipelineByType( type, req.body.planoId, req.body.floorId, filterByStatus, filterByApprovalStatus, req.body.showtask );
 
           const data = await planoTaskService.aggregate( pipeline );
           console.log( '-------', data );
@@ -56,7 +56,7 @@ export async function getplanoFeedback( req, res ) {
     return res.sendError( e, 500 );
   }
 }
-function buildPipelineByType( type, planoId, floorId, filterByStatus, filterByApprovalStatus ) {
+function buildPipelineByType( type, planoId, floorId, filterByStatus, filterByApprovalStatus, showtask ) {
   console.log( type, planoId, floorId, filterByStatus );
   const matchStage = {
     $match: {
@@ -67,7 +67,7 @@ function buildPipelineByType( type, planoId, floorId, filterByStatus, filterByAp
     },
   };
 
-  const taskLookup = {
+  let taskLookup = {
     $lookup: {
       from: 'processedtasks',
       let: { taskId: '$taskId' },
@@ -104,6 +104,34 @@ function buildPipelineByType( type, planoId, floorId, filterByStatus, filterByAp
       as: 'taskData',
     },
   };
+  if ( showtask ) {
+    taskLookup = {
+      $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',
+      },
+    };
+  }
 
   const unwindTask = { $unwind: { path: '$taskData', preserveNullAndEmptyArrays: false } };
 
@@ -231,91 +259,95 @@ function buildPipelineByType( type, planoId, floorId, filterByStatus, filterByAp
   ];
   if ( filterByApprovalStatus && filterByApprovalStatus != '' ) {
     let filterByApprovalCond = { $eq: filterByApprovalStatus };
-    if ( filterByApprovalStatus != 'pending' ) {
-      filterByApprovalCond = { $ne: 'pending' };
-    }
-    console.log( '*********************' );
+
+    console.log( '*********************', filterByApprovalCond );
     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' } ],
+    if ( filterByApprovalStatus === 'pending' ) {
+      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: { $eq: [ '$$detail.status', 'pending' ] },
+                                    },
+                                  },
+                                },
+                              ],
+                            },
+                          },
+                        },
+                      },
+                    ],
+                  },
+                },
+              },
             },
           },
-        },
-        {
-          $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' ], [] ] },
-                                  ],
+
+
+      );
+    } else {
+      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: { $ne: [ '$$detail.status', 'pending' ] },
+                                    },
+                                  },
                                 },
-                              },
-                            ],
+                              ],
+                            },
                           },
                         },
                       },
-                    },
-                  ],
+                    ],
+                  },
                 },
               },
             },
           },
-        },
 
 
-    );
+      );
+    }
     pipeline.push( taskLookup );
     pipeline.push( unwindTask );
     pipeline.push( ...commonLookups );
@@ -644,14 +676,16 @@ export async function updateFixtureStatus( req, res ) {
         },
 
     );
-    let allTaskDone = vmTask.filter( ( data ) => data.status === 'incomplete' );
-    if ( allTaskDone.length === 0 ) {
-      await planoService.updateOne(
-          {
-            _id: new mongoose.Types.ObjectId( req.body.planoId ),
-          },
-          { $set: { planoProgress: 100 } },
-      );
+    if ( vmTask.length>0 ) {
+      let allTaskDone = vmTask.filter( ( data ) => data.status === 'incomplete' );
+      if ( allTaskDone.length === 0 ) {
+        await planoService.updateOne(
+            {
+              _id: new mongoose.Types.ObjectId( req.body.planoId ),
+            },
+            { $set: { planoProgress: 100 } },
+        );
+      }
     }
     res.sendSuccess( 'updated successfully' );
   } catch ( e ) {

package/src/controllers/planoLibrary.controller.js

@@ -267,94 +267,37 @@ export async function FixtureLibraryList( req, res ) {
       {
         $lookup: {
           from: 'fixtureconfigs',
-          let: { libraryId: '$_id' },
-          pipeline: [
-            {
-              $match: {
-                $expr: {
-                  $eq: [ '$fixtureLibraryId', '$$libraryId' ],
-                },
-              },
-            },
-            {
-              $group: {
-                _id: null,
-                templateId: { $push: '$_id' },
-              },
-            },
-            {
-              $project: {
-                _id: 0,
-                templateId: 1,
-              },
-            },
-          ],
+          localField: '_id',
+          foreignField: 'fixtureLibraryId',
           as: 'fixtureTemplate',
         },
       },
       {
-        $project: {
-          fixtureCategorySize: 1,
-          fixtureWidth: 1,
-          fixtureHeight: 1,
-          fixtureLength: 1,
-          shelfConfig: 1,
-          shelfCount: { $size: '$shelfConfig' },
-          fixtureCategory: 1,
-          clientId: 1,
-          fixtureType: 1,
-          status: 1,
-          header: 1,
-          footer: 1,
-          fixtureLibCode: 1,
-          templateId: { $ifNull: [ { $arrayElemAt: [ '$fixtureTemplate.templateId', 0 ] }, [] ] },
+        $set: {
+          templateId: {
+            $setUnion: [
+              { $map: { input: '$fixtureTemplate', as: 'fc', in: '$$fc._id' } },
+              [],
+            ],
+          },
         },
       },
       {
         $lookup: {
           from: 'storefixtures',
-          let: { libraryId: '$_id' },
-          pipeline: [
-            {
-              $match: {
-                $expr: {
-                  $eq: [ '$fixtureLibraryId', '$$libraryId' ],
-                },
-              },
-            },
-            {
-              $group: {
-                _id: null,
-                planoId: { $push: '$planoId' },
-              },
-            },
-            {
-              $project: {
-                _id: 0,
-                planoId: 1,
-              },
-            },
-          ],
+          localField: '_id',
+          foreignField: 'fixtureLibraryId',
           as: 'storeFixtureDetails',
         },
       },
       {
-        $project: {
-          fixtureWidth: 1,
-          fixtureHeight: 1,
-          fixtureLength: 1,
-          shelfConfig: 1,
-          shelfCount: 1,
-          fixtureCategory: 1,
-          clientId: 1,
-          fixtureType: 1,
-          status: 1,
-          templateId: 1,
-          header: 1,
-          footer: 1,
-          fixtureLibCode: 1,
-          planoId: { $ifNull: [ { $arrayElemAt: [ '$storeFixtureDetails.planoId', 0 ] }, [] ] },
-          templateCount: { $size: '$templateId' },
+        $set: {
+          planoId: {
+            $setUnion: [
+              { $map: { input: '$storeFixtureDetails', as: 'sf', in: '$$sf.planoId' } },
+              [],
+            ],
+          },
         },
       },
       {
@@ -386,14 +329,14 @@ export async function FixtureLibraryList( req, res ) {
           fixtureLength: 1,
           fixtureType: 1,
           shelfConfig: 1,
-          shelfCount: 1,
+          shelfCount: { $size: '$shelfConfig' },
           fixtureCategory: 1,
           clientId: 1,
           planoId: 1,
           templateId: 1,
           header: 1,
           footer: 1,
-          templateCount: 1,
+          templateCount: { $size: '$templateId' },
           fixtureLibCode: 1,
           planoStatus: { $ifNull: [ { $arrayElemAt: [ '$planoStatus.statusList', 0 ] }, [] ] },
           status: {
@@ -698,11 +641,10 @@ export async function uploadVmImage( req, res ) {
     if ( !req.params?.vmId ) {
       return res.sendError( 'id is required', 400 );
     }
-    console.log( req.files );
     let params = {
       Bucket: JSON.parse( process.env.BUCKET ).storeBuilder,
-      Key: `vmType/${req.params.vmId}/${Date.now()}/`,
-      fileName: req.files.file.name,
+      Key: `vmType/${req.params.vmId}/`,
+      fileName: Date.now() +'.'+ req.files?.file?.name?.split( '.' )?.slice( -1 )?.[0],
       ContentType: req.files.file.mimeType,
       body: req.files.file.data,
     };
@@ -770,44 +712,44 @@ export async function getBrandList( req, res ) {
 
       sheet.getRow( 1 ).values = [ 'Brand Name', 'Brand Category', 'Brand SubCategory' ];
 
-      let rowStart = 2;
-      let lockedRowNumber = [];
+      // let rowStart = 2;
+      // let lockedRowNumber = [];
       if ( req.body.emptyDownload ) {
         getBrandDetails = [];
       }
-      getBrandDetails.forEach( ( ele ) => {
-        sheet.getRow( rowStart ).values = [ ele.brandName, ele.category.toString(), ele.subCategory.toString() ];
-        if ( ele.isUsed ) {
-          lockedRowNumber.push( rowStart );
-        }
-        rowStart = rowStart + 1;
-      } );
+      // getBrandDetails.forEach( ( ele ) => {
+      //   sheet.getRow( rowStart ).values = [ ele.brandName, ele.category.toString(), ele.subCategory.toString() ];
+      //   if ( ele.isUsed ) {
+      //     lockedRowNumber.push( rowStart );
+      //   }
+      //   rowStart = rowStart + 1;
+      // } );
 
-      let unlockCellValues = 20000;
-      let splitLoop = [];
+      // let unlockCellValues = 20000;
+      // let splitLoop = [];
 
-      for ( let i=1; i<=unlockCellValues; i+=2000 ) {
-        splitLoop.push( { start: i, end: i + 1999 } );
-      }
+      // for ( let i=1; i<=unlockCellValues; i+=2000 ) {
+      //   splitLoop.push( { start: i, end: i + 1999 } );
+      // }
 
-      await Promise.all( splitLoop.map( ( item ) => {
-        for ( let i=item.start; i<=item.end; i++ ) {
-          const row = sheet.getRow( i );
-          if ( i > rowStart - 1 ) {
-            row.values = [ '', '', '', '', '', '', '', '', '', '' ];
-          }
-          if ( !lockedRowNumber.includes( i ) && i != 1 ) {
-            row.eachCell( ( cell ) => {
-              cell.protection = { locked: false };
-            } );
-          }
-        }
-      } ) );
+      // await Promise.all( splitLoop.map( ( item ) => {
+      //   for ( let i=item.start; i<=item.end; i++ ) {
+      //     const row = sheet.getRow( i );
+      //     if ( i > rowStart - 1 ) {
+      //       row.values = [ '', '', '', '', '', '', '', '', '', '' ];
+      //     }
+      //     if ( !lockedRowNumber.includes( i ) && i != 1 ) {
+      //       row.eachCell( ( cell ) => {
+      //         cell.protection = { locked: false };
+      //       } );
+      //     }
+      //   }
+      // } ) );
 
-      await sheet.protect( 'password123', {
-        selectLockedCells: false,
-        selectUnlockedCells: true,
-      } );
+      // await sheet.protect( 'password123', {
+      //   selectLockedCells: false,
+      //   selectUnlockedCells: true,
+      // } );
 
       sheet.columns.forEach( ( column ) => {
         let maxLength = 10;
@@ -841,8 +783,8 @@ export async function addUpdateBrandList( req, res ) {
         brandData.push( {
           clientId: inputData.clientId,
           brandName: ele.brand,
-          category: [ ...new Set( ele.category ) ],
-          subCategory: [ ...new Set( ele.subCategory ) ],
+          category: [ ...new Set( ele?.category?.map( ( ele ) => ele ) ) ],
+          subCategory: [ ...new Set( ele?.subCategory?.map( ( ele ) => ele ) ) ],
         } );
       }
     } );
@@ -860,28 +802,66 @@ export async function uploadBrandList( req, res ) {
     let inputData = req.body;
 
     let brandData = inputData.brandData.reduce( ( acc, ele ) => {
-      console.log( ele?.category, ele );
-      if ( !acc[ele.brandName] ) {
-        acc[ele.brandName] = {
-          brandName: ele.brandName,
+      let category = ele?.['Brand Category'].split( ',' );
+      let subCategory = ele?.['Brand SubCategory'].split( ',' );
+      if ( !acc[ele['Brand Name']] ) {
+        acc[ele['Brand Name']] = {
+          brandName: ele['Brand Name'],
           clientId: inputData.clientId,
-          category: [ ...new Set( ele?.category?.map( ( ele ) => ele ) ) ],
-          subCategory: [ ...new Set( ele?.subCategory?.map( ( ele ) => ele ) ) ],
+          category: [ ...new Set( category?.filter( ( ele ) => ele ).map( ( ele ) => ele ) ) ],
+          subCategory: [ ...new Set( subCategory?.filter( ( ele ) => ele ).map( ( ele ) => ele ) ) ],
         };
       } else {
-        acc[ele.brandName].category.push( ...ele.category );
-        if ( ele?.subCategory.length ) {
-          acc[ele.brandName].subCategory.push( ...ele?.subCategory );
+        category.forEach( ( cat ) => {
+          if ( !acc[ele['Brand Name']].category.includes( cat ) ) {
+            acc[ele['Brand Name']].category.push( cat );
+          }
+        } );
+        if ( subCategory.length ) {
+          subCategory.forEach( ( cat ) => {
+            if ( !acc[ele['Brand Name']].subCategory.includes( cat ) ) {
+              acc[ele['Brand Name']].subCategory.push( cat );
+            }
+          } );
         }
       }
       return acc;
     }, {} );
+    await Promise.all( Object.keys( brandData ).map( async ( brand ) => {
+      let brandLower = brand.toLowerCase();
+      let query = [
+        {
+          $addFields: {
+            brandLower: { $toLower: '$brandName' },
+          },
+        },
+        {
+          $match: {
+            brandLower: brandLower,
+            clientId: inputData.clientId,
+          },
+        },
+      ];
+      let brandDetails = await planoProductService.aggregate( query );
+      if ( brandDetails.length ) {
+        let getCategory = brandDetails[0]?.category;
+        let getsubCategory = brandDetails[0]?.subCategory;
+        brandData[brand].category.forEach( ( ele ) => {
+          if ( !getCategory.includes( ele ) ) {
+            getCategory.push( ele );
+          }
+        } );
+        brandData[brand].subCategory.forEach( ( ele ) => {
+          if ( !getsubCategory.includes( ele ) ) {
+            getsubCategory.push( ele );
+          }
+        } );
+        await planoProductService.updateOne( { _id: brandDetails[0]._id }, { category: getCategory, subCategory: getsubCategory } );
+      } else {
+        await planoProductService.create( brandData[brand] );
+      }
+    } ) );
 
-    await planoProductService.deleteMany( { clientId: inputData.clientId, _id: { $nin: inputData.brandUsedList } } );
-    await planoProductService.insertMany( Object.values( brandData ) );
-    // await Promise.all( Object.keys( brandData ).map( async ( ele ) => {
-    //   await planoProductService.updateOne( { brandName: { $regex: brandData[ele].brandName, $options: 'i' }, clientId: req.body.clientId }, brandData[ele] );
-    // } ) );
     return res.sendSuccess( 'Brand details upload successfully' );
   } catch ( e ) {
     logger.error( { functionName: 'uploadBrandList', error: e } );
@@ -993,13 +973,7 @@ export async function getVmLibList( req, res ) {
             {
               $group: {
                 _id: null,
-                templateId: { $push: '$_id' },
-              },
-            },
-            {
-              $project: {
-                _id: 0,
-                templateId: 1,
+                templateIds: { $addToSet: '$_id' },
               },
             },
           ],
@@ -1007,66 +981,26 @@ export async function getVmLibList( req, res ) {
         },
       },
       {
-        $project: {
-          vmName: 1,
-          vmType: 1,
-          vmBrand: 1,
-          vmCategory: 1,
-          clientId: 1,
-          vmHeight: 1,
-          status: 1,
-          vmWidth: 1,
-          vmImageUrl: 1,
-          isDoubleSided: 1,
-          vmSubCategory: 1,
-          vmLibCode: 1,
-          templateId: { $ifNull: [ { $arrayElemAt: [ '$fixtureTemplate.templateId', 0 ] }, [] ] },
+        $set: {
+          templateId: { $ifNull: [ { $arrayElemAt: [ '$fixtureTemplate.templateIds', 0 ] }, [] ] },
         },
       },
       {
         $lookup: {
           from: 'storefixtures',
-          let: { libraryId: '$_id' },
-          pipeline: [
-            {
-              $match: {
-                $expr: {
-                  $in: [ '$$libraryId', { $ifNull: [ '$vmConfig.vmId', [] ] } ],
-                },
-              },
-            },
-            {
-              $group: {
-                _id: null,
-                planoId: { $push: '$planoId' },
-              },
-            },
-            {
-              $project: {
-                _id: 0,
-                planoId: 1,
-              },
-            },
-          ],
+          localField: 'templateId',
+          foreignField: 'fixtureConfigId',
           as: 'storeFixtureDetails',
         },
       },
       {
-        $project: {
-          vmName: 1,
-          vmType: 1,
-          vmBrand: 1,
-          vmCategory: 1,
-          clientId: 1,
-          vmHeight: 1,
-          status: 1,
-          vmWidth: 1,
-          vmImageUrl: 1,
-          isDoubleSided: 1,
-          templateId: 1,
-          vmLibCode: 1,
-          vmSubCategory: 1,
-          planoId: { $ifNull: [ { $arrayElemAt: [ '$storeFixtureDetails.planoId', 0 ] }, [] ] },
+        $set: {
+          planoId: {
+            $setUnion: [
+              { $map: { input: '$storeFixtureDetails', as: 'sf', in: '$$sf.planoId' } },
+              [],
+            ],
+          },
           templateCount: { $size: '$templateId' },
         },
       },
@@ -1472,3 +1406,52 @@ async function getMaxVMLibCode() {
     return false;
   }
 }
+
+export async function fixtureNameList( req, res ) {
+  try {
+    let getFixtureDetails = await planoLibraryService.aggregate( [
+      {
+        $match: {
+          clientId: req.query.clientId,
+          status: 'complete',
+        },
+      },
+      {
+        $group: {
+          _id: '',
+          fixtureDetails: {
+            $push: { fixtureName: {
+              $concat: [
+                '$fixtureCategory',
+                ' - ',
+                { $toString: '$fixtureWidth.value' },
+                '$fixtureWidth.unit',
+              ] }, id: '$_id',
+            },
+          },
+        },
+      },
+      {
+        $project: {
+          _id: 1,
+          fixtureDetails: 1,
+        },
+      },
+    ] );
+
+    return res.sendSuccess( getFixtureDetails?.[0]?.fixtureDetails || [] );
+  } catch ( e ) {
+    logger.error( { functionName: 'fixtureNameList', error: e } );
+    return res.sendError( e, 500 );
+  }
+}
+
+export async function vmNameList( req, res ) {
+  try {
+    let getVmDetails = await vmService.find( { clientId: req.query.clientId, status: 'complete' }, { vmName: 1, vmWidth: 1, vmHeight: 1, vmImageUrl: 1, vmType: 1 } );
+    return res.sendSuccess( getVmDetails );
+  } catch ( e ) {
+    logger.error( { functionName: 'vmNameList', error: e } );
+    return res.sendError( e, 500 );
+  }
+}

package/src/controllers/script.controller.js

@@ -8920,7 +8920,6 @@ export async function updatePlanoMappings( req, res ) {
     return res.sendError( 'Unauthorized', 401 );
   }
   try {
-    console.log( JSON.stringify( req.body ) );
     const floor = await storeBuilderService.findOne( { storeName: req.body.storeName } );
 
     for ( let i = 0; i < req.body?.walls?.length; i++ ) {

package/src/controllers/storeBuilder.controller.js

@@ -17,6 +17,7 @@ import * as fixtureConfigService from '../service/fixtureConfig.service.js';
 import * as planoStaticData from '../service/planoStaticData.service.js';
 import * as planoVmService from '../service/planoVm.service.js';
 import * as planotaskService from '../service/processedTaskservice.js';
+import * as layoutService from '../service/storeBuilder.service.js';
 
 
 dayjs.extend( utc );
@@ -3639,7 +3640,7 @@ export async function planoList( req, res ) {
               },
             },
           },
-          { 'taskDetails.layoutStatus': 'pending' },
+          // { 'taskDetails.layoutStatus': 'pending' },
       );
       query.push( {
         $match: {
@@ -3655,9 +3656,36 @@ export async function planoList( req, res ) {
         orQuery.push( { 'planoTask.taskStatus.status': { $in: [ 'open', 'inprogress' ] } } );
       }
       if ( inputData.filter.status.includes( 'reviewPending' ) ) {
-        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' } ] } );
+        orQuery.push( {
+          $and: [
+            { 'planoTask.taskStatus': {
+              $elemMatch: {
+                type: 'layout',
+                status: 'submit',
+              },
+            } }, { 'taskDetails.layoutStatus': 'pending' },
+          ],
+        } );
+        orQuery.push( {
+          $and: [
+            { 'planoTask.taskStatus': {
+              $elemMatch: {
+                type: 'fixture',
+                status: 'submit',
+              },
+            } }, { 'taskDetails.fixtureStatus': 'pending' },
+          ],
+        } );
+        orQuery.push( {
+          $and: [
+            { 'planoTask.taskStatus': {
+              $elemMatch: {
+                type: 'vm',
+                status: 'submit',
+              },
+            } }, { 'taskDetails.vmStatus': 'pending' },
+          ],
+        } );
       }
       if ( inputData.filter.status.includes( 'completed' ) ) {
         orQuery.push( { $and: [ { 'taskDetails.layoutStatus': 'complete' }, { 'taskDetails.fixtureStatus': 'complete' }, { 'taskDetails.vmStatus': 'complete' } ] } );
@@ -3894,6 +3922,7 @@ export async function getTaskDetails( req, res ) {
           planoId: new mongoose.Types.ObjectId( req.query.planoId ),
           isPlano: true,
           date_iso: { $lte: new Date( dayjs().format( 'YYYY-MM-DD' ) ) },
+          floorId: new mongoose.Types.ObjectId( req.query.floorId ),
         },
       },
       {
@@ -3987,6 +4016,41 @@ export async function getTaskDetails( req, res ) {
                     },
                   },
                 },
+                hasDisagreeIssues: {
+                  $anyElementTrue: {
+                    $map: {
+                      input: {
+                        $reduce: {
+                          input: '$answers',
+                          initialValue: [],
+                          in: {
+                            $concatArrays: [
+                              '$$value',
+                              {
+                                $reduce: {
+                                  input: { $ifNull: [ '$$this.issues', [] ] },
+                                  initialValue: [],
+                                  in: {
+                                    $concatArrays: [
+                                      '$$value',
+                                      { $ifNull: [ '$$this.Details', [] ] },
+                                    ],
+                                  },
+                                },
+                              },
+                            ],
+                          },
+                        },
+                      },
+                      as: 'detail',
+                      in: {
+                        $or: [
+                          { $eq: [ '$$detail.status', 'disagree' ] },
+                        ],
+                      },
+                    },
+                  },
+                },
               },
             },
             {
@@ -4028,6 +4092,33 @@ export async function getTaskDetails( req, res ) {
                     ],
                   },
                 },
+                layoutDisagree: {
+                  $sum: {
+                    $cond: [
+                      { $and: [ { $eq: [ '$type', 'layout' ] }, '$hasDisagreeIssues' ] },
+                      1,
+                      0,
+                    ],
+                  },
+                },
+                fixtureDisagree: {
+                  $sum: {
+                    $cond: [
+                      { $and: [ { $eq: [ '$type', 'fixture' ] }, '$hasDisagreeIssues' ] },
+                      1,
+                      0,
+                    ],
+                  },
+                },
+                vmDisagree: {
+                  $sum: {
+                    $cond: [
+                      { $and: [ { $eq: [ '$type', 'vm' ] }, '$hasDisagreeIssues' ] },
+                      1,
+                      0,
+                    ],
+                  },
+                },
               },
             },
             {
@@ -4057,6 +4148,9 @@ export async function getTaskDetails( req, res ) {
                 layoutPending: { $sum: '$layoutPending' },
                 fixturePending: { $sum: '$fixturePending' },
                 vmPending: { $sum: '$vmPending' },
+                layoutDisagree: { $sum: '$layoutDisagree' },
+                fixtureDisagree: { $sum: '$fixtureDisagree' },
+                vmDisagree: { $sum: '$vmDisagree' },
               },
             },
             {
@@ -4068,6 +4162,7 @@ export async function getTaskDetails( req, res ) {
                       $and: [
                         { $gt: [ '$layoutCount', 0 ] },
                         { $eq: [ '$layoutPending', 0 ] },
+                        { $eq: [ '$layoutDisagree', 0 ] },
                       ],
                     },
                     then: 'complete',
@@ -4087,7 +4182,25 @@ export async function getTaskDetails( req, res ) {
                           ],
                         },
                         then: 'pending',
-                        else: '',
+                        else: {
+                          $cond: {
+                            if: {
+                              $and: [
+                                {
+                                  $gt: [ '$layoutCount', 0 ],
+                                },
+                                {
+                                  $gt: [
+                                    '$layoutDisagree',
+                                    0,
+                                  ],
+                                },
+                              ],
+                            },
+                            then: 'disagree',
+                            else: '',
+                          },
+                        },
                       },
                     },
                   },
@@ -4100,6 +4213,9 @@ export async function getTaskDetails( req, res ) {
                         {
                           $eq: [ '$fixturePending', 0 ],
                         },
+                        {
+                          $eq: [ '$fixtureDisagree', 0 ],
+                        },
                       ],
                     },
                     then: 'complete',
@@ -4122,7 +4238,25 @@ export async function getTaskDetails( req, res ) {
                           ],
                         },
                         then: 'pending',
-                        else: '',
+                        else: {
+                          $cond: {
+                            if: {
+                              $and: [
+                                {
+                                  $gt: [ '$fixtureCount', 0 ],
+                                },
+                                {
+                                  $gt: [
+                                    '$fixtureDisagree',
+                                    0,
+                                  ],
+                                },
+                              ],
+                            },
+                            then: 'disagree',
+                            else: '',
+                          },
+                        },
                       },
                     },
                   },
@@ -4133,6 +4267,7 @@ export async function getTaskDetails( req, res ) {
                       $and: [
                         { $gt: [ '$vmCount', 0 ] },
                         { $eq: [ '$vmPending', 0 ] },
+                        { $eq: [ '$vmDisagree', 0 ] },
                       ],
                     },
                     then: 'complete',
@@ -4145,7 +4280,25 @@ export async function getTaskDetails( req, res ) {
                           ],
                         },
                         then: 'pending',
-                        else: '',
+                        else: {
+                          $cond: {
+                            if: {
+                              $and: [
+                                {
+                                  $gt: [ '$vmCount', 0 ],
+                                },
+                                {
+                                  $gt: [
+                                    '$vmDisagree',
+                                    0,
+                                  ],
+                                },
+                              ],
+                            },
+                            then: 'disagree',
+                            else: '',
+                          },
+                        },
                       },
                     },
                   },
@@ -4157,6 +4310,9 @@ export async function getTaskDetails( req, res ) {
                 fixtureCount: 1,
                 vmCount: 1,
                 completeLayout: 1,
+                layoutDisagree: 1,
+                fixtureDisagree: 1,
+                vmDisagree: 1,
               },
             },
           ],
@@ -4206,8 +4362,11 @@ export async function getTaskDetails( req, res ) {
     ];
 
     let taskInfo = await planotaskService.aggregate( query );
-    let disabledInfo = taskInfo?.[0]?.taskStatus?.filter( ( ele ) => ( ( ele.feedbackStatus && ele.feedbackStatus != 'complete' ) || ele.status != 'submit' ) && !ele?.breach );
-    console.log( disabledInfo );
+    let disabledInfo = [];
+    let floorDetails = await layoutService.findOne( { _id: req.query.floorId }, { isEdited: 1 } );
+    if ( floorDetails && !floorDetails?.isEdited ) {
+      disabledInfo = taskInfo?.[0]?.taskStatus?.filter( ( ele ) => ( ( ele.feedbackStatus && ![ 'complete', 'disagree' ].includes( ele.feedbackStatus ) ) || ele.status != 'submit' ) && !ele?.breach );
+    }
     return res.sendSuccess( { taskDetails: taskInfo?.[0]?.taskStatus, disabled: disabledInfo?.length ? true : false } );
   } catch ( e ) {
     logger.error( { functionName: 'getTaskDetails', error: e } );

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, insertOpenSearchData } 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';
@@ -215,8 +215,8 @@ export async function createTask( req, res ) {
           scheduleEndTime_iso: dayjs.utc( endDate, 'YYYY-MM-DD hh:mm A' ).format(),
           allowedOverTime: false,
           allowedStoreLocation: req.body?.geoFencing || false,
-          createdBy: task.createdBy,
-          createdByName: task.createdByName,
+          createdBy: req?.user?._id || task?.createdBy,
+          createdByName: req?.user?.userName || task?.createdByName,
           questionAnswers: [],
           isdeleted: false,
           questionCount: 0,
@@ -598,7 +598,8 @@ export async function updateAnswersv2( req, res ) {
     if ( !taskDetails ) {
       return res.sendError( 'No data found', 204 );
     }
-
+    console.log( req.body.answers[0] );
+    console.log( req.body.answers[0].issues[0] );
     let data = {
       fixtureId: req.body.fixtureId,
       answers: req.body.answers,
@@ -612,13 +613,16 @@ export async function updateAnswersv2( req, res ) {
       storeName: req.body?.storeName,
       storeId: req.body?.storeId,
     };
-    console.log( '111111', data );
+    console.log( '111111', data.answers[0] );
+    console.log( '111111', data.answers[0].issues[0] );
     if ( req.body.type==='layout' ) {
       await planoTaskService.updateOne( { planoId: req.body.planoId, taskType: req.body.taskType, 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 );
     } else {
       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 );
     }
 
+    await insertOpenSearchData( JSON.parse( process.env.OPENSEARCH ).planotaskcompliances, data );
+
     return res.sendSuccess( 'Fixture details updated successfully' );
   } catch ( e ) {
     logger.error( { functionName: 'updateAnswers', error: e } );

package/src/routes/fixtureTemplate.routes.js

@@ -14,5 +14,6 @@ fixtureTemplateRouter
     .post( '/getTemplateList', validate( validateDtos.fixtureVMListSchema ), fixtureTemplateController.getTemplateList )
     .get( '/getTemplateDetails', validate( validateDtos.queryTemplateId ), fixtureTemplateController.getTemplateDetails )
     .post( '/updateFixtureTask', validate( validateDtos.updateFixtureTask ), fixtureTemplateController.updateFixtureTask )
-    .post( '/getAllTemplates', fixtureTemplateController.getAllTemplates );
+    .post( '/getAllTemplates', fixtureTemplateController.getAllTemplates )
+    .get( '/getTemplate', validate( validateDtos.queryTemplateId ), fixtureTemplateController.getFixtureTemplate );
 

package/src/routes/planoLibrary.routes.js

@@ -14,7 +14,8 @@ planoLibraryRouter
     .post( '/fixtureList', isAllowedSessionHandler, validate( validateDtos.fixtureVMListSchema ), planoLibraryController.FixtureLibraryList )
     .post( '/duplicateFixture', isAllowedSessionHandler, validate( validateDtos.bodyFixtureId ), planoLibraryController.duplicateFixture )
     .post( '/deleteFixture', isAllowedSessionHandler, validate( validateDtos.bodyFixtureId ), planoLibraryController.deleteFixture )
-    .get( '/fixtureSizeList', isAllowedSessionHandler, validate( validateDtos.getClient ), planoLibraryController.getFixLibWidth );
+    .get( '/fixtureSizeList', isAllowedSessionHandler, validate( validateDtos.getClient ), planoLibraryController.getFixLibWidth )
+    .get( '/fixtureNameList', isAllowedSessionHandler, validate( validateDtos.getClient ), planoLibraryController.fixtureNameList );
 
 planoLibraryRouter
     .post( '/addVmType', isAllowedSessionHandler, validate( validateDtos.addVmType ), planoLibraryController.addVmType )
@@ -36,5 +37,6 @@ planoLibraryRouter
     .post( '/duplicateVmLib', isAllowedSessionHandler, validate( validateDtos.deleteVmLib ), planoLibraryController.duplicateVmLib )
     .post( '/deleteVmLib', isAllowedSessionHandler, validate( validateDtos.deleteVmLib ), planoLibraryController.deleteVmLibrary )
     .get( '/getVmDetails', isAllowedSessionHandler, validate( validateDtos.getVmDetails ), planoLibraryController.getVmDetails )
-    .post( '/vmBulkUpload', isAllowedSessionHandler, validate( validateDtos.vmBulkUpload ), planoLibraryController.vmBulkUpload );
+    .post( '/vmBulkUpload', isAllowedSessionHandler, validate( validateDtos.vmBulkUpload ), planoLibraryController.vmBulkUpload )
+    .get( '/vmNameList', isAllowedSessionHandler, validate( validateDtos.getClient ), planoLibraryController.vmNameList );