tango-app-api-store-builder 1.0.39 → 1.0.41

package/package.json

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

package/src/controllers/managePlano.controller.js

@@ -1929,9 +1929,19 @@ export async function getPlanoRevisionById( req, res ) {
               },
             ];
             let complianceStatus = await planoComplianceService.aggregate( complianceQuery );
+            if ( fixture._id.toString() == '690b3745e4c80c1a0572ae4e' ) {
+              console.log( complianceStatus?.[0]?.status, fixture._id.toString() );
+            }
             shelf.compliance = complianceStatus?.[0]?.status.length ? ( ( complianceStatus?.[0]?.status?.length != shelf.productPerShelf ) || complianceStatus?.[0]?.status?.includes( 'misplaced' ) ) ? 'improper' : 'proper' : 'improper';
             return shelf;
           } ) );
+          fixture.vmConfig = await Promise.all( fixture.vmConfig.map( async ( vm ) => {
+            const vmInfo = await planoVmService.findOne( { _id: vm.vmId } );
+            return {
+              ...vm,
+              ...vmInfo?.toObject(),
+            };
+          } ) );
           return fixture;
         } ) );
         return poly;
@@ -2369,11 +2379,11 @@ export async function createPlanoFromCAD( req, res ) {
     const file = req.files.file;
     const { storeId, floorNumber } = req.body;
 
-    if (!req?.files?.file) return res.sendError({ errMsg: 'File is required' }, 400);
+    if ( !req?.files?.file ) return res.sendError( { errMsg: 'File is required' }, 400 );
 
-    if (!storeId || !floorNumber) return res.sendError({ errMsg: 'storeId and floorNumber are required' }, 400);
+    if ( !storeId || !floorNumber ) return res.sendError( { errMsg: 'storeId and floorNumber are required' }, 400 );
 
-    if (!file.name.endsWith('.dxf')) return res.sendError({ errMsg: 'Only DXF files are allowed' }, 400);
+    if ( !file.name.endsWith( '.dxf' ) ) return res.sendError( { errMsg: 'Only DXF files are allowed' }, 400 );
 
 
     // if (file.size > 20 * 1024 * 1024) {
@@ -2391,7 +2401,7 @@ export async function createPlanoFromCAD( req, res ) {
 
     const fileRes = await fileUpload( fileUploadPayload );
 
-    if (!fileRes?.Key) return res.sendError({ errMsg: 'Failed to upload file to storage' }, 502);
+    if ( !fileRes?.Key ) return res.sendError( { errMsg: 'Failed to upload file to storage' }, 502 );
 
     // CAD Extraction
     const dataExtractPayload = {
@@ -2410,8 +2420,8 @@ export async function createPlanoFromCAD( req, res ) {
 
     if ( !cadRes.ok ) {
       const errorText = await cadRes.text();
-      logger.error({ cadLambdaError: errorText });
-      return res.sendError({ errMsg: 'CAD extraction service failed' }, 502);
+      logger.error( { cadLambdaError: errorText } );
+      return res.sendError( { errMsg: 'CAD extraction service failed' }, 502 );
     }
 
     const cadData = await cadRes.json();
@@ -2426,10 +2436,10 @@ export async function createPlanoFromCAD( req, res ) {
       !cadData?.data?.layoutPolygon
     ) {
       return res.sendError(
-        {
-          errMsg: 'Invalid CAD layout data',
-          errInfo: { cadData, input: dataExtractPayload }
-        }, 502);
+          {
+            errMsg: 'Invalid CAD layout data',
+            errInfo: { cadData, input: dataExtractPayload },
+          }, 502 );
     }
 
     const userMeta = {
@@ -2441,9 +2451,9 @@ export async function createPlanoFromCAD( req, res ) {
     // PLANOGRAM
     let planoData = await planoService.findOne( { storeId }, { _id: 1, clientId: 1, storeName: 1 } );
 
-    if (!planoData) {
-      const storeData = await storeService.findOne({ storeId }, { clientId: 1, storeName: 1 });
-      if (!storeData) return res.sendError({ errMsg: 'Unable to find the store to create planogram' }, 400);
+    if ( !planoData ) {
+      const storeData = await storeService.findOne( { storeId }, { clientId: 1, storeName: 1 } );
+      if ( !storeData ) return res.sendError( { errMsg: 'Unable to find the store to create planogram' }, 400 );
 
       const newPlano = {
         clientId: storeData.clientId,
@@ -2458,8 +2468,8 @@ export async function createPlanoFromCAD( req, res ) {
         ...userMeta,
       };
 
-      planoData = await planoService.create(newPlano);
-      if (!planoData) return res.sendError({ errMsg: 'Failed to create new planogram' }, 400);
+      planoData = await planoService.create( newPlano );
+      if ( !planoData ) return res.sendError( { errMsg: 'Failed to create new planogram' }, 400 );
     }
 
     const floorPayload = {
@@ -2486,8 +2496,8 @@ export async function createPlanoFromCAD( req, res ) {
         ...userMeta,
       };
 
-      floorData = await floorService.create(newFloor);
-      if (!floorData) return res.sendError({ errMsg: 'Failed to create new floor layout' }, 400);
+      floorData = await floorService.create( newFloor );
+      if ( !floorData ) return res.sendError( { errMsg: 'Failed to create new floor layout' }, 400 );
     }
 
     const meta = {
@@ -2499,36 +2509,36 @@ export async function createPlanoFromCAD( req, res ) {
     };
 
     // Create Fixtures
-    const processedFixtures = computeStoreFixtures(cadData.data, meta);
+    const processedFixtures = computeStoreFixtures( cadData.data, meta );
     const storeFixtures = [];
     const storeFixtureShelves = [];
 
     try {
-      await Promise.all([
-        fixtureShelfService.deleteMany({ floorId: meta.floorId }),
-        storeFixtureService.deleteMany({ floorId: meta.floorId }),
-      ]);
+      await Promise.all( [
+        fixtureShelfService.deleteMany( { floorId: meta.floorId } ),
+        storeFixtureService.deleteMany( { floorId: meta.floorId } ),
+      ] );
 
-      for (let i = 0; i < processedFixtures.length; i++) {
+      for ( let i = 0; i < processedFixtures.length; i++ ) {
         const fix = processedFixtures[i];
-        const fixRes = await storeFixtureService.create(fix);
-        if (fixRes) {
+        const fixRes = await storeFixtureService.create( fix );
+        if ( fixRes ) {
           const fixture = fixRes.toObject();
-          storeFixtures.push({ ...fixture, shelfConfig: fix.shelfConfig });
+          storeFixtures.push( { ...fixture, shelfConfig: fix.shelfConfig } );
 
-          const shelvesToCreate = fix?.shelfConfig?.map(s => {
+          const shelvesToCreate = fix?.shelfConfig?.map( ( s ) => {
             return {
               ...s,
               ...meta,
-              fixtureId: fixture._id
-            }
-          })
-          storeFixtureShelves.push(...shelvesToCreate);
+              fixtureId: fixture._id,
+            };
+          } );
+          storeFixtureShelves.push( ...shelvesToCreate );
         }
       }
 
-      if(storeFixtureShelves.length){
-        await fixtureShelfService.insertMany(storeFixtureShelves);
+      if ( storeFixtureShelves.length ) {
+        await fixtureShelfService.insertMany( storeFixtureShelves );
       }
     } catch ( e ) {
       logger.error( {
@@ -2539,25 +2549,24 @@ export async function createPlanoFromCAD( req, res ) {
 
 
     try {
-      const updateStoreFixtures = await processFixtureTemplates({ fixtures: storeFixtures });
+      const updateStoreFixtures = await processFixtureTemplates( { fixtures: storeFixtures } );
 
-      if (updateStoreFixtures.length) await storeFixtureService.bulkUpsert(updateStoreFixtures);
-    } catch (e) {
-      logger.error({
+      if ( updateStoreFixtures.length ) await storeFixtureService.bulkUpsert( updateStoreFixtures );
+    } catch ( e ) {
+      logger.error( {
         functionName: 'createPlanoFromCAD [Update Fixtures]',
         error: e,
-      });
+      } );
     }
 
-    return res.sendSuccess(meta);
-
-  } catch (error) {
-    logger.error({
+    return res.sendSuccess( meta );
+  } catch ( error ) {
+    logger.error( {
       functionName: 'createPlanoFromCAD',
       error,
     } );
 
-    return res.sendError({ errMsg: 'Failed to create planogram.' }, 500);
+    return res.sendError( { errMsg: 'Failed to create planogram.' }, 500 );
   }
 }
 
@@ -2602,7 +2611,7 @@ function transformFixtureData( data ) {
     associatedElementNumber: data?.wallNumber,
     associatedElementFixtureNumber: data.fixtureNumber,
     associatedElementType: f?.associatedElementType === 'wall' ? 'wall' : undefined,
-    productBrandName: Array.isArray(f?.productBrandName) ? f?.productBrandName?.map(normalizeCadText) : normalizeCadText(f?.productBrandName),
+    productBrandName: Array.isArray( f?.productBrandName ) ? f?.productBrandName?.map( normalizeCadText ) : normalizeCadText( f?.productBrandName ),
     shelfConfig: f?.shelfConfig ?? [],
     fixtureHeight: {
       value: 0,
@@ -2625,10 +2634,10 @@ function transformFixtureData( data ) {
 
 function computeStoreFixtures( data, meta ) {
   let fixtures = [];
-  const walls = (data?.layoutPolygon ?? []).filter(e => e.elementType === 'wall').sort((a,b) => a.elementNumber - b.elementNumber);
-  const allFixtures = walls.flatMap(w => w?.fixtures);
-  allFixtures.forEach((f,i) => f.fixtureNumber = i + 1);
-  
+  const walls = ( data?.layoutPolygon ?? [] ).filter( ( e ) => e.elementType === 'wall' ).sort( ( a, b ) => a.elementNumber - b.elementNumber );
+  const allFixtures = walls.flatMap( ( w ) => w?.fixtures );
+  allFixtures.forEach( ( f, i ) => f.fixtureNumber = i + 1 );
+
   for ( let i = 1; i <= walls.length; i++ ) {
     const w = walls[i - 1];
     const wFixtures = w?.fixtures ?? [];
@@ -2664,11 +2673,11 @@ function computeStoreFixtures( data, meta ) {
   return fixtures;
 }
 
-async function processFixtureTemplates(data) {
+async function processFixtureTemplates( data ) {
   const updateStoreFixtures = [];
   const newFixtureTemplates = [];
 
-  for (let i = 0; i < data.fixtures.length; i++) {
+  for ( let i = 0; i < data.fixtures.length; i++ ) {
     let fixture = data.fixtures[i];
     const mapKey = `${fixture.fixtureCategory}${fixture.fixtureWidth.value}${fixture.fixtureWidth.unit}${fixture.header.label}`;
 
@@ -2700,13 +2709,13 @@ async function processFixtureTemplates(data) {
       },
     ];
 
-    let [subTemplate, masterTemplate] = await Promise.all([
-      await fixtureConfigService.aggregate(subTemplateQuery),
-      await fixtureConfigService.aggregate(masterTemplateQuery),
-    ]);
+    let [ subTemplate, masterTemplate ] = await Promise.all( [
+      await fixtureConfigService.aggregate( subTemplateQuery ),
+      await fixtureConfigService.aggregate( masterTemplateQuery ),
+    ] );
 
 
-    if (!subTemplate?.length) {
+    if ( !subTemplate?.length ) {
       const templateGroupName = fixture.header.label;
       let templateIndex = 1;
 
@@ -2716,25 +2725,25 @@ async function processFixtureTemplates(data) {
         status: 'complete',
         templateIndex: masterTemplate.length ? masterTemplate.length + 1 : 1,
         crestMapKey: mapKey,
-      }
+      };
 
       delete newTemplateData._id;
 
-      if (!masterTemplate.length) {
+      if ( !masterTemplate.length ) {
         const newMasterTemplate = {
           ...newTemplateData,
           fixtureName: `${newTemplateData?.header?.label}-${newTemplateData?.fixtureCategory}`,
           templateType: 'master',
           crestMapKey: mapKey,
-        }
-        masterTemplate = await fixtureConfigService.create(newMasterTemplate);
+        };
+        masterTemplate = await fixtureConfigService.create( newMasterTemplate );
       } else {
         masterTemplate = masterTemplate[0];
 
         const masterTempIndexQuery = [
           {
             $match: {
-              masterTemplateId: new mongoose.Types.ObjectId(masterTemplate._id),
+              masterTemplateId: new mongoose.Types.ObjectId( masterTemplate._id ),
             },
           }, {
             $group: {
@@ -2744,7 +2753,7 @@ async function processFixtureTemplates(data) {
           },
         ];
 
-        const getMaxTempIndex = await fixtureConfigService.aggregate(masterTempIndexQuery);
+        const getMaxTempIndex = await fixtureConfigService.aggregate( masterTempIndexQuery );
         templateIndex = getMaxTempIndex?.[0]?.tempId + 1;
       }
 
@@ -2755,7 +2764,7 @@ async function processFixtureTemplates(data) {
       newTemplateData.createdAt = new Date();
       newTemplateData.updatedAt = new Date();
 
-      subTemplate = await fixtureConfigService.create(newTemplateData);
+      subTemplate = await fixtureConfigService.create( newTemplateData );
 
       fixture.fixtureConfigId = subTemplate._id;
       fixture.masterTemplateId = masterTemplate._id;
@@ -2767,9 +2776,9 @@ async function processFixtureTemplates(data) {
       fixture.masterTemplateId = sub?.masterTemplateId;
     }
 
-    newFixtureTemplates.push(subTemplate);
-    updateStoreFixtures.push(fixture);
+    newFixtureTemplates.push( subTemplate );
+    updateStoreFixtures.push( fixture );
   }
 
   return updateStoreFixtures;
-}
+}

package/src/controllers/script.controller.js

@@ -15434,3 +15434,376 @@ export async function update4487Inventory( req, res ) {
     return res.sendError( e.message || 'Internal Server Error', 500 );
   }
 }
+
+export async function insertAntennaMappingData( req, res ) {
+  try {
+    const storeName = "LKST4487";
+    let successCount = 0;
+    let errorCount = 0;
+    const errors = [];
+
+    const antennaMapingData = [
+      {
+        "fixtureNumber": 14,
+        "readerId": "a4:e8:a3:91:7f:01",
+        "storageBoxAntennaNo": [ 1, 2, 3, 6, 7 ],
+        "shelfConfig": [
+          { "shelfNumber": 1, "antennaNo": [ 18 ] },
+          { "shelfNumber": 2, "antennaNo": [ 16 ] },
+          { "shelfNumber": 3, "antennaNo": [ 15 ] },
+          { "shelfNumber": 4, "antennaNo": [ 20 ] },
+          { "shelfNumber": 5, "antennaNo": [ 19 ] },
+          { "shelfNumber": 6, "antennaNo": [ 17 ] },
+          { "shelfNumber": 7, "antennaNo": [ 12 ] },
+          { "shelfNumber": 8, "antennaNo": [ 10 ] },
+        ],
+      },
+      {
+        "fixtureNumber": 15,
+        "readerId": "a4:e8:a3:91:7f:01",
+        "storageBoxAntennaNo": [ 8, 9, 11, 13, 14 ],
+        "shelfConfig": [
+          { "shelfNumber": 1, "antennaNo": [ 26 ] },
+          { "shelfNumber": 2, "antennaNo": [ 25 ] },
+          { "shelfNumber": 3, "antennaNo": [ 24 ] },
+          { "shelfNumber": 4, "antennaNo": [ 23 ] },
+          { "shelfNumber": 5, "antennaNo": [ 22 ] },
+          { "shelfNumber": 6, "antennaNo": [ 21 ] },
+          { "shelfNumber": 7, "antennaNo": [ 4 ] },
+          { "shelfNumber": 8, "antennaNo": [ 5 ] },
+        ],
+      },
+      {
+        "fixtureNumber": 3,
+        "wallNumber": 1,
+        "readerId": "a4:e8:a3:91:7f:01",
+        "storageBoxAntennaNo": [ 25, 26, 27, 28, 29 ],
+        "shelfConfig": [
+          { "shelfNumber": 1, "antennaNo": [ 15 ] },
+          { "shelfNumber": 2, "antennaNo": [ 16 ] },
+          { "shelfNumber": 3, "antennaNo": [ 21, 19 ] },
+          { "shelfNumber": 4, "antennaNo": [ 17, 18 ] },
+          { "shelfNumber": 5, "antennaNo": [ 20, 22 ] },
+          { "shelfNumber": 6, "antennaNo": [ 23, 24 ] },
+        ],
+      },
+      {
+        "fixtureNumber": 4,
+        "wallNumber": 1,
+        "readerId": "a4:e8:a3:91:7f:01",
+        "storageBoxAntennaNo": [ 5, 6, 9, 13 ],
+        "shelfConfig": [
+          { "shelfNumber": 1, "antennaNo": [ 4 ] },
+          { "shelfNumber": 2, "antennaNo": [ 3 ] },
+          { "shelfNumber": 3, "antennaNo": [ 1, 2 ] },
+          { "shelfNumber": 4, "antennaNo": [ 10, 12 ] },
+          { "shelfNumber": 5, "antennaNo": [ 7, 14 ] },
+          { "shelfNumber": 6, "antennaNo": [ 8 ] },
+        ],
+      },
+      {
+        "fixtureNumber": 5,
+        "readerId": "a4:e8:a3:91:7f:03",
+        "storageBoxAntennaNo": [ 2, 5, 6, 7, 3 ],
+        "shelfConfig": [
+          { "shelfNumber": 1, "antennaNo": [ 10 ] },
+          { "shelfNumber": 2, "antennaNo": [ 11 ] },
+          { "shelfNumber": 3, "antennaNo": [ 9, 16 ] },
+          { "shelfNumber": 4, "antennaNo": [ 20, 21 ] },
+          { "shelfNumber": 5, "antennaNo": [ 18, 19 ] },
+          { "shelfNumber": 6, "antennaNo": [ 25, 30 ] },
+        ],
+      },
+      {
+        "fixtureNumber": 6,
+        "readerId": "a4:e8:a3:91:7f:03",
+        "storageBoxAntennaNo": [ 26, 27, 28, 29, 31 ],
+        "shelfConfig": [
+          { "shelfNumber": 1, "antennaNo": [ 24 ] },
+          { "shelfNumber": 2, "antennaNo": [ 17 ] },
+          { "shelfNumber": 3, "antennaNo": [ 22, 23 ] },
+          { "shelfNumber": 4, "antennaNo": [ 12, 13 ] },
+          { "shelfNumber": 5, "antennaNo": [ 14, 15 ] },
+          { "shelfNumber": 6, "antennaNo": [ 1, 4 ] },
+        ],
+      },
+      {
+        "fixtureNumber": 1,
+        "readerId": "a4:e8:a3:91:7f:00",
+        "storageBoxAntennaNo": [ 18, 19, 20, 21, 22 ],
+        "shelfConfig": [
+          { "shelfNumber": 1, "antennaNo": [ 28 ] },
+          { "shelfNumber": 2, "antennaNo": [ 25 ] },
+          { "shelfNumber": 3, "antennaNo": [ 30, 31 ] },
+          { "shelfNumber": 4, "antennaNo": [ 29, 32 ] },
+          { "shelfNumber": 5, "antennaNo": [ 26, 27 ] },
+          { "shelfNumber": 6, "antennaNo": [ 16, 17 ] },
+        ],
+      },
+      {
+        "fixtureNumber": 2,
+        "wallNumber": 1,
+        "readerId": "a4:e8:a3:91:7f:00",
+        "storageBoxAntennaNo": [ 7, 8, 9, 10, 11 ],
+        "shelfConfig": [
+          { "shelfNumber": 1, "antennaNo": [ 3 ] },
+          { "shelfNumber": 2, "antennaNo": [ 6 ] },
+          { "shelfNumber": 3, "antennaNo": [ 4, 5 ] },
+          { "shelfNumber": 4, "antennaNo": [ 1, 2 ] },
+          { "shelfNumber": 5, "antennaNo": [ 14, 15 ] },
+          { "shelfNumber": 6, "antennaNo": [ 12, 13 ] },
+        ],
+      },
+      {
+        "fixtureNumber": 11,
+        "wallNumber": 3,
+        "readerId": "a4:e8:a3:91:7f:02",
+        "storageBoxAntennaNo": [ 8, 9, 12, 13, 14 ],
+        "shelfConfig": [
+          { "shelfNumber": 1, "antennaNo": [ 15 ] },
+          { "shelfNumber": 2, "antennaNo": [ 7 ] },
+          { "shelfNumber": 3, "antennaNo": [ 3 ] },
+          { "shelfNumber": 4, "antennaNo": [ 2 ] },
+          { "shelfNumber": 5, "antennaNo": [ 1 ] },
+          { "shelfNumber": 6, "antennaNo": [ 6, 7 ] },
+          { "shelfNumber": 7, "antennaNo": [ 5, 4 ] },
+          { "shelfNumber": 8, "antennaNo": [ 10, 11 ] },
+        ],
+      },
+      {
+        "fixtureNumber": 9,
+        "wallNumber": 3,
+        "readerId": "a4:e8:a3:91:7f:04",
+        "storageBoxAntennaNo": [ 17, 18, 19, 20, 21 ],
+        "shelfConfig": [
+          { "shelfNumber": 1, "antennaNo": [ 26 ] },
+          { "shelfNumber": 2, "antennaNo": [ 24 ] },
+          { "shelfNumber": 3, "antennaNo": [ 25 ] },
+          { "shelfNumber": 4, "antennaNo": [ 23 ] },
+          { "shelfNumber": 5, "antennaNo": [ 30 ] },
+          { "shelfNumber": 6, "antennaNo": [ 29 ] },
+          { "shelfNumber": 7, "antennaNo": [ 27, 28 ] },
+          { "shelfNumber": 8, "antennaNo": [ 22, 8 ] },
+        ],
+      },
+      {
+        "fixtureNumber": 10,
+        "readerId": "a4:e8:a3:91:7f:04",
+        "storageBoxAntennaNo": [ 1, 2, 3, 4, 5 ],
+        "shelfConfig": [
+          { "shelfNumber": 1, "antennaNo": [ 13 ] },
+          { "shelfNumber": 2, "antennaNo": [ 14 ] },
+          { "shelfNumber": 3, "antennaNo": [ 15 ] },
+          { "shelfNumber": 4, "antennaNo": [ 16 ] },
+          { "shelfNumber": 5, "antennaNo": [ 12 ] },
+          { "shelfNumber": 6, "antennaNo": [ 9 ] },
+          { "shelfNumber": 7, "antennaNo": [ 10, 11 ] },
+          { "shelfNumber": 8, "antennaNo": [ 6, 7 ] },
+        ],
+      },
+      {
+        "fixtureNumber": 12,
+        "wallNumber": 3,
+        "readerId": "a4:e8:a3:91:7f:04",
+        "storageBoxAntennaNo": [ 14, 15, 16, 17, 18 ],
+        "shelfConfig": [
+          { "shelfNumber": 1, "antennaNo": [ 25 ] },
+          { "shelfNumber": 2, "antennaNo": [ 26 ] },
+          { "shelfNumber": 3, "antennaNo": [ 27 ] },
+          { "shelfNumber": 4, "antennaNo": [ 21 ] },
+          { "shelfNumber": 5, "antennaNo": [ 24 ] },
+          { "shelfNumber": 6, "antennaNo": [ 22 ] },
+          { "shelfNumber": 7, "antennaNo": [ 20 ] },
+          { "shelfNumber": 8, "antennaNo": [ 19 ] },
+        ],
+      },
+      {
+        "fixtureNumber": 13,
+        "wallNumber": 3,
+        "readerId": "a4:e8:a3:91:7f:04",
+        "storageBoxAntennaNo": [ 1, 2, 5, 6, 7 ],
+        "shelfConfig": [
+          { "shelfNumber": 1, "antennaNo": [ 13 ] },
+          { "shelfNumber": 2, "antennaNo": [ 11 ] },
+          { "shelfNumber": 3, "antennaNo": [ 10 ] },
+          { "shelfNumber": 4, "antennaNo": [ 8 ] },
+          { "shelfNumber": 5, "antennaNo": [ 12 ] },
+          { "shelfNumber": 6, "antennaNo": [ 9 ] },
+          { "shelfNumber": 7, "antennaNo": [ 4 ] },
+          { "shelfNumber": 8, "antennaNo": [ 3 ] },
+        ],
+      },
+      {
+        "fixtureNumber": 7,
+        "wallNumber": 2,
+        "readerId": "a4:e8:a3:8e:85:43",
+        "storageBoxAntennaNo": [ 7 ],
+        "shelfConfig": [
+          { "shelfNumber": 1, "antennaNo": [ 6 ] },
+          { "shelfNumber": 2, "antennaNo": [ 8 ] },
+          { "shelfNumber": 3, "antennaNo": [ 5 ] },
+          { "shelfNumber": 4, "antennaNo": [ 4 ] },
+          { "shelfNumber": 5, "antennaNo": [ 3 ] },
+          { "shelfNumber": 6, "antennaNo": [ 2 ] },
+          { "shelfNumber": 7, "antennaNo": [ 1 ] },
+        ],
+      },
+      {
+        "fixtureNumber": 8,
+        "wallNumber": 2,
+        "readerId": "a4:e8:a3:8e:85:43",
+        "storageBoxAntennaNo": [ 9, 10, 11, 12, 13 ],
+        "shelfConfig": [
+          { "shelfNumber": 1, "antennaNo": [ 21 ] },
+          { "shelfNumber": 2, "antennaNo": [ 22 ] },
+          { "shelfNumber": 3, "antennaNo": [ 18, 24 ] },
+          { "shelfNumber": 4, "antennaNo": [ 19, 20 ] },
+          { "shelfNumber": 5, "antennaNo": [ 14, 15 ] },
+          { "shelfNumber": 6, "antennaNo": [ 16, 17 ] },
+          { "shelfNumber": 7, "antennaNo": [] },
+        ],
+      },
+      {
+        "fixtureNumber": 16,
+        "readerId": "A4-E8-A3-91-7E-FC",
+        "storageBoxAntennaNo": [ 11, 14, 8 ],
+        "shelfConfig": [
+          { "shelfNumber": 1, "antennaNo": [ 15 ] },
+          { "shelfNumber": 2, "antennaNo": [ 12, 18 ] },
+          { "shelfNumber": 3, "antennaNo": [ 9, 10 ] },
+        ],
+      },
+      {
+        "fixtureNumber": 17,
+        "readerId": "A4-E8-A3-91-7E-FC",
+        "storageBoxAntennaNo": [ 2, 3, 1 ],
+        "shelfConfig": [
+          { "shelfNumber": 1, "antennaNo": [ 5, 16 ] },
+          { "shelfNumber": 2, "antennaNo": [ 4, 13 ] },
+          { "shelfNumber": 3, "antennaNo": [ 17, 7 ] },
+        ],
+      },
+      {
+        "fixtureNumber": 19,
+        "readerId": "A4-E8-A3-91-7E-FC",
+        "storageBoxAntennaNo": [],
+        "shelfConfig": [
+          { "shelfNumber": 1, "antennaNo": [ 19, 25 ] },
+          { "shelfNumber": 2, "antennaNo": [ 26 ] },
+        ],
+      },
+      {
+        "fixtureNumber": 18,
+        "wallNumber": null,
+        "readerId": "A4-E8-A3-91-7F-05",
+        "storageBoxAntennaNo": [ 17, 18 ],
+        "shelfConfig": [
+          { "shelfNumber": 1, "antennaNo": [ 21, 22 ] },
+          { "shelfNumber": 2, "antennaNo": [ 26 ] },
+          { "shelfNumber": 3, "antennaNo": [ 19, 20 ] },
+        ],
+      },
+      {
+        "fixtureNumber": 20,
+        "wallNumber": null,
+        "readerId": "A4-E8-A3-91-7F-05",
+        "storageBoxAntennaNo": [ 8, 2, 3 ],
+        "shelfConfig": [
+          { "shelfNumber": 1, "antennaNo": [ 10, 11 ] },
+          { "shelfNumber": 2, "antennaNo": [ 7, 15 ] },
+          { "shelfNumber": 3, "antennaNo": [ 5, 16 ] },
+        ],
+      },
+      {
+        "fixtureNumber": 21,
+        "wallNumber": null,
+        "readerId": "A4-E8-A3-91-7F-05",
+        "storageBoxAntennaNo": [],
+        "shelfConfig": [
+          { "shelfNumber": 1, "antennaNo": [ 12 ] },
+          { "shelfNumber": 2, "antennaNo": [ 9, 14 ] },
+          { "shelfNumber": 3, "antennaNo": [ 1, 13 ] },
+        ],
+      },
+
+    ];
+    for ( const mappingData of antennaMapingData ) {
+      try {
+        const { fixtureNumber, readerId, storageBoxAntennaNo, shelfConfig } = mappingData;
+
+        const query = {
+          storeName: storeName,
+          fixtureNumber: fixtureNumber,
+        };
+
+        const fixture = await storeFixtureService.findOne( query );
+
+        if ( !fixture ) {
+          const errorMsg = `Fixture not found for storeName: ${storeName}, fixtureNumber: ${fixtureNumber}`;
+          console.warn( errorMsg );
+          errors.push( errorMsg );
+          errorCount++;
+          continue;
+        }
+
+        const fixtureId = fixture._id;
+
+        if ( readerId ) {
+          await storeFixtureService.updateOne(
+              { _id: fixtureId },
+              { $set: { readerId: readerId } },
+          );
+          console.log( `Updated fixture ${fixtureNumber} readerId:`, readerId );
+        }
+
+        if ( storageBoxAntennaNo && Array.isArray( storageBoxAntennaNo ) && storageBoxAntennaNo.length > 0 ) {
+          await storeFixtureService.updateOne(
+              { _id: fixtureId },
+              { 'footer.antennaNo': storageBoxAntennaNo },
+          );
+          console.log( `Updated fixture ${fixtureNumber} footer.antennaNo:`, storageBoxAntennaNo );
+        }
+
+        if ( shelfConfig && Array.isArray( shelfConfig ) && shelfConfig.length > 0 ) {
+          for ( const shelfMapping of shelfConfig ) {
+            const { shelfNumber, antennaNo } = shelfMapping;
+
+            if ( !shelfNumber || !antennaNo || !Array.isArray( antennaNo ) ) {
+              console.warn( `Invalid shelf config for fixture ${fixtureNumber}, shelf ${shelfNumber}` );
+              continue;
+            }
+
+            const shelf = await fixtureShelfService.findOne( {
+              fixtureId: fixtureId,
+              shelfNumber: shelfNumber,
+            } );
+
+            if ( shelf ) {
+              await fixtureShelfService.updateOne(
+                  { _id: shelf._id },
+                  { antennaNo: antennaNo },
+              );
+              console.log( `Updated fixture ${fixtureNumber}, shelf ${shelfNumber} with antennaNo:`, antennaNo );
+            } else {
+              const errorMsg = `Shelf not found for fixture ${fixtureNumber}, shelfNumber: ${shelfNumber}`;
+              console.warn( errorMsg );
+              errors.push( errorMsg );
+            }
+          }
+        }
+
+        successCount++;
+      } catch ( error ) {
+        const errorMsg = `Error processing fixture ${mappingData.fixtureNumber}: ${error.message}`;
+        console.error( errorMsg, error );
+        errors.push( errorMsg );
+        errorCount++;
+      }
+    }
+  } catch ( e ) {
+    logger.error( { functionName: 'insertAntennaMappingData', error: e } );
+    return res.sendError( e.message || 'Internal Server Error', 500 );
+  }
+}
+
+// insertAntennaMappingData();

package/src/controllers/storeBuilder.controller.js

@@ -27,6 +27,8 @@ import * as fixtureConfigDuplicateService from '../service/fixtureConfigDuplicat
 import * as planoVmDuplicateService from '../service/planoVmDuplicate.service.js';
 import advancedFormat from 'dayjs/plugin/advancedFormat.js';
 import * as planoRevisionService from '../service/planoRevision.service.js';
+// import xlsx from 'xlsx';
+// import fs from 'fs';
 
 dayjs.extend( advancedFormat );
 dayjs.extend( utc );
@@ -8011,69 +8013,87 @@ export async function updateProductMapping( req, res ) {
     await Promise.all( storeDetails.map( async ( store ) => {
       // let number = Number( store.storeName.replace( /\D/g, '' ) );
       let getLatestData = await fetch( `${JSON.parse( process.env.LAMBDAURL )?.getRFIDDetails}/${store.storeName}`, { method: 'GET' } );
-
       if ( getLatestData.status == 200 ) {
         let response = await getLatestData.json();
-        let data = response.mac_details.flatMap( ( ele ) => ele.body );
+        logger.error( { data: response } );
+        // let data = response.mac_details.flatMap( ( ele ) => ele.body );
         let mappingData = [];
         let complianceData = [];
-        await Promise.all( data.map( async ( ele ) => {
-          if ( ele?.data ) {
-            let fixtureDetails = await storeFixtureService.find( { readerId: ele?.data?.MAC } );
-            if ( fixtureDetails.length ) {
-              let getShelfDetails = await fixtureShelfService.findOne( { fixtureId: { $in: fixtureDetails?.map( ( fixt ) => fixt._id ) }, antennaNo: { $in: [ ele?.data?.antenna ] } } );
-              if ( !getShelfDetails ) {
-                fixtureDetails = fixtureDetails.find( ( fixt ) => fixt?.footer?.antennaNo?.includes( ele.data.antenna ) );
-                if ( fixtureDetails ) {
-                  getShelfDetails = { shelfType: 'storage' };
+        let excelData = [];
+        for ( let macDetails of response?.mac_details ) {
+          let fixtureDetails = await storeFixtureService.find( { readerId: macDetails?.MAC } );
+          if ( fixtureDetails.length ) {
+            let data = macDetails?.body ?? [];
+            await Promise.all( data.map( async ( ele ) => {
+              if ( ele?.data ) {
+                let getShelfDetails = await fixtureShelfService.findOne( { fixtureId: { $in: fixtureDetails?.map( ( fixt ) => fixt._id ) }, antennaNo: { $in: [ ele?.data?.antenna ] } } );
+                let fixtureShelfDetails;
+                if ( !getShelfDetails ) {
+                  logger.error( { data: macDetails?.MAC } );
+                  fixtureShelfDetails = fixtureDetails.find( ( fixt ) => fixt?.footer?.antennaNo?.includes( ele.data.antenna ) );
+                  if ( fixtureDetails ) {
+                    getShelfDetails = { shelfType: 'storage' };
+                  }
+                } else {
+                  fixtureShelfDetails = fixtureDetails.find( ( fixt ) => fixt._id.toString() == getShelfDetails.fixtureId.toString() );
                 }
-              } else {
-                fixtureDetails = fixtureDetails.find( ( fixt ) => fixt._id.toString() == getShelfDetails.fixtureId.toString() );
-              }
-              if ( getShelfDetails ) {
-                let productDetails = await planoProductService.findOne( { productId: ele.data.idText } );
-                if ( productDetails ) {
-                  let data = {
-                    clientId: req.body.clientId,
-                    storeName: fixtureDetails.storeName,
-                    storeId: fixtureDetails.storeId,
-                    type: getShelfDetails?.shelfType != 'storage' ? 'product' : 'storageBox',
-                    productId: productDetails._id,
-                    pid: productDetails.productId,
-                    planoId: fixtureDetails.planoId,
-                    floorId: fixtureDetails.floorId,
-                    fixtureId: fixtureDetails._id,
-                    ...( getShelfDetails?.shelfType != 'storage' && { shelfId: getShelfDetails._id } ),
-                  };
-                  mappingData.push( data );
-
-                  // let mappingDetails = await planoMappingService.create( data );
-
-                  let productData = {
-                    'planoMappingId': '',
-                    'date': dayjs().format( 'YYYY-MM-DD' ),
-                    'clientId': req.body.clientId,
-                    'compliance': getShelfDetails?.shelfType != 'storage' ? getShelfDetails.productBrandName.includes( productDetails.brandName ) ? 'proper' : 'misplaced' : '',
-                    'fixtureId': fixtureDetails._id,
-                    'floorId': fixtureDetails.floorId,
-                    'planoId': fixtureDetails.planoId,
-                    'productId': productDetails._id,
-                    'rfId': ele.data.idHex,
-                    'shelfId': getShelfDetails._id,
-                    'storeId': fixtureDetails.storeId,
-                    'storeName': fixtureDetails.storeName,
-                    'type': getShelfDetails?.shelfType != 'storage' ? 'product' : 'storageBox',
-                  };
-                  complianceData.push( productData );
-
-                  // await planoComplianceService.create( productData );
+                logger.error( { data: fixtureShelfDetails, antennaNo: ele.data.antenna, macId: ele?.data?.MAC } );
+                if ( getShelfDetails && fixtureShelfDetails ) {
+                  let productDetails = await planoProductService.findOne( { productId: ele.data.idText } );
+                  if ( productDetails ) {
+                    let data = {
+                      clientId: req.body.clientId,
+                      storeName: fixtureShelfDetails.storeName,
+                      storeId: fixtureShelfDetails.storeId,
+                      type: getShelfDetails?.shelfType != 'storage' ? 'product' : 'storageBox',
+                      productId: productDetails._id,
+                      pid: productDetails.productId,
+                      planoId: fixtureShelfDetails.planoId,
+                      floorId: fixtureShelfDetails.floorId,
+                      fixtureId: fixtureShelfDetails._id,
+                      ...( getShelfDetails?.shelfType != 'storage' && { shelfId: getShelfDetails._id } ),
+                    };
+                    mappingData.push( data );
+
+                    // let mappingDetails = await planoMappingService.create( data );
+
+                    let productData = {
+                      'planoMappingId': '',
+                      'date': dayjs().format( 'YYYY-MM-DD' ),
+                      'clientId': req.body.clientId,
+                      'compliance': getShelfDetails?.shelfType != 'storage' ? getShelfDetails.productBrandName.includes( productDetails.brandName ) ? 'proper' : 'misplaced' : '',
+                      'fixtureId': fixtureShelfDetails._id,
+                      'floorId': fixtureShelfDetails.floorId,
+                      'planoId': fixtureShelfDetails.planoId,
+                      'productId': productDetails._id,
+                      'rfId': ele.data.idHex,
+                      'shelfId': getShelfDetails._id,
+                      'storeId': fixtureShelfDetails.storeId,
+                      'storeName': fixtureShelfDetails.storeName,
+                      'type': getShelfDetails?.shelfType != 'storage' ? 'product' : 'storageBox',
+                    };
+                    complianceData.push( productData );
+
+
+                    excelData.push( {
+                      fixtureId: fixtureShelfDetails._id.toString(),
+                      readerId: ele?.data?.MAC,
+                      antennaNo: ele.data.antenna,
+                      pid: ele.data.idText,
+                      productName: productDetails?.brandName,
+                    } );
+
+                    // await planoComplianceService.create( productData );
+                  }
                 }
               }
-            }
+            } ) );
           }
-        } ) );
+        }
+
+        // await Promise.all( response?.mac_details?.map( async ( macDetails ) => {
+        // } ) );
         await planoMappingService.deleteMany( { storeId: store.storeId } );
-        console.log( mappingData, '@@mappingData' );
         let mappingInsertData = await planoMappingService.insertMany( mappingData );
         mappingInsertData = new Map( mappingInsertData.map( ( ele, index ) => [ index, ele ] ) );
         let date = dayjs().format();
@@ -8081,8 +8101,12 @@ export async function updateProductMapping( req, res ) {
           compliance.planoMappingId = mappingInsertData.get( index );
           compliance.createdAt = date;
         } );
-
         await planoComplianceService.insertMany( complianceData );
+        // const ws = xlsx.utils.json_to_sheet( excelData );
+        // const wb = xlsx.utils.book_new();
+        // xlsx.utils.book_append_sheet( wb, ws, 'data' );
+        // const buffer = xlsx.write( wb, { type: 'buffer', bookType: 'xlsx' } );
+        // fs.writeFileSync( './items.xlsx', buffer );
       }
     } ) );
     return res.sendSuccess( 'Updated successfully' );