tango-app-api-store-builder 1.0.0-beta-71 → 1.0.0-beta-73

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "tango-app-api-store-builder",
-    "version": "1.0.0-beta-71",
+    "version": "1.0.0-beta-73",
     "description": "storeBuilder",
     "main": "index.js",
     "type": "module",
@@ -24,7 +24,7 @@
         "jszip": "^3.10.1",
         "mongodb": "^6.12.0",
         "nodemon": "^3.1.9",
-        "tango-api-schema": "^2.2.77",
+        "tango-api-schema": "^2.2.94",
         "tango-app-api-middleware": "^3.1.48",
         "winston": "^3.17.0",
         "winston-daily-rotate-file": "^5.0.0",

package/src/controllers/script.controller.js

@@ -1928,6 +1928,8 @@ export async function updatelayoutFeedback( req, res ) {
           },
         ];
 
+        await storeBuilderService.updateOne( { _id: floorDoc._id }, { layoutPolygon: layoutPolygon } );
+
         console.log( layoutPolygon, floorDoc._id );
       }
     }
@@ -1958,3 +1960,131 @@ export async function extractZipFileNames( req, res ) {
     return res.sendError( e.message || 'Internal Server Error', 500 );
   }
 }
+
+export async function updateFixtureFeedback( req, res ) {
+  try {
+    if ( req?.headers?.authorization?.split( ' ' )[1] !== 'hwjXfCD6TgMvc82cuSGZ9bNv9MuXsaiQ6uvx' ) {
+      return res.sendError( 'Unauthorized', 401 );
+    }
+
+    if ( !req.body.length ) {
+      return res.sendError( 'Store List is required', 400 );
+    }
+
+    const storeList = req.body;
+
+    for ( let i = 0; i < storeList.length; i++ ) {
+      const store = storeList[i];
+
+      // const issueTypes = [
+      //   'Fixture size is wrong',
+      //   'Fixture type is wrong',
+      //   'Fixture brand is wrong',
+      //   'Fixture not in the store',
+      //   'Shelves count/Product Category/Capacity is wrong',
+      //   'Others',
+      // ];
+
+      const planogram = await planoService.findOne( { storeName: store.storeName } );
+
+      const fixtureTaskList = await planoTaskService.find( { planoId: planogram.toObject()._id, type: 'fixture' } );
+
+      for ( let j = 0; j < fixtureTaskList.length; j++ ) {
+        const fixtureTask = fixtureTaskList[j].toObject();
+
+        const [ q1 ] = fixtureTask.answers;
+
+        if ( q1.value === true ) {
+          continue;
+        }
+
+        const fixture = await storeFixtureService.findOne( { _id: fixtureTask.fixtureId } );
+
+        const fixtureDoc = fixture?.toObject();
+
+
+        if ( q1.issues.includes( 'Shelves count/Product Category/Capacity is wrong' ) ) {
+          const taskShelves = q1.data.shelves;
+
+          const fixtureShelves = await fixtureShelfService.findAndSort( { fixtureId: fixtureTask.fixtureId }, {}, { shelfNumber: 1 } );
+
+          const shelfCount = q1.data.shelves.length;
+
+          const fixtureCapacity = q1.data.shelves.reduce( ( sum, item ) => sum + ( item.productCapacity ? item.productCapacity : 0 ), 0 );
+
+          const updateFixture = await storeFixtureService.updateOne( { _id: fixtureDoc._id }, { shelfcount: shelfCount, fixtureCapacity: fixtureCapacity } );
+
+          console.log( updateFixture );
+
+          for ( let k = 0; k < taskShelves.length; k++ ) {
+            const taskShelf = taskShelves[k];
+            const productCapacity = taskShelf.productCapacity;
+            const section = taskShelf.section;
+            const subBrand = taskShelf.subBrand;
+            const formattedsubBrand = subBrand.length ? ( subBrand.length > 1 ? subBrand.join( ' + ' ) : subBrand[0] ) : undefined;
+            if ( taskShelves.length === fixtureShelves.length ) {
+              const fixtureShelf = fixtureShelves.filter( ( shelf ) => {
+                return shelf.toObject().shelfNumber === k+1;
+              } );
+
+              const updateShelf = await fixtureShelfService.updateOne( { _id: fixtureShelf?.[0].toObject()._id }, { shelfCapacity: productCapacity, sectionName: formattedsubBrand, sectionZone: section } );
+
+              console.log( updateShelf );
+            } else if ( taskShelves.length < fixtureShelves.length ) {
+              const fixtureShelf = fixtureShelves.filter( ( shelf ) => {
+                return shelf.toObject().shelfNumber === k+1;
+              } );
+
+
+              const updateShelf = await fixtureShelfService.updateOne( { _id: fixtureShelf?.[0].toObject()._id }, { shelfCapacity: productCapacity, sectionName: formattedsubBrand, sectionZone: section } );
+
+              console.log( updateShelf );
+
+
+              const shelfDifference = fixtureShelves.length - taskShelves.length;
+
+              const shelvesToDelete = fixtureShelves.slice( -shelfDifference );
+
+              shelvesToDelete.map( async ( shelf ) => {
+                await fixtureShelfService.deleteOne( { _id: shelf.toObject()._id } );
+              } );
+            } else if ( taskShelves.length > fixtureShelves.length ) {
+              if ( k + 1 <= fixtureShelves.length ) {
+                const fixtureShelf = fixtureShelves.filter( ( shelf ) => {
+                  return shelf.toObject().shelfNumber === k+1;
+                } );
+
+
+                const updateShelf = await fixtureShelfService.updateOne( { _id: fixtureShelf?.[0].toObject()._id }, { shelfCapacity: productCapacity, sectionName: formattedsubBrand, sectionZone: section } );
+
+                console.log( updateShelf );
+              } else if ( k + 1 > fixtureShelves.length ) {
+                const insertData = {
+                  'clientId': planogram.toObject().clientId,
+                  'storeName': planogram.toObject().storeName,
+                  'storeId': planogram.toObject().storeId,
+                  'planoId': planogram.toObject()._id,
+                  'floorId': fixtureDoc.floorId,
+                  'fixtureId': fixtureDoc._id,
+                  'shelfNumber': k+1,
+                  'shelfOrder': 'LTR',
+                  'shelfCapacity': productCapacity,
+                  'sectionName': formattedsubBrand,
+                  'sectionZone': section,
+                };
+
+
+                await fixtureShelfService.create( insertData );
+              }
+            }
+          }
+        }
+      }
+    }
+
+    res.sendSuccess( 'Updated successfully' );
+  } catch ( e ) {
+    logger.error( { functionName: 'updatelayoutFeedback', error: e } );
+    return res.sendError( e.message || 'Internal Server Error', 500 );
+  }
+}

package/src/controllers/storeBuilder.controller.js

@@ -14,7 +14,7 @@ import * as planoComplianceService from '../service/planoCompliance.service.js';
 import * as planoTaskComplianceService from '../service/planoTask.service.js';
 import * as planoQrConversionRequestService from '../service/planoQrConversionRequest.service.js';
 import * as fixtureConfigService from '../service/fixtureConfig.service.js';
-import * as planoStaticBrandCategoriesService from '../service/planoStaticBrandCategories.service.js';
+import * as planoStaticData from '../service/planoStaticData.service.js';
 
 
 import path from 'path';
@@ -607,7 +607,7 @@ export async function storeFixturesv1( req, res ) {
                               date: currentDate,
                             } );
 
-                            const shelves = await fixtureShelfService.find( { fixtureId: fixture._id }, { shelfNumber: 1, sectionName: 1, sectionZone: 1, shelfCapacity: 1 } );
+                            const shelves = await fixtureShelfService.findAndSort( { fixtureId: fixture._id }, { shelfNumber: 1, sectionName: 1, sectionZone: 1, shelfCapacity: 1 }, { shelfNumber: 1 } );
 
                             const shelfDetails = await Promise.all(
                                 shelves.map( async ( shelf ) => {
@@ -702,7 +702,7 @@ export async function storeFixturesv1( req, res ) {
                         date: currentDate,
                       } );
 
-                      const shelves = await fixtureShelfService.find( { fixtureId: fixture._id }, { shelfNumber: 1, sectionName: 1, sectionZone: 1, shelfCapacity: 1 } );
+                      const shelves = await fixtureShelfService.findAndSort( { fixtureId: fixture._id }, { shelfNumber: 1, sectionName: 1, sectionZone: 1, shelfCapacity: 1 }, { shelfNumber: 1 } );
 
                       const shelfDetails = await Promise.all(
                           shelves.map( async ( shelf ) => {
@@ -1081,7 +1081,7 @@ export async function fixtureShelfProductv1( req, res ) {
     }
 
     if ( [ 'L2', 'L4' ].includes( fixture.toObject().productResolutionLevel ) ) {
-      const fixtureShelves = await fixtureShelfService.find( { fixtureId: new mongoose.Types.ObjectId( fixtureId ) } );
+      const fixtureShelves = await fixtureShelfService.findAndSort( { fixtureId: new mongoose.Types.ObjectId( fixtureId ) }, {}, { shelfNumber: 1 } );
       // if ( !fixtureShelves.length ) return res.sendError( 'No shelves found for the fixture', 204 );
       const productCount = await planoMappingService.count( { fixtureId: new mongoose.Types.ObjectId( fixtureId ), type: 'product' } );
       const shelfProducts = await Promise.all(
@@ -1095,7 +1095,7 @@ export async function fixtureShelfProductv1( req, res ) {
     }
 
     if ( fixture.toObject().productResolutionLevel === 'L3' ) {
-      const fixtureShelves = await fixtureShelfService.find( { fixtureId: new mongoose.Types.ObjectId( fixtureId ) } );
+      const fixtureShelves = await fixtureShelfService.findAndSort( { fixtureId: new mongoose.Types.ObjectId( fixtureId ) }, {}, { shelfNumber: 1 } );
       // if ( !fixtureShelves.length ) return res.sendError( 'No shelves found for the fixture', 204 );
       const productCount = await planoMappingService.count( { fixtureId: new mongoose.Types.ObjectId( fixtureId ), type: 'product' } );
       const groupedShelves = fixtureShelves.reduce( async ( accPromise, shelf ) => {
@@ -2048,7 +2048,7 @@ export async function storeFixturesTask( req, res ) {
                               date_string: req.body?.date,
                             }, { status: 1 } );
 
-                            const shelves = await fixtureShelfService.find( { fixtureId: fixture._id }, { shelfNumber: 1, sectionName: 1, sectionZone: 1, shelfCapacity: 1 } );
+                            const shelves = await fixtureShelfService.findAndSort( { fixtureId: fixture._id }, { shelfNumber: 1, sectionName: 1, sectionZone: 1, shelfCapacity: 1 }, { shelfNumber: 1 } );
 
                             const shelfDetails = await Promise.all(
                                 shelves.map( async ( shelf ) => {
@@ -2128,7 +2128,7 @@ export async function storeFixturesTask( req, res ) {
                         date_string: req.body?.date,
                       }, { status: 1 } );
 
-                      const shelves = await fixtureShelfService.find( { fixtureId: fixture._id }, { shelfNumber: 1, sectionName: 1, sectionZone: 1, shelfCapacity: 1 } );
+                      const shelves = await fixtureShelfService.findAndSort( { fixtureId: fixture._id }, { shelfNumber: 1, sectionName: 1, sectionZone: 1, shelfCapacity: 1 }, { shelfNumber: 1 } );
 
                       const shelfDetails = await Promise.all(
                           shelves.map( async ( shelf ) => {
@@ -2437,6 +2437,61 @@ export const fixtureQrUpdate = async ( req, res ) => {
   }
 };
 
+export const fixtureQrUpdatev1 = async ( req, res ) => {
+  try {
+    const { fixtureId, date, productQr } = req.body;
+
+    const fixture = await storeFixtureService.findOne( { _id: new mongoose.Types.ObjectId( fixtureId ) }, { _id: 1 } );
+
+    if ( !fixture ) {
+      return res.sendError( { message: 'Invalid fixture Id' }, 400 );
+    }
+
+    const fixtureShelves = await fixtureShelfService.find( { fixtureId: new mongoose.Types.ObjectId( fixtureId ) } );
+
+    let productIndex = 0;
+
+    const complianceData = fixtureShelves.map( ( shelf ) => {
+      const shelfObj = shelf.toObject();
+      const products = shelfObj.shelfCapacity ?
+        Array.from( { length: shelfObj.shelfCapacity }, () => ( {
+          category: shelfObj.sectionName,
+          productIndex: productIndex++,
+          status: 'missing',
+        } ) ) :
+        [];
+
+      return { ...shelfObj, products };
+    } );
+
+    const productMap = new Map();
+    productQr.forEach( ( productCv, i ) => {
+      if ( productCv.parent_brand ) {
+        productMap.set( i, productCv );
+      }
+    } );
+
+    complianceData.forEach( ( shelf ) => {
+      shelf.products.forEach( ( product ) => {
+        const matchedProduct = productMap.get( product.productIndex );
+        if ( matchedProduct && product.category === matchedProduct.parent_brand ) {
+          Object.assign( product, { status: 'proper', barcode: matchedProduct.barcode } );
+        }
+      } );
+    } );
+
+    const currentDate = new Date( date );
+
+    await planoQrConversionRequestService.updateOne( { fixtureId: new mongoose.Types.ObjectId( fixtureId ), date: currentDate }, { status: 'data-received', receivedQr: productQr, processedData: complianceData } );
+
+    res.sendSuccess( complianceData );
+  } catch ( error ) {
+    logger.error( 'fixtureQrUpdate =>', error );
+    return res.sendError( { message: 'Internal Server Error' }, 500 );
+  }
+};
+
+
 export const updateDetailedDistance = async ( req, res ) => {
   try {
     const { floorId, elementNumber, elementType, detailedDistance } = req.body;
@@ -2725,7 +2780,7 @@ export const getFixtureBrands = async ( req, res ) => {
 
     // const [ data ] = sections;
 
-    const brandCategories = await planoStaticBrandCategoriesService.findOne( { } );
+    const brandCategories = await planoStaticData.findOne( { type: 'brandCategory' } );
 
     return res.sendSuccess( brandCategories.toObject().data );
   } catch ( error ) {

package/src/controllers/task.controller.js

@@ -9,6 +9,7 @@ import * as planoTaskService from '../service/planoTask.service.js';
 import * as planoService from '../service/planogram.service.js';
 import * as checklistService from '../service/checklist.service.js';
 import timeZone from 'dayjs/plugin/timezone.js';
+import * as planoProductService from '../service/planoProduct.service.js';
 dayjs.extend( timeZone );
 
 async function createUser( data ) {
@@ -110,6 +111,32 @@ export async function createTask( req, res ) {
     if ( !taskDetails.length ) {
       return res.sendError( 'No data found', 204 );
     }
+    let userEmailList = [ ...new Set( req.body.stores.map( ( ele ) => ele.email ) ) ];
+    for ( let mail of userEmailList ) {
+      let query = [
+        {
+          $addFields: {
+            emailLower: { $toLower: '$email' },
+          },
+        },
+        {
+          $match: {
+            clientId: req.body.clientId,
+            emailLower: mail.toLowerCase(),
+          },
+        },
+      ];
+      userDetails = await userService.aggregate( query );
+      if ( !userDetails.length ) {
+        let userData = {
+          clientId: req.body.clientId,
+          mobileNumber: '',
+          email: mail,
+          userName: mail.split( '@' )[0],
+        };
+        await createUser( userData );
+      }
+    }
     let endDate = dayjs().add( req.body.days, 'day' ).format( 'YYYY-MM-DD' );
     await Promise.all( taskDetails.map( async ( task ) => {
       let data = {
@@ -183,22 +210,22 @@ export async function createTask( req, res ) {
             {
               $match: {
                 clientId: req.body.clientId,
-                email: getUserEmail.email,
+                email: getUserEmail.email.toLowerCase(),
               },
             },
           ];
           userDetails = await userService.aggregate( query );
-          if ( !userDetails.length ) {
-            let userData = {
-              clientId: req.body.clientId,
-              mobileNumber: '',
-              email: getUserEmail.email,
-              userName: getUserEmail.email.split( '@' )[0],
-            };
-            userDetails = await createUser( userData );
-          } else {
-            userDetails = userDetails[0];
-          }
+          // if ( !userDetails.length ) {
+          //   let userData = {
+          //     clientId: req.body.clientId,
+          //     mobileNumber: '',
+          //     email: getUserEmail.email,
+          //     userName: getUserEmail.email.split( '@' )[0],
+          //   };
+          //   userDetails = await createUser( userData );
+          // } else {
+          userDetails = userDetails[0];
+          // }
         }
         let taskData = { ...data };
         taskData.store_id = store.storeId;
@@ -564,3 +591,18 @@ export async function getFixtureDetails( req, res ) {
     return res.sendError( e, 500 );
   }
 }
+
+export async function getVmDetails( req, res ) {
+  try {
+    let getVms = await planoProductService.find( { type: 'vm' }, { productName: 1 } );
+    if ( !getVms.length ) {
+      return res.sendError( 'No data found', 204 );
+    }
+    getVms = [ ...new Set( getVms.map( ( ele ) => ele.productName ) ) ];
+    getVms.push( 'other' );
+    return res.sendSuccess( getVms );
+  } catch ( e ) {
+    logger.error( { functionName: 'getVmDetails', error: e } );
+    return res.sendError( e, 500 );
+  }
+}

package/src/routes/script.routes.js

@@ -18,4 +18,5 @@ scriptRouter
     .post( '/updateRfidProduct2', scriptController.updateRfidProduct2 )
     .post( '/getProdTaskData', scriptController.getProdTaskData )
     .post( '/updateLayoutFeedback', scriptController.updatelayoutFeedback )
+    .post( '/updateFixtureFeedback', scriptController.updateFixtureFeedback )
     .post( '/getFileNames', scriptController.extractZipFileNames );

package/src/routes/storeBuilder.routes.js

@@ -23,22 +23,23 @@ storeBuilderRouter
     // .post( '/FixtureShelfDetails', storeBuilderController.fixtureShelfProduct )
     // .post( '/scan', storeBuilderController.scan )
     .post( '/storeLayout', isAllowedSessionHandler, validate( validateDtos.storeList ), storeBuilderController.storeLayout )
-    .post( '/storeFixtures', isAllowedSessionHandler, validate( validateDtos.storeList ), storeBuilderController.storeFixturesv1 )
-    .post( '/FixtureShelfDetails', isAllowedSessionHandler, validate( validateDtos.fixtureShelfProduct ), storeBuilderController.fixtureShelfProductv1 )
+    .post( '/storeFixtures', validate( validateDtos.storeList ), storeBuilderController.storeFixturesv1 )
+    .post( '/FixtureShelfDetails', validate( validateDtos.fixtureShelfProduct ), storeBuilderController.fixtureShelfProductv1 )
     .post( '/scan', isAllowedSessionHandler, storeBuilderController.scanv1 )
     .post( '/updateMissing', isAllowedSessionHandler, storeBuilderController.updateMissing )
     .post( '/bulkFixtureUpload', isAllowedSessionHandler, storeBuilderController.bulkFixtureUpload )
     .post( '/uploadImage', isAllowedSessionHandler, storeBuilderController.uploadImage )
-    .post( '/storeFixturesTask', isAllowedSessionHandler, storeBuilderController.storeFixturesTask )
+    .post( '/storeFixturesTask', storeBuilderController.storeFixturesTask )
     .post( '/qrFileUpload', isAllowedSessionHandler, storeBuilderController.qrFileUpload )
     .post( '/updateQrCvProcessRequest', isAllowedSessionHandler, storeBuilderController.updateQrCvProcessRequest )
     .post( '/getQrCvProcessRequest', isAllowedSessionHandler, storeBuilderController.getQrCvProcessRequest )
     .post( '/fixtureQrUpdate', isAllowedSessionHandler, storeBuilderController.fixtureQrUpdate )
+    .post( '/fixtureQrUpdatev1', isAllowedSessionHandler, storeBuilderController.fixtureQrUpdatev1 )
     .post( '/updateDeatailedDistance', isAllowedSessionHandler, storeBuilderController.updateDetailedDistance )
     .post( '/upsertFixture', isAllowedSessionHandler, storeBuilderController.upsertFixtures )
     .post( '/getshelfSections', isAllowedSessionHandler, storeBuilderController.getShelfSections )
     .post( '/getFixtureTypes', isAllowedSessionHandler, storeBuilderController.getFixtureTypes )
     .post( '/getFixtureLengths', isAllowedSessionHandler, storeBuilderController.getFixtureLengths )
-    .post( '/getFixtureBrands', isAllowedSessionHandler, storeBuilderController.getFixtureBrands )
+    .post( '/getFixtureBrands', storeBuilderController.getFixtureBrands )
     .post( '/checkPlanoExist', isAllowedSessionHandler, storeBuilderController.checkPlanoExist )
     .post( '/storeLayoutElements', isAllowedSessionHandler, storeBuilderController.storeLayoutElements );

package/src/routes/task.routes.js

@@ -11,4 +11,5 @@ storeBuilderTaskRouter
     .post( '/uploadImage', isAllowedSessionHandler, taskController.uploadImage )
     .post( '/updateStatus', isAllowedSessionHandler, taskController.updateStatus )
     .post( '/updateAnswers', isAllowedSessionHandler, taskController.updateAnswers )
-    .get( '/getFixtureDetails', isAllowedSessionHandler, taskController.getFixtureDetails );
+    .get( '/getFixtureDetails', isAllowedSessionHandler, taskController.getFixtureDetails )
+    .get( '/getVmDetails', isAllowedSessionHandler, taskController.getVmDetails );

package/src/service/fixtureShelf.service.js

@@ -4,6 +4,10 @@ export async function find( query={}, field={} ) {
   return model.fixtureShelfModel.find( query, field );
 }
 
+export async function findAndSort( query={}, field={}, sortField={} ) {
+  return model.fixtureShelfModel.find( query, field ).sort( sortField );
+}
+
 export async function findOne( query={}, field={} ) {
   return model.fixtureShelfModel.findOne( query, field );
 }
@@ -27,3 +31,7 @@ export async function create( data ) {
 export async function count( data ) {
   return model.fixtureShelfModel.countDocuments( data );
 }
+
+export async function deleteOne( query ) {
+  return model.fixtureShelfModel.deleteOne( query );
+}

package/src/service/{planoStaticBrandCategories.service.js → planoStaticData.service.js}

@@ -1,8 +1,8 @@
 import model from 'tango-api-schema';
 
 export async function find( query={}, field={} ) {
-  return model.planoStaticBrandCategories.find( query, field );
+  return model.planoStaticData.find( query, field );
 }
 export async function findOne( query={}, field={} ) {
-  return model.planoStaticBrandCategories.findOne( query, field );
+  return model.planoStaticData.findOne( query, field );
 }