tango-app-api-store-builder 1.0.0-beta-96 → 1.0.0-beta-97

package/src/controllers/task.controller.js

@@ -4,14 +4,16 @@ import * as storeService from '../service/store.service.js';
 import * as processedChecklistService from '../service/processedchecklist.service.js';
 import * as userService from '../service/user.service.js';
 import dayjs from 'dayjs';
-import { logger, fileUpload, signedUrl, download } from 'tango-app-api-middleware';
+import { logger, fileUpload, signedUrl } from 'tango-app-api-middleware';
 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';
-import * as floorService from '../service/storeBuilder.service.js';
 import mongoose from 'mongoose';
+const ObjectId = mongoose.Types.ObjectId;
+import * as floorService from '../service/storeBuilder.service.js';
+import * as planoStaticService from '../service/planoStaticData.service.js';
 
 dayjs.extend( timeZone );
 
@@ -114,6 +116,18 @@ export async function createTask( req, res ) {
     if ( !taskDetails.length ) {
       return res.sendError( 'No data found', 204 );
     }
+    let endDate;
+    let scheduleEndTime = '11:59 PM';
+    let taskConfig = await planoStaticService.findOne( { clientId: req.body.clientId } );
+    if ( taskConfig && !req.body?.endTime ) {
+      scheduleEndTime = taskConfig.dueTime;
+      req.body.days = taskConfig?.dueDay || 0;
+      req.body.geoFencing = taskConfig?.allowedStoreLocation || false;
+    }
+    if ( req.body?.endTime ) {
+      scheduleEndTime = req.body.endTime;
+    }
+    endDate = dayjs().add( req.body.days, 'day' ).format( 'YYYY-MM-DD' );
     let userEmailList = [ ...new Set( req.body.stores.map( ( ele ) => ele.email ) ) ];
     for ( let mail of userEmailList ) {
       let query = [
@@ -140,7 +154,7 @@ export async function createTask( req, res ) {
         await createUser( userData );
       }
     }
-    let endDate = dayjs().add( req.body.days, 'day' ).format( 'YYYY-MM-DD' );
+    endDate = `${endDate} ${scheduleEndTime}`;
     await Promise.all( taskDetails.map( async ( task ) => {
       let splitName = task?.checkListName.split( ' ' );
       splitName.pop();
@@ -152,11 +166,11 @@ export async function createTask( req, res ) {
         checkListName: task.checkListName,
         checkListId: task._id,
         scheduleStartTime: '12:00 AM',
-        scheduleEndTime: '11:59 PM',
+        scheduleEndTime: scheduleEndTime,
         scheduleStartTime_iso: dayjs.utc( '12:00 AM', 'hh:mm A' ).format(),
-        scheduleEndTime_iso: dayjs( endDate ).utc( '11:59 PM', 'hh:mm A' ).format(),
+        scheduleEndTime_iso: dayjs.utc( endDate, 'YYYY-MM-DD hh:mm A' ).format(),
         allowedOverTime: false,
-        allowedStoreLocation: false,
+        allowedStoreLocation: req.body?.geoFencing || false,
         createdBy: task.createdBy,
         createdByName: task.createdByName,
         questionAnswers: [],
@@ -519,6 +533,30 @@ export async function updateAnswers( req, res ) {
     return res.sendError( e, 500 );
   }
 }
+export async function updateAnswersv2( req, res ) {
+  try {
+    let taskDetails = await processedService.findOne( { date_string: dayjs().format( 'YYYY-MM-DD' ), userId: req.user._id, isPlano: true, planoType: 'layout' } );
+    let data = {
+      fixtureId: req.body.fixtureId,
+      answers: req.body.answers,
+      status: req.body.answers?.find( ( ans ) => typeof ans.answer == 'boolean' && ans?.answer == false ) ? 'incomplete' : 'complete',
+      planoId: req.body.planoId,
+      floorId: req.body.floorId,
+      type: req.body.type,
+      date_iso: new Date( dayjs().format( 'YYYY-MM-DD' ) ),
+      taskId: taskDetails?._id,
+      storeName: taskDetails?.storeName,
+      storeId: taskDetails?.store_id,
+    };
+    console.log( data );
+    await planoTaskService.updateOne( { planoId: req.body.planoId, floorId: req.body.floorId, fixtureId: req.body.fixtureId, type: req.body.type, date_string: dayjs().format( 'YYYY-MM-DD' ), ...( taskDetails?._id ) ? { taskId: taskDetails?._id } :{} }, data );
+
+    return res.sendSuccess( 'Fixture details updated successfully' );
+  } catch ( e ) {
+    logger.error( { functionName: 'updateAnswers', error: e } );
+    return res.sendError( e, 500 );
+  }
+}
 
 export async function getFixtureDetails( req, res ) {
   try {
@@ -629,11 +667,33 @@ export async function generatetaskDetails( req, res ) {
           date_iso: { $gte: new Date( req.body.fromDate ), $lte: new Date( req.body.toDate ) },
           isPlano: true,
           planoType: 'layout',
+          ...( req.body?.store?.length ) ? { storeName: { $in: req.body.store } } :{},
+          userEmail: { $nin: [ 'sandeep.pal@yopmail.com', 'balaji@tangotech.co.in', 'gowri@tangotech.co.in', 'gowri@yopmail.com' ] },
+        },
+      },
+      {
+        $lookup: {
+          from: 'checklistassignconfigs',
+          let: { storeId: '$store_id', email: '$userEmail' },
+          pipeline: [
+            {
+              $match: {
+                $expr: {
+                  $and: [
+                    { $eq: [ '$checkListId', new ObjectId( '6789e3c7a5683c58215ec089' ) ] },
+                    { $eq: [ '$store_id', '$$storeId' ] },
+                    { $eq: [ '$userEmail', '$$email' ] },
+                  ],
+                },
+              },
+            },
+          ],
+          as: 'assignUser',
         },
       },
       {
         $project: {
-          _id: 0,
+          _id: 1,
           storeName: 1,
           store_id: 1,
           userEmail: 1,
@@ -643,7 +703,7 @@ export async function generatetaskDetails( req, res ) {
           storeStatus: {
             $cond: {
               if: { $eq: [ '$checklistStatus', 'submit' ] },
-              then: 'Yes',
+              then: '',
               else: '',
 
             },
@@ -652,51 +712,83 @@ export async function generatetaskDetails( req, res ) {
       },
       {
         $group: {
-          _id: '$store_id',
+          _id: '$planoId',
           count: { $sum: 1 },
           storeName: { $first: '$storeName' },
+          taskId: { $last: '$_id' },
           checklistStatus: { $push: '$checklistStatus' },
+          date_string: { $push: '$date_string' },
         },
       },
       {
         $project: {
           _id: 0,
+          taskId: 1,
           storeName: 1,
           checklistStatus: 1,
           count: 1,
+          date_string: 1,
+          planoId: '$_id',
         },
       },
     ];
-    console.log( JSON.stringify( query ) );
     let taskDetails = await processedService.aggregate( query );
-    let processedTaskDetails = await planoTaskService.find( { date_string: { $gte: req.body.fromDate, $lte: req.body.toDate }, type: 'layout', status: 'incomplete' } );
+    console.log( taskDetails.map( ( ele ) => ele.taskId ) );
+    let processedTaskDetails = await planoTaskService.find( { date_string: { $gte: req.body.fromDate, $lte: req.body.toDate }, type: 'layout', ...( req.body.store.length ) ? { storeName: { $in: req.body.store } } : {}, taskId: { $in: taskDetails.map( ( ele ) => ele.taskId ) } }, { status: 1, planoId: 1, date_string: 1, _id: 0, taskId: 1 } );
     processedTaskDetails.forEach( ( item ) => {
-      let taskIndex = taskDetails.findIndex( ( taskItem ) => taskItem.checklistStatus == 'submit' && item.date_string == taskItem.date_string && item.planoId.toString() == taskItem.planoId.toString() );
+      let taskIndex = taskDetails.findIndex( ( taskItem ) => taskItem.checklistStatus.includes( 'submit' ) && taskItem.date_string.includes( item.date_string ) && item.planoId.toString() == taskItem.planoId.toString() );
       if ( taskIndex != -1 ) {
-        taskDetails[taskIndex].storeStatus = 'No';
+        taskDetails[taskIndex].storeStatus = item.status == 'complete' ? 'yes' : 'No';
       }
     } );
 
     taskDetails.forEach( ( ele ) => {
       delete ele.planoId;
     } );
-    // console.log( taskDetails );
-    // let completeStore = [ ...new Set( taskDetails.filter( ( ele ) => ele.checklistStatus.includes( 'submit' ) ).map( ( ele ) => ele.storeName ) ) ];
 
-    // let incompleteStore = [ ...new Set( taskDetails.filter( ( ele ) => !ele.checklistStatus.includes( 'submit' ) ).map( ( ele ) => {
-    //   return { storeName: ele.storeName, checklistStatus: ele.checklistStatus[ele.checklistStatus.length-1] };
-    // } ) ) ];
 
-    // incompleteStore = incompleteStore.filter( ( ele ) => !completeStore.includes( ele ) );
+    let completeStore = taskDetails.filter( ( ele ) => ele.checklistStatus.includes( 'submit' ) );
+    completeStore = completeStore.reduce( ( acc, ele ) => {
+      if ( !acc[ele.storeName] ) {
+        acc[ele.storeName] = {
+          storeName: ele.storeName,
+          status: 'submit',
+          storeStatus: ele.storeStatus,
+        };
+      }
+      return acc;
+    }, {} );
+
+    completeStore = Object.values( completeStore );
+
+    let completeStoreList =completeStore.map( ( item ) => item.storeName );
+
+    let incompleteStore = taskDetails.filter( ( ele ) => !ele.checklistStatus.includes( 'submit' ) );
+
+    incompleteStore = incompleteStore.reduce( ( acc, ele ) => {
+      if ( !acc[ele.storeName] ) {
+        acc[ele.storeName] = {
+          storeName: ele.storeName,
+          status: ele.checklistStatus[ele.checklistStatus.length - 1],
+          storeStatus: ele.storeStatus,
+        };
+      }
+      return acc;
+    }, {} );
+
+    incompleteStore = Object.values( incompleteStore );
+
+    incompleteStore = incompleteStore.filter( ( ele ) => !completeStoreList.includes( ele.storeName ) );
 
     if ( !taskDetails.length ) {
       return res.sendError( 'No date found', 204 );
     }
 
-    // return res.sendSuccess( { completeCount: completeStore.length, store: completeStore, incompleteStore: incompleteStore, incompleteStoreCount: incompleteStore.length } );
+    let data = [ ...completeStore, ...incompleteStore ];
 
-    await download( taskDetails, res );
+    return res.sendSuccess( { count: data.length, completeStore: completeStore.length, incompleteStore: incompleteStore.length, data } );
   } catch ( e ) {
+    console.log( e );
     logger.error( { functioName: 'generatetaskDetails', error: e } );
     return res.sendError( e, 500 );
   }
@@ -709,22 +801,35 @@ export async function taskSubmitDetails( req, res ) {
         $match: {
           date_string: { $gte: req.body.fromDate, $lte: req.body.toDate },
           type: 'layout',
+          status: req.body.status,
+        },
+      },
+      {
+        $group: {
+          _id: '',
+          planoId: { $addToSet: '$planoId' },
         },
       },
       {
         $lookup: {
-          from: 'planograms',
+          from: 'processedtasks',
           let: { plano_id: '$planoId' },
           pipeline: [
             {
               $match: {
                 $expr: {
                   $and: [
-                    { $eq: [ '$_id', '$$plano_id' ] },
+                    { $in: [ '$planoId', '$$plano_id' ] },
                   ],
                 },
               },
             },
+            {
+              $group: {
+                _id: '$planoId',
+                storeName: { $first: '$storeName' },
+              },
+            },
             {
               $project: {
                 storeName: 1,
@@ -738,41 +843,15 @@ export async function taskSubmitDetails( req, res ) {
       { $unwind: { path: '$planogram', preserveNullAndEmptyArrays: true } },
       {
         $project: {
+          _id: 0,
           storeName: '$planogram.storeName',
-          answers: 1,
-          type: 1,
-          status: 1,
-          planoId: 1,
-          floorId: 1,
-        },
-      },
-      {
-        $group: {
-          _id: '$planoId',
-          storeName: { $first: '$storeName' },
-          answers: { $last: '$answers' },
-          type: { $last: '$type' },
-          status: { $last: '$status' },
-          floorId: { $last: '$floorId' },
-        },
-      },
-      {
-        $project: {
-          storeName: 1,
-          answers: 1,
-          type: 1,
-          status: 1,
-          planoId: '$_id',
-          floorId: 1,
         },
       },
     ];
 
     let processedTaskDetails = await planoTaskService.aggregate( query );
-    let completeStore = [ ...new Set( processedTaskDetails.filter( ( ele ) => ele.status == 'complete' ).map( ( ele ) => ele.storeName ) ) ];
-    let incompleteStore = [ ...new Set( processedTaskDetails.filter( ( ele ) => ele.status == 'incomplete' ).map( ( ele ) => ele.storeName ) ) ];
-    incompleteStore = incompleteStore.filter( ( ele ) => !completeStore.includes( ele ) );
-    return res.sendSuccess( { complete: { count: completeStore.length, storeList: completeStore }, incompleteStore: { count: incompleteStore.length, storeList: incompleteStore }, data: processedTaskDetails } );
+    processedTaskDetails = processedTaskDetails.map( ( ele ) => ele.storeName );
+    return res.sendSuccess( { count: processedTaskDetails.length, data: processedTaskDetails } );
   } catch ( e ) {
     logger.error( { functioName: 'taskSubmitDetails', error: e } );
     return res.sendError( e, 500 );

package/src/dtos/validation.dtos.js

@@ -89,4 +89,222 @@ export const updateStatus = {
   body: updateStatusSchema,
 };
 
+export const createFixtureSchema = joi.object( {
+  fixtureCategory: joi.string().required(),
+  fixtureType: joi.string().required(),
+  clientId: joi.string().required(),
+} );
+
+export const createFixture = {
+  body: createFixtureSchema,
+};
+
+export const updateFixtureSchema = joi.object( {
+  fixtureWidth: joi.object().optional(),
+  fixtureHeight: joi.object().optional(),
+  fixtureCategory: joi.string().optional(),
+  fixtureLength: joi.object().optional(),
+  header: joi.object().optional(),
+  footer: joi.object().optional(),
+  shelfConfig: joi.array().optional(),
+  status: joi.string().required(),
+  fixtureCapacity: joi.number().required(),
+  isBodyEnabled: joi.boolean().required(),
+} );
+
+export const fixtureIdSchema = joi.object( {
+  fixtureId: joi.string().required(),
+} );
+
+export const fixtureId ={
+  query: fixtureIdSchema,
+};
+
+export const bodyFixtureId = {
+  body: fixtureIdSchema,
+};
+
+export const updateFixture = {
+  body: updateFixtureSchema,
+  params: fixtureIdSchema,
+};
+export const fixtureVMListSchema = joi.object( {
+  clientId: joi.string().required(),
+  limit: joi.number().required(),
+  offset: joi.number().required(),
+  sortColumnName: joi.string().required().allow( '' ),
+  sortBy: joi.number().required().allow( '' ),
+  searchValue: joi.string().required().allow( '' ),
+  filter: joi.object( {
+    status: joi.array().items( joi.any() ).min( 0 ),
+    type: joi.array().items( joi.any() ).min( 0 ),
+    size: joi.array().items( joi.any() ).min( 0 ).optional(),
+    brand: joi.array().items( joi.any() ).min( 0 ).optional(),
+    category: joi.array().items( joi.any() ).min( 0 ).optional(),
+    subCategory: joi.array().items( joi.any() ).min( 0 ).optional(),
+  } ).required(),
+  export: joi.boolean().required(),
+  emptyDownload: joi.boolean().required(),
+} );
+
+export const fixtureList = {
+  body: fixtureVMListSchema,
+};
+
+export const addVmTypeSchema = joi.object( {
+  clientId: joi.string().required(),
+  vmData: joi.array().items( joi.any() ).min( 1 ).required(),
+} );
+
+export const addVmType = {
+  body: addVmTypeSchema,
+};
+
+export const getClientSchema = joi.object( {
+  clientId: joi.string().required(),
+} );
+
+export const getClient = {
+  query: getClientSchema,
+};
+
+export const deleteVMTypeImageSchema = joi.object( {
+  vmId: joi.string().required(),
+  index: joi.number().required(),
+} );
+
+export const deleteVMTypeImage = {
+  body: getClientSchema,
+};
+
+export const updateTaskConfigSchema = joi.object( {
+  clientId: joi.string().required(),
+  dueDay: joi.number().required(),
+  dueTime: joi.string().required(),
+  allowedStoreLocation: joi.boolean().required(),
+} );
+
+export const updateTaskConfig = {
+  body: updateTaskConfigSchema,
+};
+
+export const uploadBrandListSchema = joi.object( {
+  clientId: joi.string().required(),
+  brandData: joi.array().items( joi.any() ).min( 1 ).required(),
+} );
+
+export const uploadBrandList = {
+  body: uploadBrandListSchema,
+};
+
+export const fixtureBulkUploadSchema = joi.object( {
+  clientId: joi.string().required(),
+  fixtureData: joi.array().items( joi.any() ).min( 1 ).required(),
+  newFixtureStatus: joi.string().optional(),
+  updateFixtureStatus: joi.string().optional(),
+  deleteFixtureList: joi.array().items( joi.any() ).min( 0 ),
+} );
+
+export const fixtureBulkUpload = {
+  body: fixtureBulkUploadSchema,
+};
+
+export const addUpdateBrandSchema = joi.object( {
+  clientId: joi.string().required(),
+  brandId: joi.string().optional(),
+  brandName: joi.string().required(),
+  subCategory: joi.array().items( joi.any() ).min( 0 ).required(),
+  category: joi.array().items( joi.any() ).min( 1 ).required(),
+} );
+
+export const addUpdateBrand = {
+  body: addUpdateBrandSchema,
+};
+
+export const getVmDetailsSchema = joi.object( {
+  vmId: joi.string().required(),
+} );
+
+export const getVmDetails = {
+  query: getVmDetailsSchema,
+};
+
+export const deleteVmLibSchema = joi.object( {
+  vmId: joi.string().required(),
+} );
+
+export const deleteVmLib = {
+  body: deleteVmLibSchema,
+};
+
+export const addUpdateVmSchema = joi.object( {
+  clientId: joi.string().required(),
+  vmName: joi.string().required(),
+  vmType: joi.string().required(),
+  vmBrand: joi.string().required(),
+  vmSubBrand: joi.string().optional().allow( '' ),
+  vmCategory: joi.string().optional().allow( '' ),
+  vmSubCategory: joi.string().optional().allow( '' ),
+  vmHeight: joi.object( {
+    value: joi.number().required(),
+    unit: joi.string().required(),
+  } ).required(),
+  vmWidth: joi.object( {
+    value: joi.number().required(),
+    unit: joi.string().required(),
+  } ).required(),
+  vmImageUrl: joi.string().optional(),
+  isDoubleSided: joi.boolean().required(),
+  status: joi.string().required(),
+  _id: joi.string().optional(),
+} );
+
+export const addUpdateVm = {
+  body: addUpdateVmSchema,
+};
+
+export const vmBulkUploadSchema = joi.object( {
+  clientId: joi.string().required(),
+  vmData: joi.array().items( joi.any() ).min( 1 ).required(),
+  newVmStatus: joi.string().required(),
+  updateVmStatus: joi.string().required(),
+  deleteVmList: joi.array().required(),
+} );
+
+export const vmBulkUpload = {
+  body: vmBulkUploadSchema,
+};
+
+export const createTemplateSchema = joi.object( {
+  clientId: joi.string().required(),
+  fixtureLibraryId: joi.string().required(),
+} );
+
+export const createTemplate = {
+  body: createTemplateSchema,
+};
+
+export const templateIdSchema = joi.object( {
+  templateId: joi.string().required(),
+} );
+
+export const templateId = {
+  body: templateIdSchema,
+};
+
+export const queryTemplateId = {
+  query: templateIdSchema,
+};
+
+export const updateFixtureTaskSchema = joi.object( {
+  endDate: joi.string().required(),
+  clientId: joi.string().required(),
+  storeList: joi.array().items( joi.any() ).min( 1 ).required(),
+  endTime: joi.string().required(),
+  geoFencing: joi.boolean().required(),
+} );
+
+export const updateFixtureTask = {
+  body: updateFixtureTaskSchema,
+};
 

package/src/routes/fixtureTemplate.routes.js

@@ -0,0 +1,17 @@
+import express from 'express';
+import { validate } from 'tango-app-api-middleware';
+import * as fixtureTemplateController from '../controllers/fixtureTemplate.controller.js';
+import * as validateDtos from '../dtos/validation.dtos.js';
+
+
+export const fixtureTemplateRouter = express.Router();
+
+fixtureTemplateRouter
+    .post( '/createTemplate', validate( validateDtos.createTemplate ), fixtureTemplateController.createTemplate )
+    .post( '/updateTemplate/:templateId', fixtureTemplateController.updateTemplate )
+    .post( '/deleteTemplate', validate( validateDtos.templateId ), fixtureTemplateController.deleteTemplate )
+    .post( '/duplicateTemplate', validate( validateDtos.templateId ), fixtureTemplateController.duplicateTemplate )
+    .post( '/getTemplateList', validate( validateDtos.fixtureVMListSchema ), fixtureTemplateController.getTemplateList )
+    .get( '/getTemplateDetails', validate( validateDtos.queryTemplateId ), fixtureTemplateController.getTemplateDetails )
+    .post( '/updateFixtureTask', validate( validateDtos.updateFixtureTask ), fixtureTemplateController.updateFixtureTask );
+

package/src/routes/managePlano.routes.js

@@ -0,0 +1,12 @@
+import express from 'express';
+import * as managePlanoController from '../controllers/managePlano.controller.js';
+
+
+export const managePlanoRouter = express.Router();
+
+managePlanoRouter
+    .post( '/updateStorePlano', managePlanoController.updateStorePlano )
+    .post( '/getplanoFeedback', managePlanoController.getplanoFeedback )
+    .get( '/fixtureList', managePlanoController.fixtureList )
+    .get( '/templateList', managePlanoController.templateList )
+    .get( '/fixtureBrandsList', managePlanoController.fixtureBrandsList );

package/src/routes/planoLibrary.routes.js

@@ -0,0 +1,40 @@
+import express from 'express';
+import { isAllowedSessionHandler, validate } from 'tango-app-api-middleware';
+import * as planoLibraryController from '../controllers/planoLibrary.controller.js';
+import * as validateDtos from '../dtos/validation.dtos.js';
+
+
+export const planoLibraryRouter = express.Router();
+
+planoLibraryRouter
+    .post( '/fixtureBulkUpload', isAllowedSessionHandler, validate( validateDtos.fixtureBulkUpload ), planoLibraryController.fixtureBulkUpload )
+    .post( '/createFixture', isAllowedSessionHandler, validate( validateDtos.createFixture ), planoLibraryController.createFixture )
+    .post( '/updateFixture/:fixtureId', isAllowedSessionHandler, validate( validateDtos.updateFixture ), planoLibraryController.updateFixture )
+    .get( '/fixtureDetails', isAllowedSessionHandler, validate( validateDtos.fixtureId ), planoLibraryController.getFixture )
+    .post( '/fixtureList', isAllowedSessionHandler, validate( validateDtos.fixtureVMListSchema ), planoLibraryController.FixtureLibraryList )
+    .post( '/duplicateFixture', isAllowedSessionHandler, validate( validateDtos.bodyFixtureId ), planoLibraryController.duplicateFixture )
+    .post( '/deleteFixture', isAllowedSessionHandler, validate( validateDtos.bodyFixtureId ), planoLibraryController.deleteFixture )
+    .get( '/fixtureSizeList', isAllowedSessionHandler, validate( validateDtos.getClient ), planoLibraryController.getFixLibWidth );
+
+planoLibraryRouter
+    .post( '/addVmType', isAllowedSessionHandler, validate( validateDtos.addVmType ), planoLibraryController.addVmType )
+    .post( '/uploadVmtypeImage/:vmId', isAllowedSessionHandler, planoLibraryController.uploadVmImage )
+    .post( '/deleteVmType', isAllowedSessionHandler, planoLibraryController.deleteVmType )
+    .get( '/getVmTypeList', isAllowedSessionHandler, validate( validateDtos.getClient ), planoLibraryController.getVmTypeList )
+    .post( '/deleteVmTypeImage', isAllowedSessionHandler, validate( validateDtos.deleteVMTypeImage ), planoLibraryController.deletevmTypeImage );
+
+planoLibraryRouter
+    .get( '/getBrandList', isAllowedSessionHandler, validate( validateDtos.getClient ), planoLibraryController.getBrandList )
+    .post( '/addUpdateBrand', isAllowedSessionHandler, validate( validateDtos.addUpdateBrand ), planoLibraryController.addUpdateBrandList )
+    .post( '/uploadBrandList', isAllowedSessionHandler, validate( validateDtos.uploadBrandList ), planoLibraryController.uploadBrandList )
+    .post( '/updateTaskconfig', isAllowedSessionHandler, validate( validateDtos.updateTaskConfig ), planoLibraryController.updateTaskConfig )
+    .get( '/getTaskConfig', isAllowedSessionHandler, validate( validateDtos.getClient ), planoLibraryController.getTaskConfig );
+
+planoLibraryRouter
+    .post( '/addUpdateVm', isAllowedSessionHandler, validate( validateDtos.addUpdateVm ), planoLibraryController.addUpdateVm )
+    .post( '/getVmLibList', isAllowedSessionHandler, validate( validateDtos.fixtureVMListSchema ), planoLibraryController.getVmLibList )
+    .post( '/duplicateVmLib', isAllowedSessionHandler, validate( validateDtos.deleteVmLib ), planoLibraryController.duplicateVmLib )
+    .post( '/deleteVmLib', isAllowedSessionHandler, validate( validateDtos.deleteVmLib ), planoLibraryController.deleteVmLibrary )
+    .get( '/getVmDetails', isAllowedSessionHandler, validate( validateDtos.getVmDetails ), planoLibraryController.getVmDetails )
+    .post( '/vmBulkUpload', isAllowedSessionHandler, validate( validateDtos.vmBulkUpload ), planoLibraryController.vmBulkUpload );
+

package/src/routes/script.routes.js

@@ -29,4 +29,6 @@ scriptRouter
     .post( '/downloadPlanoImages', scriptController.downloadPlanoImage )
     .post( '/getVideoUrls', scriptController.getVideoLinks )
     .post( '/updateExcelPlanogram', scriptController.updateExcelPlanogram )
-    .post( '/recorrectTaskData', scriptController.recorrectTaskData );
+    .post( '/recorrectTaskData', scriptController.recorrectTaskData )
+    .post( '/migrateCrest', scriptController.migrateCrestv1 )
+;

package/src/routes/storeBuilder.routes.js

@@ -43,4 +43,8 @@ storeBuilderRouter
     .post( '/getFixtureBrands', isAllowedSessionHandler, storeBuilderController.getFixtureBrands )
     .post( '/checkPlanoExist', isAllowedSessionHandler, storeBuilderController.checkPlanoExist )
     .post( '/storeLayoutElements', isAllowedSessionHandler, storeBuilderController.storeLayoutElements )
-    .post( '/qrScan', storeBuilderController.qrScan );
+    .post( '/qrScan', storeBuilderController.qrScan )
+    .post( '/storeFixturesV2', validate( validateDtos.storeList ), storeBuilderController.storeFixturesv2 )
+    .post( '/fixtureShelfDetailsv2', validate( validateDtos.fixtureShelfProduct ), storeBuilderController.fixtureShelfProductv2 )
+    .post( '/storeFixturesTaskv2', storeBuilderController.storeFixturesTaskv2 )
+;

package/src/routes/task.routes.js

@@ -11,6 +11,7 @@ storeBuilderTaskRouter
     .post( '/uploadImage', isAllowedSessionHandler, taskController.uploadImage )
     .post( '/updateStatus', isAllowedSessionHandler, taskController.updateStatus )
     .post( '/updateAnswers', isAllowedSessionHandler, taskController.updateAnswers )
+    .post( '/updateAnswersv2', isAllowedSessionHandler, taskController.updateAnswersv2 )
     .get( '/getFixtureDetails', isAllowedSessionHandler, taskController.getFixtureDetails )
     .get( '/getVmDetails', isAllowedSessionHandler, taskController.getVmDetails )
     .post( '/generateTaskExcel', taskController.generatetaskDetails )

package/src/service/fixtureConfig.service.js

@@ -8,14 +8,37 @@ export async function findOne( query={}, field={} ) {
   return model.fixtureConfigModel.findOne( query, field );
 }
 
-export async function insertMany( data ) {
+export async function insertMany( data = [] ) {
   return model.fixtureConfigModel.insertMany( data );
 }
 
-export async function aggregate( query ) {
+export async function aggregate( query = [] ) {
   return model.fixtureConfigModel.aggregate( query );
 }
 
-export async function updateOne( query, record ) {
+export async function updateOne( query = {}, record = {} ) {
   return model.fixtureConfigModel.updateOne( query, { $set: record } );
 }
+
+export async function count( query = {} ) {
+  return model.fixtureConfigModel.countDocuments( query );
+}
+
+export async function upsertOne( query, record ) {
+  return model.fixtureConfigModel.findOneAndUpdate(
+      query,
+      record,
+      { upsert: true, new: true },
+  );
+}
+export async function create( data = {} ) {
+  return model.fixtureConfigModel.create( data );
+}
+
+export async function deleteOne( query = {} ) {
+  return model.fixtureConfigModel.deleteOne( query );
+}
+
+export const findAndSort = async ( query={}, field={}, sort={} ) => {
+  return await model.fixtureConfigModel.find( query, field ).sort( sort ).collation( { locale: 'en_US', numericOrdering: true } );
+};