tango-app-api-store-builder 1.0.0-beta-40 → 1.0.0-beta-42

package/src/controllers/storeBuilder.controller.js

@@ -552,7 +552,7 @@ export async function storeFixturesv1( req, res ) {
             { storeId: { $in: req.body.id } },
           ],
         },
-        { storeId: 1, storeName: 1, planoId: '$_id', productResolutionLevel: 1, scanType: 1 },
+        { storeId: 1, storeName: 1, planoId: '$_id', productResolutionLevel: 1, scanType: 1, clientId: 1 },
     );
 
     if ( !planograms?.length ) return res.sendError( 'No data found', 204 );
@@ -598,7 +598,7 @@ export async function storeFixturesv1( req, res ) {
                               date: currentDate,
                             } );
 
-                            const shelves = await fixtureShelfService.find( { fixtureId: fixture._id }, { shelfNumber: 1 } );
+                            const shelves = await fixtureShelfService.find( { fixtureId: fixture._id }, { shelfNumber: 1, sectionName: 1, sectionZone: 1 } );
 
                             const shelfDetails = await Promise.all(
                                 shelves.map( async ( shelf ) => {
@@ -621,9 +621,24 @@ export async function storeFixturesv1( req, res ) {
                             if ( cvProcessStatus ) {
                               fixtureStatus = 'inprogress';
                             } else {
-                              fixtureStatus = complianceCount === 0 ? '' : complianceCount === productCount ? 'complete' : 'incomplete';
+                              const missingCount = await planoComplianceService.count( {
+                                fixtureId: fixture._id,
+                                compliance: 'missing',
+                                date: currentDate,
+                              } );
+                              fixtureStatus = complianceCount === 0 && !missingCount ? '' : complianceCount === productCount ? 'complete' : 'incomplete';
                             }
 
+                            const vms = await planoMappingService.find( { fixtureId: fixture._id, type: 'vm' } );
+
+                            const vmDetails = await Promise.all( vms.map( async ( vm ) => {
+                              const vmTemplate = await planoProductService.findOne( { _id: vm.toObject().productId } );
+                              return {
+                                ...vm.toObject(),
+                                ...vmTemplate?.toObject(),
+                              };
+                            } ) );
+
                             return {
                               ...fixture.toObject(),
                               status: fixtureStatus,
@@ -631,6 +646,7 @@ export async function storeFixturesv1( req, res ) {
                               productCount: productCount,
                               vmCount: vmCount,
                               shelfDetails: shelfDetails,
+                              vms: vmDetails,
                             };
                           } ),
                       );
@@ -676,7 +692,7 @@ export async function storeFixturesv1( req, res ) {
                         date: currentDate,
                       } );
 
-                      const shelves = await fixtureShelfService.find( { fixtureId: fixture._id }, { shelfNumber: 1 } );
+                      const shelves = await fixtureShelfService.find( { fixtureId: fixture._id }, { shelfNumber: 1, sectionName: 1, sectionZone: 1 } );
 
                       const shelfDetails = await Promise.all(
                           shelves.map( async ( shelf ) => {
@@ -699,9 +715,25 @@ export async function storeFixturesv1( req, res ) {
                       if ( cvProcessStatus ) {
                         fixtureStatus = 'inprogress';
                       } else {
-                        fixtureStatus = complianceCount === 0 ? '' : complianceCount === productCount ? 'complete' : 'incomplete';
+                        const missingCount = await planoComplianceService.count( {
+                          fixtureId: fixture._id,
+                          compliance: 'missing',
+                          date: currentDate,
+                        } );
+                        fixtureStatus = complianceCount === 0 && !missingCount ? '' : complianceCount === productCount ? 'complete' : 'incomplete';
                       }
 
+                      const vms = await planoMappingService.find( { fixtureId: fixture._id, type: 'vm' } );
+
+                      const vmDetails = await Promise.all( vms.map( async ( vm ) => {
+                        const vmTemplate = await planoProductService.findOne( { _id: vm.toObject().productId } );
+
+                        return {
+                          ...vm.toObject(),
+                          ...vmTemplate?.toObject(),
+                        };
+                      } ) );
+
                       return {
                         ...fixture.toObject(),
                         status: fixtureStatus,
@@ -709,7 +741,7 @@ export async function storeFixturesv1( req, res ) {
                         productCount: productCount,
                         vmCount: vmCount,
                         shelfDetails: shelfDetails,
-
+                        vms: vmDetails,
                       };
                     } ),
                 );
@@ -2348,4 +2380,69 @@ export const fixtureQrUpdate = async ( req, res ) => {
   }
 };
 
+export const updateDetailedDistance = async ( req, res ) => {
+  try {
+    const { floorId, elementNumber, elementType, detailedDistance } = req.body;
+
+    if ( !floorId || elementNumber === undefined || !elementType || detailedDistance === undefined ) {
+      return res.sendError( 'Missing required fields', 400 );
+    }
+
+    const floorData = await storeBuilderService.findOne( { '_id': new mongoose.Types.ObjectId( floorId ) } );
+
+    const layoutPolygon = floorData.toObject().layoutPolygon.map( ( element ) => {
+      if ( element.elementType === elementType && element.elementNumber === elementNumber ) {
+        return {
+          ...element,
+          detailedDistance: detailedDistance,
+        };
+      } else {
+        return { ...element };
+      }
+    } );
+
+    const updateFloor = await storeBuilderService.updateOne( { '_id': new mongoose.Types.ObjectId( floorId ) }, { layoutPolygon: layoutPolygon } );
 
+
+    if ( !updateFloor.modifiedCount ) {
+      return res.sendError( 'Floor layout or element not found', 400 );
+    }
+
+    return res.sendSuccess( { message: 'Detailed distance updated successfully', updateFloor } );
+  } catch ( error ) {
+    logger.error( 'updateDetailedDistance =>', error );
+    return res.sendError( 'Internal Server Error', 500 );
+  }
+};
+
+export const upsertFixtures = async ( req, res ) => {
+  try {
+    const { fixtureId, planoId, floorId, data } = req.body;
+
+    if ( !planoId || !floorId || !data ) {
+      return res.sendError( 'Missing required fields', 400 );
+    }
+
+    const updateData = {
+      planoId: new mongoose.Types.ObjectId( planoId ),
+      floorId: new mongoose.Types.ObjectId( floorId ),
+      ...data,
+    };
+
+    let fixture;
+    if ( fixtureId ) {
+      fixture = await storeFixtureService.findOneAndUpdate(
+          { _id: fixtureId },
+          { $set: updateData },
+          { new: true, upsert: true },
+      );
+    } else {
+      fixture = await storeFixtureService.create( updateData );
+    }
+
+    return res.sendSuccess( { message: 'Fixture upserted successfully', fixture } );
+  } catch ( error ) {
+    logger.error( 'upsertFixtures =>', error );
+    return res.sendError( 'Internal Server Error', 500 );
+  }
+};

package/src/controllers/task.controller.js

@@ -106,117 +106,123 @@ export async function createTask( req, res ) {
     if ( !taskDetails.length ) {
       return res.sendError( 'No data found', 204 );
     }
+    let endDate = dayjs().add( req.body.days, 'day' ).format( 'YYYY-MM-DD' );
     await Promise.all( taskDetails.map( async ( task ) => {
-      let processedList = await processedService.findOne( { sourceCheckList_id: task._id, checklistStatus: 'submit' } );
-      if ( !processedList ) {
-        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: task._id,
-          checkListName: task.checkListName,
-          checkListId: task._id,
-          scheduleStartTime: '12:00 AM',
-          scheduleEndTime: '11:59 PM',
-          scheduleStartTime_iso: dayjs.utc( '12:00 AM', 'hh:mm A' ).format(),
-          scheduleEndTime_iso: dayjs.utc( '11:59 PM', 'hh:mm A' ).format(),
-          allowedOverTime: false,
-          allowedStoreLocation: false,
-          createdBy: task.createdBy,
-          createdByName: task.createdByName,
-          questionAnswers: [],
-          isdeleted: false,
-          questionCount: 0,
-          storeCount: 0,
-          locationCount: 0,
-          checkListType: 'task',
-          country: '',
-          store_id: '',
-          storeName: '',
-          userId: '',
-          userName: '',
-          userEmail: '',
-          checklistStatus: 'open',
-          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,
-        };
+      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: task._id,
+        checkListName: task.checkListName,
+        checkListId: task._id,
+        scheduleStartTime: '12:00 AM',
+        scheduleEndTime: '11:59 PM',
+        scheduleStartTime_iso: dayjs.utc( '12:00 AM', 'hh:mm A' ).format(),
+        scheduleEndTime_iso: dayjs( endDate ).utc( '11:59 PM', 'hh:mm A' ).format(),
+        allowedOverTime: false,
+        allowedStoreLocation: false,
+        createdBy: task.createdBy,
+        createdByName: task.createdByName,
+        questionAnswers: [],
+        isdeleted: false,
+        questionCount: 0,
+        storeCount: 0,
+        locationCount: 0,
+        checkListType: 'task',
+        country: '',
+        store_id: '',
+        storeName: '',
+        userId: '',
+        userName: '',
+        userEmail: '',
+        checklistStatus: 'open',
+        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,
+        type: task.checkListName == 'Product Verification' ? 'product' : task.checkListName == 'Fixture Verification' ? 'fixture' : 'vm',
+      };
+      let query = [
+        {
+          $addFields: {
+            store: { $toLower: '$storeName' },
+          },
+        },
+        {
+          $match: {
+            clientId: req.body.clientId,
+            store: { $in: storeList },
+          },
+        },
+      ];
+
+      let storeDetails = await storeService.aggregate( query );
+      if ( req.body.userEmail ) {
         let query = [
           {
             $addFields: {
-              store: { $toLower: '$storeName' },
+              emailLower: { $toLower: '$email' },
             },
           },
           {
             $match: {
               clientId: req.body.clientId,
-              store: { $in: storeList },
+              emailLower: req.body.userEmail,
             },
           },
         ];
+        userDetails = await userService.aggregate( query );
+        if ( !userDetails.length ) {
+          let userData = {
+            clientId: req.body.clientId,
+            mobileNumber: '',
+            email: req.body.userEmail,
+            userName: req.body.userEmail.split( '@' )[0],
+          };
+          userDetails = await createUser( userData );
+        } else {
+          userDetails = userDetails[0];
+        }
+      }
 
-        let storeDetails = await storeService.aggregate( query );
-        if ( req.body.userEmail ) {
-          let query = [
-            {
-              $addFields: {
-                emailLower: { $toLower: '$email' },
-              },
-            },
-            {
-              $match: {
-                clientId: req.body.clientId,
-                emailLower: req.body.userEmail,
-              },
-            },
-          ];
-          userDetails = await userService.aggregate( query );
-          if ( !userDetails.length ) {
+      await Promise.all( storeDetails.map( async ( store ) => {
+        let planoDetails = await planoService.findOne( { storeId: store.storeId } );
+        console.log( planoDetails, store.storeId, 'details' );
+        if ( !req.body.userEmail ) {
+          userDetails = await userService.findOne( { email: store?.spocDetails?.[0]?.email } );
+          if ( !userDetails ) {
             let userData = {
               clientId: req.body.clientId,
-              mobileNumber: '',
-              email: req.body.userEmail,
-              userName: req.body.userEmail.split( '@' )[0],
+              mobileNumber: store?.spocDetails?.[0]?.contact,
+              email: store?.spocDetails?.[0]?.email,
+              userName: store?.spocDetails?.[0]?.name,
             };
             userDetails = await createUser( userData );
-          } else {
-            userDetails = userDetails[0];
           }
         }
-        if ( !req.body.userEmail ) {
-          await Promise.all( storeDetails.map( async ( store ) => {
-            let planoDetails = await planoService.findOne( { storeId: store.storeId } );
-            userDetails = await userService.findOne( { email: store?.spocDetails?.[0]?.email } );
-            if ( !userDetails ) {
-              let userData = {
-                clientId: req.body.clientId,
-                mobileNumber: store?.spocDetails?.[0]?.contact,
-                email: store?.spocDetails?.[0]?.email,
-                userName: store?.spocDetails?.[0]?.name,
-              };
-              userDetails = await createUser( userData );
-            }
-            let taskData = { ...data };
-            taskData.store_id = store.storeId;
-            taskData.storeName = store.storeName;
-            taskData.userId = userDetails._id;
-            taskData.userName = userDetails.userName;
-            taskData.userEmail = userDetails.email;
-            taskData.planoId = planoDetails?.planoId;
-            await processedService.create( taskData );
-          } ) );
+        let taskData = { ...data };
+        taskData.store_id = store.storeId;
+        taskData.storeName = store.storeName;
+        taskData.userId = userDetails._id;
+        taskData.userName = userDetails.userName;
+        taskData.userEmail = userDetails.email;
+        taskData.planoId = planoDetails?._id;
+        for ( let i=0; i<req.body.days; i++ ) {
+          let currDate = dayjs().add( i, 'day' );
+          let insertData = { ...taskData, date_string: currDate.format( 'YYYY-MM-DD' ), date_iso: new Date( currDate.format( 'YYYY-MM-DD' ) ), scheduleStartTime_iso: dayjs.utc( `${currDate.format( 'YYYY-MM-DD' )} 12:00 AM`, 'YYYY-MM-DD hh:mm A' ).format() };
+          let response = await processedService.updateOne( { date_string: currDate.format( 'YYYY-MM-DD' ), store_id: insertData.store_id, userEmail: insertData.userEmail, planoId: insertData.planoId, sourceCheckList_id: task._id }, insertData );
+          console.log( insertData.store_id, response );
         }
-      }
+      } ) );
     } ) );
 
     return res.sendSuccess( 'Task created successfully' );
@@ -289,6 +295,9 @@ export async function updateStatus( req, res ) {
       return res.sendError( 'No data found', 204 );
     }
     await processedService.updateOne( { _id: req.body.taskId }, { checklistStatus: req.body.status } );
+    if ( req.body.status == 'submit' ) {
+      await processedService.deleteMany( { _id: req.body.taskId, date_iso: { $gt: new Date( dayjs().format( 'YYYY-MM-DD' ) ) } } );
+    }
     return res.sendSuccess( 'Task status updated successfully' );
   } catch ( e ) {
     logger.error( { functionName: 'storeLayout', error: e } );

package/src/routes/script.routes.js

@@ -0,0 +1,13 @@
+import express from 'express';
+
+export const scriptRouter = express.Router();
+import * as scriptController from '../controllers/script.controller.js';
+
+
+scriptRouter
+    .post( '/getUniqueStoresFromExcel', scriptController.getStoreNames )
+    .post( '/bilkInsertFixtureConfig', scriptController.createFixtureConfig )
+    .post( '/bulkInsertPlanoData', scriptController.createPlano )
+    .post( '/bulkIinsertFloorData', scriptController.createFloors )
+    .post( '/bulkIinsertVmTemplateData', scriptController.createVmData )
+    .post( '/bulkIinsertFixturesShelvesVmsData', scriptController.createFixturesShelves );

package/src/routes/storeBuilder.routes.js

@@ -1,23 +1,25 @@
 import express from 'express';
-import { isAllowedSessionHandler, validate } from 'tango-app-api-middleware';
+import { validate } from 'tango-app-api-middleware';
 import * as storeBuilderController from '../controllers/storeBuilder.controller.js';
+// import * as scriptController from '../controllers/script.controller.js';
 import * as validateDtos from '../dtos/validation.dtos.js';
 
+
 export const storeBuilderRouter = express.Router();
 
 storeBuilderRouter
-    .post( '/createStoreLayout', isAllowedSessionHandler, validate( validateDtos.createBuilder ), storeBuilderController.createStoreBuilder )
-    .post( '/updateStoreLayout', isAllowedSessionHandler, validate( validateDtos.updateStoreLayout ), storeBuilderController.updateStoreLayout )
-    .post( '/storeLayoutList', isAllowedSessionHandler, validate( validateDtos.storeLayoutList ), storeBuilderController.getLayoutList )
-    .post( '/updateFloor', isAllowedSessionHandler, validate( validateDtos.updateFloor ), storeBuilderController.updateFloor )
-    .post( '/uploadBulkStore', isAllowedSessionHandler, storeBuilderController.uploadBulkStore )
-    .post( '/uploadFile', isAllowedSessionHandler, storeBuilderController.uploadFile )
+    .post( '/createStoreLayout', validate( validateDtos.createBuilder ), storeBuilderController.createStoreBuilder )
+    .post( '/updateStoreLayout', validate( validateDtos.updateStoreLayout ), storeBuilderController.updateStoreLayout )
+    .post( '/storeLayoutList', validate( validateDtos.storeLayoutList ), storeBuilderController.getLayoutList )
+    .post( '/updateFloor', validate( validateDtos.updateFloor ), storeBuilderController.updateFloor )
+    .post( '/uploadBulkStore', storeBuilderController.uploadBulkStore )
+    .post( '/uploadFile', storeBuilderController.uploadFile )
     // .post( '/storeLayout', validate( validateDtos.storeList ), storeBuilderController.storeFixtures )
-    .post( '/storeDetails', isAllowedSessionHandler, validate( validateDtos.storeDetails ), storeBuilderController.getStoreDetails )
-    .delete( '/deleteStoreLayout/:id', isAllowedSessionHandler, validate( validateDtos.deleteStoreLayout ), storeBuilderController.deleteStoreLayout )
-    .post( '/removeFile', isAllowedSessionHandler, storeBuilderController.deleteFile )
-    .post( '/deleteFloor', isAllowedSessionHandler, storeBuilderController.deleteFloor )
-    .post( '/updateStatus', isAllowedSessionHandler, validate( validateDtos.updateStatus ), storeBuilderController.updateStatus )
+    .post( '/storeDetails', validate( validateDtos.storeDetails ), storeBuilderController.getStoreDetails )
+    .delete( '/deleteStoreLayout/:id', validate( validateDtos.deleteStoreLayout ), storeBuilderController.deleteStoreLayout )
+    .post( '/removeFile', storeBuilderController.deleteFile )
+    .post( '/deleteFloor', storeBuilderController.deleteFloor )
+    .post( '/updateStatus', validate( validateDtos.updateStatus ), storeBuilderController.updateStatus )
     // .post( '/FixtureShelfDetails', storeBuilderController.fixtureShelfProduct )
     // .post( '/scan', storeBuilderController.scan )
     .post( '/storeLayout', validate( validateDtos.storeList ), storeBuilderController.storeLayout )
@@ -31,5 +33,6 @@ storeBuilderRouter
     .post( '/qrFileUpload', storeBuilderController.qrFileUpload )
     .post( '/updateQrCvProcessRequest', storeBuilderController.updateQrCvProcessRequest )
     .post( '/getQrCvProcessRequest', storeBuilderController.getQrCvProcessRequest )
-    .post( '/fixtureQrUpdate', storeBuilderController.fixtureQrUpdate );
-
+    .post( '/fixtureQrUpdate', storeBuilderController.fixtureQrUpdate )
+    .post( '/updateDeatailedDistance', storeBuilderController.updateDetailedDistance )
+    .post( '/upsertFixture', storeBuilderController.upsertFixtures );

package/src/service/planoProduct.service.js

@@ -24,3 +24,7 @@ export async function aggregate( query ) {
 export async function updateOne( query, record ) {
   return model.planoProductModel.updateOne( query, { $set: record } );
 }
+
+export async function create( data ) {
+  return model.planoProductModel.create( data );
+}

package/src/service/processedchecklist.service.js

@@ -9,7 +9,7 @@ export async function findOne( query = {}, field = {} ) {
 }
 
 export async function updateOne( query = {}, record = {} ) {
-  return model.taskProcessedModel.updateOne( query, { $set: record } );
+  return model.taskProcessedModel.updateOne( query, { $set: record }, { upsert: true } );
 }
 
 export async function find( query = {}, field = {} ) {

package/src/service/storeBuilder.service.js

@@ -8,6 +8,10 @@ export async function findOne( query={}, field={} ) {
   return model.storeLayoutModel.findOne( query, field ).sort( { floorNumber: -1 } );
 }
 
+export async function findOneAndUpdate( query={}, field={} ) {
+  return model.storeLayoutModel.findOneAndUpdate( query, field ).sort( { floorNumber: -1 } );
+}
+
 export async function insertMany( data ) {
   return model.storeLayoutModel.insertMany( data );
 }
@@ -31,3 +35,7 @@ export async function updateOne( query, record ) {
 export async function updateMany( query, record ) {
   return model.storeLayoutModel.updateMany( query, { $set: record } );
 }
+
+export async function create( data ) {
+  return model.storeLayoutModel.create( data );
+}

package/src/service/storeFixture.service.js

@@ -19,3 +19,11 @@ export async function aggregate( query ) {
 export async function updateOne( query, record ) {
   return model.storeFixtureModel.updateOne( query, { $set: record } );
 }
+
+export async function findOneAndUpdate( query={}, field={} ) {
+  return model.storeFixtureModel.findOneAndUpdate( query, field );
+}
+
+export async function create( data ) {
+  return model.storeFixtureModel.create( data );
+}