tango-app-api-store-builder 1.0.16 → 1.0.18

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "tango-app-api-store-builder",
-    "version": "1.0.16",
+    "version": "1.0.18",
     "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.5.3",
+        "tango-api-schema": "^2.5.13",
         "tango-app-api-middleware": "3.1.48",
         "url": "^0.11.4",
         "winston": "^3.17.0",

package/src/controllers/fixtureTemplate.controller.js

@@ -602,6 +602,7 @@ export async function assigedTemplate( req, res ) {
         $match: {
           ...( req.body?.clientId && { clientId: req.body?.clientId } ),
           templateType: 'sub',
+          ...( req.body.clientId && { clientId: req.body.clientId } ),
         },
       },
       {

package/src/controllers/managePlano.controller.js

@@ -1,9 +1,10 @@
 import * as floorService from '../service/storeBuilder.service.js';
-import { logger, insertOpenSearchData, getOpenSearchData } from 'tango-app-api-middleware';
+import { logger, insertOpenSearchData, getOpenSearchData, updateOpenSearchData, getOpenSearchById } from 'tango-app-api-middleware';
 // import * as storeService from '../service/store.service.js';
 import * as planoService from '../service/planogram.service.js';
 import * as storeFixtureService from '../service/storeFixture.service.js';
 import * as fixtureShelfService from '../service/fixtureShelf.service.js';
+import * as storeBuilderService from '../service/storeBuilder.service.js';
 // import * as planoProductService from '../service/planoProduct.service.js';
 import * as planoVmService from '../service/planoVm.service.js';
 // import * as planoMappingService from '../service/planoMapping.service.js';
@@ -18,6 +19,9 @@ import mongoose from 'mongoose';
 import * as planoRevisionService from '../service/planoRevision.service.js';
 import * as planoVmDuplicateService from '../service/planoVmDuplicate.service.js';
 import * as vmTypeService from '../service/vmType.service.js';
+import * as planoMappingService from '../service/planoMapping.service.js';
+import * as planoComplianceService from '../service/planoCompliance.service.js';
+import dayjs from 'dayjs';
 export async function getplanoFeedback( req, res ) {
   try {
     const taskTypes = req.body.filterByTask && req.body.filterByTask.length > 0 ? req.body.filterByTask : [ 'layout', 'fixture', 'vm' ];
@@ -115,6 +119,7 @@ export async function getplanoFeedback( req, res ) {
           let data = {};
           if ( aiDetails?.body?.hits?.hits.length ) {
             data = aiDetails?.body?.hits?.hits?.[0]?._source;
+            console.log( data, 'data' );
             delete data.isEmpty;
             delete data.fixtureFound;
           }
@@ -281,6 +286,18 @@ function buildPipelineByType( type, planoId, floorId, filterByStatus, filterByAp
         'FixtureData.shelfConfig': '$Fixtureshelves',
       },
     },
+
+    {
+      $set: {
+        'FixtureData.shelfConfig': {
+          $sortArray: {
+            input: '$FixtureData.shelfConfig',
+            sortBy: { shelfNumber: 1 },
+          },
+        },
+      },
+    },
+
   ];
 
   const vmStages = [ 'vm', 'vmRollout' ].includes( type ) ? [
@@ -1022,7 +1039,10 @@ export async function updateFixtureStatus( req, res ) {
       await planoTaskService.updateOnefilters(
           { _id: new mongoose.Types.ObjectId( req.body._id ) },
           {
-            $set: { 'answers.$[ans].status': req.body.type },
+            $set: {
+              'answers.$[ans].status': req.body.type,
+              'answers.$[ans].userAction': req.body.userAction,
+            },
           },
           [
             { 'ans._id': new mongoose.Types.ObjectId( req.body.answerId ) },
@@ -1287,7 +1307,7 @@ export async function updateStoreFixture( req, res ) {
 
     const currentFixture = await storeFixtureService.findOne( { _id: new mongoose.Types.ObjectId( fixtureId ) } );
     let currentFixtureDoc = currentFixture.toObject();
-    if ( req?.body?.taskType?.includes( 'fixture' ) || data?.taskType?.includes( 'fixture' ) ) {
+    if ( data?.userAction === 'editWithAi' || data?.userAction === 'acceptAi' ) {
       let shelfDetails = await fixtureShelfService.find( { fixtureId: fixtureId } );
       data.shelfConfig.forEach( ( ele ) => {
         let findShelfProduct = shelfDetails.find( ( shelf ) => shelf.shelfNumber == ele.shelfNumber );
@@ -1523,7 +1543,8 @@ export async function updateStoreFixture( req, res ) {
       } );
     }
     await planoService.updateOne( { _id: currentFixtureDoc?.planoId }, { $set: { updatedAt: new Date() } } );
-    if ( data?.taskType?.includes( 'fixture' ) ) {
+
+    if ( data?.userAction === 'editWithAi' || data?.userAction === 'editWithPlano' ) {
       let comments = {
         userId: req.user._id,
         userName: req.user.userName,
@@ -1531,7 +1552,8 @@ export async function updateStoreFixture( req, res ) {
         responsetype: 'agree',
         comment: '',
       };
-      await planoTaskService.updateOne( { planoId: currentFixture.planoId, floorId: currentFixture.floorId, fixtureId: currentFixture._id }, { 'answers.0.status': 'agree', 'approvalStatus': 'approved' } );
+      await planoTaskService.updateOne( { planoId: currentFixture.planoId, floorId: currentFixture.floorId, fixtureId: currentFixture._id }, { 'answers.0.status': 'agree', 'approvalStatus': 'approved', 'answers.0.userAction': data.userAction } );
+
       await planoTaskService.updateOnefilters(
           { planoId: new mongoose.Types.ObjectId( currentFixture.planoId ), floorId: new mongoose.Types.ObjectId( currentFixture.floorId ), fixtureId: new mongoose.Types.ObjectId( currentFixture._id ) },
           {
@@ -1539,9 +1561,15 @@ export async function updateStoreFixture( req, res ) {
           },
       );
     }
-    if ( req.body?.editMode ) {
-      await floorService.updateOne( { _id: new mongoose.Types.ObjectId( currentFixture.floorId ) }, { isEdited: true } );
+
+    if ( data?.userAction === 'editWithAi' || data?.userAction === 'acceptAi' ) {
+      const op_id = `${data?.storeName}_${data?.storeDate}_${data?._id}`;
+      await updateAIFeedbackInOpenSearch( data, op_id );
     }
+
+    // if ( req.body?.editMode ) {
+    //   await floorService.updateOne( { _id: new mongoose.Types.ObjectId( currentFixture.floorId ) }, { isEdited: true } );
+    // }
     res.sendSuccess( { message: 'Updated Successfully', ...( configId && { id: configId } ) } );
   } catch ( e ) {
     logger.error( { functionName: 'updateStoreFixture', error: e } );
@@ -1549,6 +1577,62 @@ export async function updateStoreFixture( req, res ) {
   }
 }
 
+const updateAIFeedbackInOpenSearch = async ( fixtureData, id ) => {
+  try {
+    let openSearchDetails = await getOpenSearchById( JSON.parse( process.env.OPENSEARCH ).planoAIValidation, id );
+    if ( openSearchDetails && openSearchDetails.statusCode == 200 && openSearchDetails?.body?._source ) {
+      const doc = {
+        'fixtureId': fixtureData._id,
+        'fixtureCapacity': fixtureData.fixtureCapacity,
+        'fixtureType': fixtureData.fixtureType,
+        'fixtureCategory': fixtureData.fixtureCategory,
+        'header': {
+          'label': fixtureData.header.label,
+        },
+        'vmConfig': fixtureData?.vmConfig.map( ( vm ) => {
+          return {
+            'vmType': vm.vmType,
+            'startYPosition': vm.startYPosition,
+            'endYPosition': vm.endYPosition,
+            'xZone': vm.xZone,
+            'yZone': vm.yZone,
+            'vmImage': vm.vmImage,
+            'vmName': vm.vmName,
+          };
+        } ) ?? [
+
+        ],
+        'shelfConfig': fixtureData?.shelfConfig.map( ( s ) => {
+          return {
+            'shelfNumber': s.shelfNumber,
+            'shelfType': s.shelfType,
+            'productPerShelf': s.productPerShelf,
+            'trayRows': s.trayRows,
+          };
+        } ) ?? [],
+        'fixtureImage': fixtureData.fixtureImage,
+        'storeDate': fixtureData.storeDate,
+      };
+
+      const document = {
+        doc: doc,
+      };
+
+      let updateResult = await updateOpenSearchData( JSON.parse( process.env.OPENSEARCH ).planoAIValidation, id, document );
+
+      if ( updateResult?.statusCode == 200 ) {
+        return true;
+      }
+      return false;
+    } else {
+      return false;
+    }
+  } catch ( e ) {
+    logger.error( { error: e, function: 'updateAIFeedbackInOpenSearch' } );
+    return false;
+  }
+};
+
 export async function updateredostatus( req, res ) {
   try {
     if ( req.body.type === 'layout' ) {
@@ -1609,6 +1693,7 @@ export async function updateGlobalComment( req, res ) {
     return res.sendError( e, 500 );
   }
 }
+
 export async function getGlobalComment( req, res ) {
   try {
     // let layoutComment = await planoGlobalCommentService.find( {
@@ -1642,19 +1727,36 @@ export async function getGlobalComment( req, res ) {
 
 export async function getAllPlanoRevisions( req, res ) {
   try {
-    const { clientId } = req.body;
+    const { planoId, floorId, storeId } = req.body;
 
-    if ( !clientId ) {
-      return res.sendError( 'Client Id is required', 400 );
+    if ( !storeId || !planoId || !floorId ) {
+      return res.sendError( 'Required field is missing', 400 );
     }
 
-    const revisions = await planoRevisionService.find(
-        { clientId },
-        { storeName: 1, storeId: 1, planoId: 1, floorId: 1, createdAt: 1 },
-    );
+    let query = [
+      {
+        $match: {
+          storeId: storeId,
+          planoId: new mongoose.Types.ObjectId( planoId ),
+          floorId: new mongoose.Types.ObjectId( floorId ),
+        },
+      },
+      {
+        $sort: { _id: -1 },
+      },
+      {
+        $limit: 5,
+      },
+      {
+        $sort: { _id: 1 },
+      },
+    ];
+
+    const revisions = await planoRevisionService.aggregate( query );
 
     res.sendSuccess( revisions );
   } catch ( e ) {
+    console.log( e );
     logger.error( { functionName: 'getAllPlanoRevisions', error: e } );
     res.sendError( 'Failed to fetch plano revisions', 500 );
   }
@@ -1662,22 +1764,44 @@ export async function getAllPlanoRevisions( req, res ) {
 
 export async function createPlanoRevision( req, res ) {
   try {
-    const { storeName, storeId, clientId, planoId, floorId, floorData } = req.body;
+    let { storeName, storeId, clientId, planoId, floorId, floorData } = req.body;
 
     if ( !storeName || !storeId || !clientId || !planoId || !floorId || !floorData ) {
       return res.sendError( 'Missing required fields', 400 );
     }
+    let planoProductCount = 0;
+    floorData.layoutPolygon.forEach( ( poly ) => {
+      poly.fixtures.forEach( ( fixt ) => {
+        planoProductCount += fixt.fixtureCapacity;
+      } );
+    } );
 
-    const newRevision = await planoRevisionService.create( {
-      storeName,
-      storeId,
-      clientId,
-      planoId,
-      floorId,
-      floorData,
+    floorData.centerFixture.forEach( ( fixt ) => {
+      planoProductCount += fixt.fixtureCapacity;
     } );
 
-    res.sendSuccess( newRevision );
+    floorData = { ...floorData, planoProductCount };
+
+    const data = {
+      storeName: storeName,
+      storeId: storeId,
+      clientId: clientId,
+      planoId: planoId,
+      productResolutionLevel: req.body.productResolutionLevel,
+      scanType: req.body.scanType,
+      createdByName: req.user.userName,
+      createdByEmail: req.user.email,
+      createdBy: req.user._id,
+      layoutName: req.body.layoutName,
+      floorId: floorId,
+      floorData: floorData,
+    };
+
+    await planoRevisionService.create( data );
+
+    await storeBuilderService.updateOne( { _id: floorId }, { ...( req.body.type == 'rollout' ) ? { rolloutStatus: true } : { verificationStatus: true } } );
+
+    res.sendSuccess( 'Plano published successfully' );
   } catch ( e ) {
     logger.error( { functionName: 'createPlanoRevision', error: e } );
     res.sendError( 'Failed to create plano revision', 500 );
@@ -1686,26 +1810,144 @@ export async function createPlanoRevision( req, res ) {
 
 export async function getPlanoRevisionById( req, res ) {
   try {
-    const { id } = req.params;
+    let { clientId, planoId } = req.body;
 
-    if ( !id ) {
-      return res.sendError( 'Revision ID is required', 400 );
+    if ( req.body?.id ) {
+      const planoDetails = await planoService.findOne( { ...( !mongoose.Types.ObjectId.isValid( req.body?.id ) && { storeId: req.body.id } ), ...( mongoose.Types.ObjectId.isValid( req.body?.id ) && { _id: req.body.id } ) }, { _id: 1, clientId: 1 } );
+      if ( !planoDetails ) {
+        return res.sendError( 'No data found', 204 );
+      }
+      planoId = planoDetails._id;
+      clientId = planoDetails.clientId;
     }
 
-    const revision = await planoRevisionService.findOne(
-        { _id: id },
-    );
+    if ( !clientId || !planoId ) {
+      return res.sendError( 'Required field is missing', 400 );
+    }
 
-    if ( !revision ) {
-      return res.sendError( 'Plano revision not found', 404 );
+    let query = [
+      {
+        $match: {
+          planoId: new mongoose.Types.ObjectId( planoId ),
+          clientId: clientId,
+        },
+      },
+      {
+        $sort: { _id: -1 },
+      },
+      {
+        $group: {
+          _id: { plano: '$planoId', floor: '$floorId' },
+          storeName: { $first: '$storeName' },
+          storeId: { $first: '$storeId' },
+          productResolutionLevel: { $first: '$productResolutionLevel' },
+          scanType: { $first: '$scanType' },
+          layoutName: { $first: '$layoutName' },
+          floorData: { $first: '$floorData' },
+          floorData: { $first: '$floorData' },
+          revisionId: { $first: '$_id' },
+        },
+      },
+      {
+        $group: {
+          _id: '$_id.plano',
+          storeName: { $first: '$storeName' },
+          storeId: { $first: '$storeId' },
+          productResolutionLevel: { $first: '$productResolutionLevel' },
+          scanType: { $first: '$scanType' },
+          layoutName: { $first: '$layoutName' },
+          floors: { $push: '$floorData' },
+          revisionId: { $first: '$revisionId' },
+        },
+      },
+      {
+        $limit: 1,
+      },
+    ];
+
+    let revisions = await planoRevisionService.aggregate( query );
+    if ( !revisions.length ) {
+      return res.sendError( 'No data found', 204 );
     }
+    let currentDate = new Date( dayjs().format( 'YYYY-MM-DD' ) );
+    revisions[0].floors = await Promise.all( revisions?.[0]?.floors.map( async ( floor ) => {
+      floor.layoutPolygon = await Promise.all( floor.layoutPolygon.map( async ( poly ) => {
+        poly.fixtures = await Promise.all( poly.fixtures.map( async ( fixture ) => {
+          fixture.shelfConfig = await Promise.all( fixture.shelfConfig.map( async ( shelf ) => {
+            const productDetails = await planoMappingService.find( { fixtureId: fixture._id, shelfId: shelf._id, type: 'product' }, { _id: 1 } );
+            let productIdList = productDetails.map( ( ele ) => ele._id );
+            let complianceQuery = [
+              {
+                $match: {
+                  fixtureId: fixture._id,
+                  shelfId: shelf._id,
+                  date: currentDate,
+                  planoMappingId: { $in: productIdList },
+                },
+              },
+              {
+                $group: {
+                  _id: '$createdAt',
+                  status: { $push: '$compliance' },
+                },
+              },
+              {
+                $sort: { _id: -1 },
+              },
+              {
+                $limit: 1,
+              },
+            ];
+            let complianceStatus = await planoComplianceService.aggregate( complianceQuery );
+            shelf.compliance = complianceStatus?.[0]?.status.length ? ( ( complianceStatus?.[0]?.status?.length != shelf.productPerShelf ) || complianceStatus?.[0]?.status?.includes( 'misplaced' ) ) ? 'improper' : 'proper' : 'improper';
+            return shelf;
+          } ) );
+          return fixture;
+        } ) );
+        return poly;
+      } ) );
+      floor.centerFixture = await Promise.all( floor.centerFixture.map( async ( fixture ) => {
+        fixture.shelfConfig = await Promise.all( fixture.shelfConfig.map( async ( shelf ) => {
+          const productDetails = await planoMappingService.find( { fixtureId: fixture._id, shelfId: shelf._id, type: 'product' }, { _id: 1 } );
+          let productIdList = productDetails.map( ( ele ) => ele._id );
+          let complianceQuery = [
+            {
+              $match: {
+                fixtureId: fixture._id,
+                shelfId: shelf._id,
+                date: currentDate,
+                planoMappingId: { $in: productIdList },
+              },
+            },
+            {
+              $group: {
+                _id: '$createdAt',
+                status: { $push: '$compliance' },
+              },
+            },
+            {
+              $sort: { _id: -1 },
+            },
+            {
+              $limit: 1,
+            },
+          ];
+          let complianceStatus = await planoComplianceService.aggregate( complianceQuery );
+          shelf.compliance = complianceStatus?.[0]?.status.length ? ( ( complianceStatus?.[0]?.status?.length != shelf.productPerShelf ) || complianceStatus?.[0]?.status?.includes( 'misplaced' ) ) ? 'improper' : 'proper' : 'improper';
+          return shelf;
+        } ) );
+        return fixture;
+      } ) );
+      return floor;
+    } ) );
 
-    res.sendSuccess( revision );
+    res.sendSuccess( revisions );
   } catch ( e ) {
     logger.error( { functionName: 'getPlanoRevisionById', error: e } );
-    res.sendError( 'Failed to fetch plano revision', 500 );
+    res.sendError( 'Failed to fetch plano revisions', 500 );
   }
 }
+
 export async function getRolloutFeedback( req, res ) {
   try {
     const taskTypes = req.body.filterByTask && req.body.filterByTask.length > 0 ? req.body.filterByTask : [ 'merchRollout', 'vmRollout' ];

package/src/controllers/script.controller.js

@@ -27,6 +27,7 @@ import fs from 'fs';
 import os from 'os';
 import { fileURLToPath } from 'url';
 import path from 'path';
+const ObjectId=mongoose.Types.ObjectId;
 
 const __filename = fileURLToPath( import.meta.url );
 const __dirname = path.dirname( __filename );
@@ -17358,6 +17359,91 @@ async function createUser( data ) {
   }
 }
 
+export async function createLayout( req, res ) {
+  try {
+    let storeDetails = await storeService.find( { storeName: { $in: req.body.storeName }, clientId: req.body.clientId, status: 'active' }, { storeName: 1, storeId: 1 } );
+    if ( !storeDetails ) {
+      return res.sendError( 'No data found', 204 );
+    }
+    await Promise.all( storeDetails.map( async ( store ) => {
+      let planoDetails = await storeBuilderService.find( { storeName: store.storeName }, { planoId: 1, _id: 1 } );
+      await Promise.all( planoDetails.map( async ( task ) => {
+        let getLayoutDetails = await processedTaskService.findOne( { storeName: store.storeName, planoType: 'layout' }, { _id: 1 } );
+        if ( !getLayoutDetails ) {
+          let data = {
+            client_id: req.body.clientId,
+            date_iso: new Date( dayjs().format( 'YYYY-MM-DD' ) ),
+            date_string: dayjs().format( 'YYYY-MM-DD' ),
+            sourceCheckList_id: new ObjectId(),
+            checkListName: 'Layout Verification',
+            checkListId: new ObjectId(),
+            scheduleStartTime: dayjs().format( 'hh:mm A' ),
+            scheduleEndTime: dayjs().format( 'hh:mm A' ),
+            scheduleStartTime_iso: dayjs().format(),
+            scheduleEndTime_iso: dayjs().format(),
+            allowedOverTime: false,
+            allowedStoreLocation: false,
+            createdBy: new ObjectId(),
+            createdByName: 'tango',
+            questionAnswers: [],
+            isdeleted: false,
+            questionCount: 0,
+            storeCount: 0,
+            locationCount: 0,
+            checkListType: 'task',
+            country: '',
+            store_id: store.storeId,
+            storeName: store.storeName,
+            userId: new ObjectId(),
+            userName: 'tango',
+            userEmail: 'tango@tangotech.co.in',
+            checklistStatus: 'submit',
+            timeFlagStatus: true,
+            timeFlag: 0,
+            questionFlag: 0,
+            mobileDetectionFlag: 0,
+            storeOpenCloseFlag: 0,
+            reinitiateStatus: false,
+            markasread: false,
+            uniformDetectionFlag: 0,
+            scheduleRepeatedType: 'daily',
+            approvalStatus: false,
+            approvalEnable: false,
+            redoStatus: false,
+            isPlano: true,
+            planoType: 'layout',
+            planoId: task.planoId,
+            floorId: task._id,
+          };
+
+          let taskData = await processedTaskService.create( data );
+          let layoutData = {
+            "date_string": dayjs().format( 'YYYY-MM-DD' ),
+            "floorId": task._id,
+            "fixtureId": null,
+            "planoId": task.planoId,
+            "taskType": "initial",
+            "type": "layout",
+            "taskId": taskData._id,
+            "answers": [],
+            "approvalStatus": "approved",
+            "date_iso": new Date( dayjs().format( 'YYYY-MM-DD' ) ),
+            "status": "complete",
+            "storeId": store.storeId,
+            "storeName": store.storeName,
+          };
+          await planoTaskService.create( layoutData );
+          await storeBuilderService.updateOne( { _id: task._id }, { planoProgress: 50 } );
+        }
+      } ) );
+    } ) );
+    return res.sendSuccess( 'Layout SUbmitted Successfully' );
+  } catch ( e ) {
+    logger.error( { functionName: 'createLayout', error: e } );
+    return res.sendError( e, 500 );
+  }
+}
+
 async function standardizeHeaders() {
   const headerMap = {
     "Innovation": "Innovation",
@@ -18537,3 +18623,27 @@ async function updateMellerCollection() {
 
 // updateMellerCollection();
 
+
+export async function updateProduct( req, res ) {
+  try {
+    let query = [
+      {
+        $group: {
+          _id: '$brandName',
+          id: { $first: '$_id' },
+        },
+      },
+    ];
+    let getProducts = await planoProductService.aggregate( query );
+    if ( getProducts.length ) {
+      await Promise.all( getProducts.map( async ( prod, index ) => {
+        await planoProductService.updateOne( { _id: prod.id }, { rfId: req.body.rfId[index] } );
+      } ) );
+    }
+
+    return res.sendSuccess( 'Updated Successfully' );
+  } catch ( e ) {
+    logger.error( { functionName: "updateProduct", error: e } );
+    return res.sendError( e, 500 );
+  }
+}