tango-app-api-store-builder 1.0.0-beta-198 → 1.0.0-beta-200

package/package.json

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

package/src/controllers/fixtureTemplate.controller.js

@@ -866,7 +866,6 @@ export async function TemplateStoresList( req, res ) {
 export async function replaceFixtureDetails( req, res ) {
   try {
     let inputData = req.body;
-    console.log( inputData );
     let replaceFixtureData = await fixtureConfigService.findOne( { _id: inputData.replaceFixture } );
 
     if ( !replaceFixtureData ) {
@@ -908,6 +907,16 @@ export async function replaceFixtureDetails( req, res ) {
       await templateLogService.create( data );
     }
     if ( inputData.storeList.length ) {
+      let storeList = inputData.storeList.map( ( ele ) => ele.storeId );
+      let getDetails = await storeFixtureService.find( { storeId: { $in: storeList }, fixtureConfigId: inputData.findFixture, $or: [ { isMerchEdited: true }, { isVmEdited: true } ] }, { storeId: 1 } );
+      if ( getDetails.length ) {
+        await Promise.all( getDetails.map( async ( ele ) => {
+          let taskDetails = await processedTaskService.findOne( { store_id: ele.storeId, isPlano: true, planoType: [ 'merchRollout', 'vmRollout' ] }, {}, { _id: -1 } );
+          if ( taskDetails ) {
+            await processedTaskService.deleteOne( { _id: taskDetails._id } );
+          }
+        } ) );
+      }
       const updateData = {
         ...replaceFixtureData.toObject(),
         fixtureConfigId: replaceFixtureData._id,

package/src/controllers/storeBuilder.controller.js

@@ -2634,6 +2634,142 @@ export async function qrScan( req, res ) {
   }
 }
 
+export async function qrScan1( req, res ) {
+  try {
+    if ( !req.body.floorId ) return res.sendError( 'Floor id is required', 400 );
+
+    if ( !req.body.fixtureId ) return res.sendError( 'Fixture id is required', 400 );
+
+    if ( !req.body.rfId.length ) return res.sendError( 'RFID is required', 400 );
+    const fixture = await storeFixtureService.findOne(
+        { _id: new mongoose.Types.ObjectId( req.body.fixtureId ) },
+        { storeId: 1, storeName: 1, planoId: '$_id', productResolutionLevel: 1 },
+    );
+
+    if ( !fixture ) return res.sendError( 'No data found', 204 );
+
+    const currentDate = new Date( dayjs().format( 'YYYY-MM-DD' ) );
+
+    async function getFixtureMetrics( fixture, currentDate ) {
+      const [ totalProducts, scannedProducts, misplacedProducts, properProducts, missingProducts ] = await Promise.all( [
+        planoMappingService.count( { fixtureId: fixture.toObject()._id } ),
+        planoComplianceService.count( { fixtureId: fixture.toObject()._id, date: currentDate } ),
+        planoComplianceService.count( { fixtureId: fixture.toObject()._id, date: currentDate, compliance: 'misplaced' } ),
+        planoComplianceService.count( { fixtureId: fixture.toObject()._id, date: currentDate, compliance: 'proper' } ),
+        planoComplianceService.count( { fixtureId: fixture.toObject()._id, date: currentDate, compliance: 'missing' } ),
+      ] );
+
+      const fixtureMetrics = {
+        total: totalProducts,
+        scanned: scannedProducts,
+        misplaced: misplacedProducts,
+        proper: properProducts,
+        missing: missingProducts,
+      };
+
+      return fixtureMetrics;
+    }
+
+
+    if ( fixture.productResolutionLevel === 'L1' ) {
+      const mappingQuery = {
+        planoId: req.body.planoId,
+        floorId: req.body.floorId,
+        fixtureId: req.body.fixtureId,
+        rfId: { $in: req.body.rfId },
+      };
+
+      const productMapping = await planoMappingService.find( mappingQuery );
+
+      if ( !productMapping.length ) {
+        const misplacedQuery = {
+          planoId: req.body.planoId,
+          floorId: req.body.floorId,
+          rfId: { $in: req.body.rfId },
+        };
+        const misplacedProductMapping = await planoMappingService.find( misplacedQuery );
+
+        if ( !misplacedProductMapping.length ) {
+          return res.sendSuccess( { data: null, status: 'missing' } );
+        }
+        misplacedProductMapping.forEach( ( ele ) => {
+          const complianceData={ ...ele.toObject(), planoMappingId: ele._id, compliance: 'misplaced' };
+          delete complianceData._id;
+          planoComplianceService.updateOne( { ...misplacedQuery, date: currentDate }, complianceData );
+        } );
+
+        // const complianceData = { ...misplacedProductMapping.toObject(), planoMappingId: misplacedProductMapping.toObject()._id, compliance: 'misplaced' };
+
+
+        const fm = await getFixtureMetrics( fixture, currentDate );
+
+        return res.sendSuccess( { data: misplacedProductMapping, fixtureMetrics: fm, status: 'misplaced' } );
+      }
+
+      productMapping.forEach( async ( ele ) => {
+        const complianceData = { ...ele.toObject(), planoMappingId: ele._id, compliance: 'proper' };
+        delete complianceData._id;
+
+        await planoComplianceService.updateOne( { ...mappingQuery, date: currentDate }, complianceData );
+      } );
+
+
+      const fm = await getFixtureMetrics( fixture, currentDate );
+
+
+      return res.sendSuccess( { data: { ...productMapping.toObject() }, fixtureMetrics: fm, status: 'proper' } );
+    } else if ( fixture.productResolutionLevel === 'L3' ) {
+      const sectionShelves = await fixtureShelfService.find( { fixtureId: fixture._id, sectionName: req.body.sectionName } );
+
+      if ( !sectionShelves.length ) return res.sendError( 'No shelves found for the Section', 400 );
+
+      const shelfIds = sectionShelves.map( ( shelf ) => shelf.toObject()._id );
+
+      const planoMapping = await planoMappingService.find( { rfId: { $in: req.body.rfId }, shelfId: { $in: shelfIds } } );
+
+      if ( !planoMapping.length ) {
+        const locatePlano = await planoMappingService.find( { rfId: { $in: req.body.rfId }, floorId: req.body.floorId } );
+
+        if ( !locatePlano.length ) {
+          return res.sendSuccess( { data: null, fixtureMetrics: null, status: 'missing' } );
+        }
+
+        locatePlano.forEach( ( ele ) => {
+          const complianceData = { ...ele.toObject(), planoMappingId: ele.toObject()._id, compliance: 'misplaced' };
+          delete complianceData._id;
+          planoComplianceService.updateOne( { date: currentDate, planoMappingId: ele.toObject()._id }, complianceData );
+        } );
+
+
+        const fm = await getFixtureMetrics( fixture, currentDate );
+
+
+        return res.sendSuccess( { data: { ...locatePlano.toObject() }, fixtureMetrics: fm, status: 'misplaced' } );
+      }
+
+      planoMapping.forEach( async ( ele ) => {
+        const complianceData = { ...ele.toObject(), planoMappingId: ele.toObject()._id, compliance: 'proper' };
+        delete complianceData._id;
+        await planoComplianceService.updateOne( { date: currentDate, planoMappingId: ele.toObject()._id }, complianceData );
+      } );
+
+      // const mapingData = planoMapping.toObject();
+
+      // delete mapingData._id;
+
+
+      const fm = await getFixtureMetrics( fixture, currentDate );
+
+      return res.sendSuccess( { data: planoMapping, fixtureMetrics: fm, status: 'proper' } );
+    } else {
+      return res.sendError( 'Incorrect resolution level', 400 );
+    }
+  } catch ( e ) {
+    logger.error( { functionName: 'scanv1', error: e, message: req.body } );
+    return res.sendError( e, 500 );
+  }
+}
+
 export async function storeFixturesv2( req, res ) {
   try {
     const planoIds = req.body.id
@@ -3240,7 +3376,7 @@ export async function planoList( req, res ) {
     let page = inputData?.offset - 1 || 0;
     let skip = limit * page;
 
-    let storeDetails = await storeService.find( { clientId: inputData.clientId, status: 'active' }, { storeId: 1 } );
+    let storeDetails = await storeService.find( { clientId: inputData.clientId, status: 'active', ...( inputData?.stores?.length && { storeId: { $in: inputData.stores } } ) }, { storeId: 1 } );
     storeDetails = storeDetails.map( ( ele ) => ele.storeId );
 
     let query = [
@@ -4553,7 +4689,7 @@ export async function getRolloutDetails( req, res ) {
     let page = req?.body?.offset || 1;
     let limit = req.body?.limit || 10;
     let skip = ( page -1 ) * limit;
-    let storeDetails = await storeService.find( { clientId: req.body.clientId, status: 'active' }, { storeId: 1 } );
+    let storeDetails = await storeService.find( { clientId: req.body.clientId, status: 'active', ...( req.body?.stores?.length && { storeId: { $in: req.body.stores } } ) }, { storeId: 1 } );
     storeDetails = storeDetails.map( ( ele ) => ele.storeId );
     let query = [
       {

package/src/routes/storeBuilder.routes.js

@@ -44,6 +44,7 @@ storeBuilderRouter
     .post( '/checkPlanoExist', isAllowedSessionHandler, storeBuilderController.checkPlanoExist )
     .post( '/storeLayoutElements', isAllowedSessionHandler, storeBuilderController.storeLayoutElements )
     .post( '/qrScan', storeBuilderController.qrScan )
+    .post( '/qrScan1', storeBuilderController.qrScan1 )
     .post( '/storeFixturesV2', isAllowedSessionHandler, validate( validateDtos.storeList ), storeBuilderController.storeFixturesv2 )
     .post( '/fixtureShelfDetailsv2', isAllowedSessionHandler, validate( validateDtos.fixtureShelfProduct ), storeBuilderController.fixtureShelfProductv2 )
     .post( '/storeFixturesTaskv2', isAllowedSessionHandler, storeBuilderController.storeFixturesTaskv2 );

package/src/service/processedTaskservice.js

@@ -16,6 +16,10 @@ export async function deleteMany( query = {} ) {
   return model.taskProcessedModel.deleteMany( query );
 }
 
+export async function deleteOne( query = {} ) {
+  return model.taskProcessedModel.deleteOne( query );
+}
+
 export async function aggregate( query = {} ) {
   return model.taskProcessedModel.aggregate( query );
 }