tango-app-api-store-builder 1.0.0-beta-74 → 1.0.0-beta-76

package/package.json

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

package/src/controllers/script.controller.js

@@ -15,6 +15,9 @@ import * as planoTaskService from '../service/planoTask.service.js';
 import * as fixtureConfigService from '../service/fixtureConfig.service.js';
 import mongoose from 'mongoose';
 import JSZip from 'jszip';
+import { signedUrl } from 'tango-app-api-middleware';
+import fs from 'fs';
+import https from 'https';
 
 
 export async function getStoreNames( req, res ) {
@@ -1777,6 +1780,28 @@ export async function getProdTaskData( req, res ) {
   }
 }
 
+export async function extractZipFileNames( req, res ) {
+  try {
+    if ( req?.headers?.authorization?.split( ' ' )[1] !== 'hwjXfCD6TgMvc82cuSGZ9bNv9MuXsaiQ6uvx' ) {
+      return res.sendError( 'Unauthorized', 401 );
+    }
+
+    if ( !req.files.file ) {
+      return res.sendError( 'No file uploaded', 400 );
+    }
+
+    const zip = new JSZip();
+    const zipContents = await zip.loadAsync( req.files.file.data );
+
+    const fileNames = Object.keys( zipContents.files );
+
+    return res.sendSuccess( { fileNames } );
+  } catch ( e ) {
+    logger.error( { functionName: 'extractZipFileNames', error: e } );
+    return res.sendError( e.message || 'Internal Server Error', 500 );
+  }
+}
+
 export async function updatelayoutFeedback( req, res ) {
   try {
     if ( req?.headers?.authorization?.split( ' ' )[1] !== 'hwjXfCD6TgMvc82cuSGZ9bNv9MuXsaiQ6uvx' ) {
@@ -1825,6 +1850,9 @@ export async function updatelayoutFeedback( req, res ) {
             case 'Wall 3':
               rightFixtures.push( {} );
               break;
+            case 'centre':
+              floorFixtures.push( {} );
+              break;
 
             default:
               break;
@@ -1939,28 +1967,6 @@ export async function updatelayoutFeedback( req, res ) {
   }
 }
 
-export async function extractZipFileNames( req, res ) {
-  try {
-    if ( req?.headers?.authorization?.split( ' ' )[1] !== 'hwjXfCD6TgMvc82cuSGZ9bNv9MuXsaiQ6uvx' ) {
-      return res.sendError( 'Unauthorized', 401 );
-    }
-
-    if ( !req.files.file ) {
-      return res.sendError( 'No file uploaded', 400 );
-    }
-
-    const zip = new JSZip();
-    const zipContents = await zip.loadAsync( req.files.file.data );
-
-    const fileNames = Object.keys( zipContents.files );
-
-    return res.sendSuccess( { fileNames } );
-  } catch ( e ) {
-    logger.error( { functionName: 'extractZipFileNames', error: e } );
-    return res.sendError( e.message || 'Internal Server Error', 500 );
-  }
-}
-
 export async function updateFixtureFeedback( req, res ) {
   try {
     if ( req?.headers?.authorization?.split( ' ' )[1] !== 'hwjXfCD6TgMvc82cuSGZ9bNv9MuXsaiQ6uvx' ) {
@@ -1987,7 +1993,7 @@ export async function updateFixtureFeedback( req, res ) {
 
       const planogram = await planoService.findOne( { storeName: store.storeName } );
 
-      const fixtureTaskList = await planoTaskService.find( { planoId: planogram.toObject()._id, type: 'fixture' } );
+      const fixtureTaskList = await planoTaskService.find( { planoId: planogram.toObject()._id, type: 'fixture', date_string: store.date } );
 
       for ( let j = 0; j < fixtureTaskList.length; j++ ) {
         const fixtureTask = fixtureTaskList[j].toObject();
@@ -2002,6 +2008,38 @@ export async function updateFixtureFeedback( req, res ) {
 
         const fixtureDoc = fixture?.toObject();
 
+        if ( q1.issues.includes( 'Fixture size is wrong' ) ) {
+          const fixtureConfig = await fixtureConfigService.findOne( { 'fixtureLength.value': q1.data.fixtureSize.value } );
+
+          if ( fixtureConfig && fixtureConfig.toObject()?.fixtureCode ) {
+            await storeFixtureService.updateOne( { _id: fixtureDoc._id }, { fixtureCode: fixtureConfig.toObject().fixtureCode } );
+          }
+        }
+
+        if ( q1.issues.includes( 'Fixture type is wrong' ) ) {
+          const fixtureConfig = await fixtureConfigService.findOne( { fixtureCategory: q1.data.fixtureType } );
+
+          if ( fixtureConfig && fixtureConfig.toObject().fixtureCode ) {
+            await storeFixtureService.updateOne( { _id: fixtureDoc._id }, { fixtureCode: fixtureConfig.toObject().fixtureCode } );
+          }
+        }
+
+        if ( q1.issues.includes( 'Fixture brand is wrong' ) ) {
+          const fixtureBrand = q1.data.fixtureBrand;
+
+          if ( fixtureBrand?.length ) {
+            const formattedfixtureBrand = fixtureBrand.length ? ( fixtureBrand.length > 1 ? fixtureBrand.join( ' + ' ) : fixtureBrand[0] ) : undefined;
+
+            await storeFixtureService.updateOne( { _id: fixtureDoc._id }, { fixtureName: formattedfixtureBrand, fixtureBrandCategory: formattedfixtureBrand } );
+          }
+        }
+
+        if ( q1.issues.includes( 'Fixture not in the store' ) ) {
+          await storeFixtureService.deleteOne( { _id: fixtureDoc._id } );
+          await fixtureShelfService.deleteMany( { fixtureId: fixtureDoc._id } );
+          await planoMappingService.deleteMany( { fixtureId: fixtureDoc._id } );
+        }
+
 
         if ( q1.issues.includes( 'Shelves count/Product Category/Capacity is wrong' ) ) {
           const taskShelves = q1.data.shelves;
@@ -2022,6 +2060,7 @@ export async function updateFixtureFeedback( req, res ) {
             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;
@@ -2035,18 +2074,17 @@ export async function updateFixtureFeedback( req, res ) {
                 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 } );
+                await planoMappingService.deleteMany( { shelfId: shelf.toObject()._id } );
               } );
             } else if ( taskShelves.length > fixtureShelves.length ) {
               if ( k + 1 <= fixtureShelves.length ) {
@@ -2080,11 +2118,324 @@ export async function updateFixtureFeedback( req, res ) {
           }
         }
       }
+
+      const vmTaskList = await planoTaskService.find( { planoId: planogram.toObject()._id, type: 'vm', date_string: store.date } );
+
+      for ( let j = 0; j < vmTaskList.length; j++ ) {
+        const vmTask = vmTaskList[j].toObject();
+
+        const [ q1, q2 ] = vmTask.answers;
+
+        if ( q1.value ) continue;
+
+        const removeVms = q1.selectedVMs.forEach( async ( vmId ) => {
+          if ( !vmId ) return;
+          const vmObjectId = new mongoose.Types.ObjectId( vmId );
+
+          const deletedVm = await planoMappingService.deleteOne( { _id: vmObjectId } );
+
+          return deletedVm;
+        } );
+
+        console.log( removeVms, 'removed vms' );
+
+        const newVms = q1.newVmsType.forEach( async ( vmType ) => {
+          const vm = await planoProductService.findOne( { type: 'vm', productName: vmType } );
+
+          if ( !vm ) return;
+
+          const insertData = {
+            'clientId': planogram.toObject().clientId,
+            'storeName': planogram.toObject().storeName,
+            'storeId': planogram.toObject().storeId,
+            'type': 'vm',
+            'planoId': planogram.toObject()._id,
+            'floorId': vmTask.floorId,
+            'fixtureId': vmTask.fixtureId,
+            'productId': vm.toObject()._id,
+          };
+
+          const insertedVm = await planoMappingService.create( insertData );
+
+          return insertedVm;
+        } );
+
+        console.log( newVms, 'new vms' );
+      }
     }
 
     res.sendSuccess( 'Updated successfully' );
   } catch ( e ) {
-    logger.error( { functionName: 'updatelayoutFeedback', error: e } );
+    logger.error( { functionName: 'updateFixtureFeedback', error: e } );
     return res.sendError( e.message || 'Internal Server Error', 500 );
   }
 }
+
+export async function getVmTaskData( req, res ) {
+  try {
+    const { storeName, date } = req.body;
+
+    const planogram = await planoService.findOne( { storeName: storeName } );
+
+    const vmTaskList = await planoTaskService.find( { planoId: planogram.toObject()._id, type: 'vm', date_string: date } );
+
+    if ( !vmTaskList?.length ) {
+      return res.sendError( 'No data', 204 );
+    }
+
+    const storefixtures = await storeFixtureService.findAndSort( { planoId: planogram.toObject()._id, fixtureType: { $ne: 'other' } }, { fixtureName: 1, fixtureNumber: 1, _id: 1 }, { fixtureNumber: 1 } );
+
+    const fixtureVmData = await Promise.all(
+        storefixtures.map( async ( fixture ) => {
+          const fixtureDoc = fixture.toObject();
+          const vmTasks = await planoTaskService.find( { fixtureId: fixture._id, type: 'vm' } );
+
+          const q2 = vmTasks[0].toObject().answers?.[1];
+
+          const params = {
+            Bucket: JSON.parse( process.env.BUCKET ).storeBuilder,
+            file_path: q2?.image || null,
+          };
+
+          const fixtureImage = await signedUrl( params );
+
+          const vmTaskData = await Promise.all(
+              vmTasks.flatMap( ( task ) => {
+                const q1 = task.toObject().answers?.[0];
+
+                if ( !q1?.newVmsType || !q1?.newVms ) return [];
+
+                return q1.newVmsType.map( async ( vmtype, k ) => {
+                  const params = {
+                    Bucket: JSON.parse( process.env.BUCKET ).storeBuilder,
+                    file_path: q1.newVms[k]?.imageUrl || null,
+                  };
+                  const signedImg = await signedUrl( params );
+
+                  return {
+                    vmtype,
+                    vmImg: signedImg,
+                  };
+                } );
+              } ),
+          );
+
+          return {
+            vms: vmTaskData,
+            fixtureImg: fixtureImage,
+            ...fixtureDoc,
+          };
+        } ),
+    );
+    return res.sendSuccess( fixtureVmData );
+  } catch ( e ) {
+    logger.error( { functionName: 'getVmTaskData', error: e } );
+    return res.sendError( e.message || 'Internal Server Error', 500 );
+  }
+}
+
+
+export async function updateVmData( req, res ) {
+  try {
+    if ( req?.headers?.authorization?.split( ' ' )[1] !== 'hwjXfCD6TgMvc82cuSGZ9bNv9MuXsaiQ6uvx' ) {
+      return res.sendError( 'Unauthorized', 401 );
+    }
+
+    if ( !req.files.file ) {
+      return res.sendError( 'Excel file is required', 400 );
+    }
+
+    const workbook = xlsx.read( req.files.file.data, { type: 'buffer' } );
+    const sheetName = 'Basha';
+    const raw = xlsx.utils.sheet_to_json( workbook.Sheets[sheetName] );
+
+    let initId = 81;
+
+    for ( let i = 0; i < raw.length; i++ ) {
+      const vmData = raw[i];
+
+      const vmInsertData = {
+        'clientId': '11',
+        'type': 'vm',
+        'productId': 'VM' + initId,
+        'productName': vmData?.['VM Categories '],
+        'productHeight': {
+          'value': vmData?.['VM Height mm'],
+          'unit': 'mm',
+        },
+        'productWidth': {
+          'value': vmData?.['VM Width mm'],
+          'unit': 'mm',
+        },
+        'startYPosition': vmData?.['StartPosition '],
+        'endYPosition': vmData?.['End Position'],
+        'xZone': vmData?.['Start Zone '],
+      };
+
+      const createdVm = await planoProductService.create( vmInsertData );
+
+      initId += 1;
+
+      const fixture = await storeFixtureService.findOne( { storeName: vmData?.['Store name '], fixtureNumber: vmData?.['Fixture Number'] } );
+
+      const fixtureDoc = fixture?.toObject();
+
+      if ( !fixture ) {
+        continue;
+      }
+
+      const mappingData = {
+        'clientId': '11',
+        'storeName': fixtureDoc.storeName,
+        'storeId': fixtureDoc.storeId,
+        'type': 'vm',
+        'planoId': fixtureDoc.planoId,
+        'floorId': fixtureDoc.floorId,
+        'fixtureId': fixtureDoc._id,
+        'productId': createdVm.toObject()._id,
+      };
+
+      await planoMappingService.create( mappingData );
+    }
+
+    res.sendSuccess( 'Updated Successfully' );
+  } catch ( e ) {
+    logger.error( { functionName: 'getVmTaskData', error: e } );
+    return res.sendError( e.message || 'Internal Server Error', 500 );
+  }
+}
+
+
+async function scrapeCrest() {
+  const storeIds = [];
+  const apiUrl = 'https://api.getcrest.ai/api/ms_shelfsensei/layout/';
+  const bearerToken = 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJ0b2tlbl90eXBlIjoiYWNjZXNzIiwiZXhwIjoxNzQzNjY5ODIyLCJpYXQiOjE3NDM2NjYyMjIsImp0aSI6IjA5ZDRjYTVhZGRiNzQxMDVhYjhjOWVjMmU3MjZiM2NiIiwidXNlcl9pZCI6MTA4NSwiaWQiOjEwODUsImN1c3RvbWVyX2dyb3VwIjozOTgsImxpY2VuY2Vfc2NvcGVzIjpbeyJyZXNvdXJjZV9zZXQiOiJwcF9zZXQiLCJzY29wZV9yb2xlIjoiY29udHJpYnV0b3IifSx7InJlc291cmNlX3NldCI6ImRwX3NldCIsInNjb3BlX3JvbGUiOiJjb250cmlidXRvciJ9LHsicmVzb3VyY2Vfc2V0IjoiZGZfc2V0Iiwic2NvcGVfcm9sZSI6ImNvbnRyaWJ1dG9yIn0seyJyZXNvdXJjZV9zZXQiOiJkZWZhdWx0X3NldCIsInNjb3BlX3JvbGUiOiJjb250cmlidXRvciJ9XX0.C3wLXzbv0bTDGiZqs8jSA3up0cq0wqA5PIMw45_T4Wg';
+  const filePath = 'response.json';
+  let allResults = [];
+
+  if ( fs.existsSync( filePath ) ) {
+    try {
+      const existingData = fs.readFileSync( filePath, 'utf8' );
+      allResults = JSON.parse( existingData );
+      if ( !Array.isArray( allResults ) ) {
+        allResults = [];
+      }
+    } catch ( error ) {
+      console.error( 'Error reading existing JSON file:', error.message );
+      allResults = [];
+    }
+  }
+
+  for ( const storeId of storeIds ) {
+    try {
+      const result = await new Promise( ( resolve ) => {
+        const payload = JSON.stringify( { store_id: storeId } );
+        const options = {
+          method: 'POST',
+          headers: {
+            'Authorization': `Bearer ${bearerToken}`,
+            'Content-Type': 'application/json',
+            'Content-Length': Buffer.byteLength( payload ),
+          },
+        };
+
+        const req = https.request( apiUrl, options, ( res ) => {
+          let data = '';
+          res.on( 'data', ( chunk ) => {
+            data += chunk;
+          } );
+          res.on( 'end', () => {
+            try {
+              const jsonData = JSON.parse( data );
+              const result = { storeName: storeId, data: jsonData };
+              allResults.push( result );
+              fs.writeFileSync( filePath, JSON.stringify( allResults, null, 2 ) );
+              console.log( 'Received Data:', result );
+              resolve( result );
+            } catch ( error ) {
+              console.error( `Error parsing JSON for ${storeId}:`, error.message );
+              resolve( { storeName: storeId, data: null } );
+            }
+          } );
+        } );
+
+        req.on( 'error', ( error ) => {
+          console.error( `Error fetching data for ${storeId}:`, error.message );
+          resolve( { storeName: storeId, data: null } );
+        } );
+
+        req.write( payload );
+        req.end();
+      } );
+    } catch ( error ) {
+      console.error( `Unexpected error for ${storeId}:`, error.message );
+    }
+    await new Promise( ( resolve ) => setTimeout( resolve, 1000 ) );
+  }
+}
+
+export async function createCrestPlanogram( req, res ) {
+  try {
+    if ( req?.headers?.authorization?.split( ' ' )[1] !== 'hwjXfCD6TgMvc82cuSGZ9bNv9MuXsaiQ6uvx' ) {
+      return res.sendError( 'Unauthorized', 401 );
+    }
+
+    if ( !req.files || !req.files.file ) {
+      return res.sendError( 'JSON file is required', 400 );
+    }
+
+    const data = JSON.parse( req.files.file.data.toString( 'utf8' ) );
+
+    const crestData = data.filter( ( item ) => item.data.message === 'SUCCESS' );
+
+    const fixtureTypes = new Set();
+    const centerSubMains = new Set();
+
+    crestData.forEach( ( store ) => {
+      store.data.result.forEach( ( section ) => {
+        if ( section.fixtures ) {
+          section.fixtures.forEach( ( fixture ) => {
+            if ( fixture.fixtureType ) {
+              fixtureTypes.add( fixture.fixtureType );
+            }
+          } );
+        }
+
+        if ( section.main === 'Euro Center' && section.centerSubMain ) {
+          centerSubMains.add( section.centerSubMain );
+        }
+      } );
+    } );
+
+    return res.sendSuccess( {
+      fixtureTypes: Array.from( fixtureTypes ),
+      euroCenterSubMains: Array.from( centerSubMains ),
+    } );
+  } catch ( e ) {
+    logger.error( { functionName: 'createCrestPlanogram', error: e } );
+    return res.sendError( e.message || 'Internal Server Error', 500 );
+  }
+}
+
+const data = {
+  'clientId': '11',
+  'fixtureCode': 'FX01',
+  'fixtureCategory': 'Shelves',
+  'fixtureConfigLength': {
+    'value': 3,
+    'unit': 'ft',
+  },
+  'fixtureConfigWidth': {
+    'value': 2,
+    'unit': 'ft',
+  },
+  'fixtureConfigType': 'Shelves',
+  'shelfConfig': [
+    {
+      shelfNumber: 1,
+      shelfZone: 'Top',
+      shelfSplitup: 0,
+      shelfProducts: 10,
+    },
+  ],
+};

package/src/controllers/storeBuilder.controller.js

@@ -2633,6 +2633,7 @@ export const getFixtureTypes = async ( req, res ) => {
         $project:
           {
             fixtureCategory: 1,
+            fixtureLength: 1,
           },
       },
       {
@@ -2643,12 +2644,13 @@ export const getFixtureTypes = async ( req, res ) => {
       {
         $group: {
           _id: '$fixtureCategory',
+          fixtureLength: { $first: '$fixtureLength' },
         },
       },
       {
         $group: {
           '_id': null,
-          'fixtureCategory': { '$push': '$_id' },
+          'fixtureCategory': { '$push': { $concat: [ '$_id', '-', { $toString: '$fixtureLength.value' }, '$fixtureLength.unit' ] } },
         },
       },
       {

package/src/controllers/task.controller.js

@@ -139,6 +139,8 @@ export async function createTask( req, res ) {
     }
     let endDate = dayjs().add( req.body.days, 'day' ).format( 'YYYY-MM-DD' );
     await Promise.all( taskDetails.map( async ( task ) => {
+      let splitName = task?.checkListName.split( ' ' );
+      splitName.pop();
       let data = {
         client_id: req.body.clientId,
         date_iso: new Date( dayjs().format( 'YYYY-MM-DD' ) ),
@@ -180,7 +182,7 @@ export async function createTask( req, res ) {
         approvalEnable: false,
         redoStatus: false,
         isPlano: true,
-        planoType: task.checkListName == 'Product Verification' ? 'product' : task.checkListName == 'Layout and Fixture Verification' ? 'layoutFixture' : 'vm',
+        planoType: splitName.length == 1 ? splitName[0].toLowerCase() : splitName[0].toLowerCase() + splitName[2],
       };
       let query = [
         {

package/src/routes/script.routes.js

@@ -19,4 +19,7 @@ scriptRouter
     .post( '/getProdTaskData', scriptController.getProdTaskData )
     .post( '/updateLayoutFeedback', scriptController.updatelayoutFeedback )
     .post( '/updateFixtureFeedback', scriptController.updateFixtureFeedback )
-    .post( '/getFileNames', scriptController.extractZipFileNames );
+    .post( '/getFileNames', scriptController.extractZipFileNames )
+    .post( '/getVmTaskData', scriptController.getVmTaskData )
+    .post( '/updateVmData', scriptController.updateVmData )
+    .post( '/createCrestPlanogram', scriptController.createCrestPlanogram );

package/src/routes/storeBuilder.routes.js

@@ -10,7 +10,7 @@ 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( '/storeLayoutList', validate( validateDtos.storeLayoutList ), storeBuilderController.getLayoutList )
     .post( '/updateFloor', isAllowedSessionHandler, validate( validateDtos.updateFloor ), storeBuilderController.updateFloor )
     .post( '/uploadBulkStore', isAllowedSessionHandler, storeBuilderController.uploadBulkStore )
     .post( '/uploadFile', isAllowedSessionHandler, storeBuilderController.uploadFile )
@@ -24,12 +24,12 @@ storeBuilderRouter
     // .post( '/scan', storeBuilderController.scan )
     .post( '/storeLayout', isAllowedSessionHandler, validate( validateDtos.storeList ), storeBuilderController.storeLayout )
     .post( '/storeFixtures', validate( validateDtos.storeList ), storeBuilderController.storeFixturesv1 )
-    .post( '/FixtureShelfDetails', validate( validateDtos.fixtureShelfProduct ), storeBuilderController.fixtureShelfProductv1 )
+    .post( '/FixtureShelfDetails', isAllowedSessionHandler, 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', storeBuilderController.storeFixturesTask )
+    .post( '/storeFixturesTask', isAllowedSessionHandler, storeBuilderController.storeFixturesTask )
     .post( '/qrFileUpload', isAllowedSessionHandler, storeBuilderController.qrFileUpload )
     .post( '/updateQrCvProcessRequest', isAllowedSessionHandler, storeBuilderController.updateQrCvProcessRequest )
     .post( '/getQrCvProcessRequest', isAllowedSessionHandler, storeBuilderController.getQrCvProcessRequest )
@@ -40,6 +40,6 @@ storeBuilderRouter
     .post( '/getshelfSections', isAllowedSessionHandler, storeBuilderController.getShelfSections )
     .post( '/getFixtureTypes', isAllowedSessionHandler, storeBuilderController.getFixtureTypes )
     .post( '/getFixtureLengths', isAllowedSessionHandler, storeBuilderController.getFixtureLengths )
-    .post( '/getFixtureBrands', storeBuilderController.getFixtureBrands )
-    .post( '/checkPlanoExist', isAllowedSessionHandler, storeBuilderController.checkPlanoExist )
+    .post( '/getFixtureBrands', isAllowedSessionHandler, storeBuilderController.getFixtureBrands )
+    .post( '/checkPlanoExist', storeBuilderController.checkPlanoExist )
     .post( '/storeLayoutElements', isAllowedSessionHandler, storeBuilderController.storeLayoutElements );

package/src/service/fixtureShelf.service.js

@@ -35,3 +35,7 @@ export async function count( data ) {
 export async function deleteOne( query ) {
   return model.fixtureShelfModel.deleteOne( query );
 }
+
+export async function deleteMany( query ) {
+  return model.fixtureShelfModel.deleteMany( query );
+}

package/src/service/planoMapping.service.js

@@ -26,3 +26,11 @@ export async function count( query ) {
 export async function create( data ) {
   return model.planoMappingModel.create( data );
 }
+
+export async function deleteOne( query ) {
+  return model.planoMappingModel.deleteOne( query );
+}
+
+export async function deleteMany( query ) {
+  return model.planoMappingModel.deleteMany( query );
+}

package/src/service/storeFixture.service.js

@@ -31,3 +31,11 @@ export async function findOneAndUpdate2( query={}, field={} ) {
 export async function create( data ) {
   return model.storeFixtureModel.create( data );
 }
+
+export async function deleteOne( query ) {
+  return model.storeFixtureModel.deleteOne( query );
+}
+
+export async function findAndSort( query={}, field={}, sortField={} ) {
+  return model.storeFixtureModel.find( query, field ).sort( sortField );
+}