tango-app-api-store-builder 1.0.0-beta-112 → 1.0.0-beta-114

package/src/controllers/storeBuilder.controller.js

@@ -574,6 +574,7 @@ export async function storeFixturesv1( req, res ) {
           const floorsWithFixtures = await Promise.all(
               floors.map( async ( floor ) => {
                 let productCapacity = 0;
+                let fixtureCount = 0;
                 const layoutPolygonWithFixtures = await Promise.all(
                     floor.layoutPolygon.map( async ( element ) => {
                       const fixtures = await storeFixtureService.findAndSort( {
@@ -595,6 +596,7 @@ export async function storeFixturesv1( req, res ) {
                               fixture.imageUrl = '';
                             }
                             productCapacity += fixture.toObject().fixtureCapacity;
+                            fixtureCount += 1;
                             const productCount = await planoMappingService.count( { fixtureId: fixture._id, type: 'product' } );
 
                             const vmCount = await planoMappingService.count( { fixtureId: fixture._id, type: 'vm' } );
@@ -696,6 +698,8 @@ export async function storeFixturesv1( req, res ) {
                         fixture.imageUrl = '';
                       }
                       productCapacity += fixture.toObject().fixtureCapacity;
+                      fixtureCount += 1;
+
                       const productCount = await planoMappingService.count( { fixtureId: fixture._id, type: 'product' } );
 
                       const vmCount = await planoMappingService.count( { fixtureId: fixture._id, type: 'vm' } );
@@ -741,10 +745,16 @@ export async function storeFixturesv1( req, res ) {
 
                       const vmDetails = await Promise.all( vms.map( async ( vm ) => {
                         const vmTemplate = await planoProductService.findOne( { _id: vm.toObject().productId } );
-
+                        const params = {
+                          Bucket: JSON.parse( process.env.BUCKET ).storeBuilder,
+                          file_path: vmTemplate?.productImageUrl,
+                        };
+                        const vmImage = await signedUrl( params );
                         return {
                           ...vm.toObject(),
                           ...vmTemplate?.toObject(),
+                          ...( typeof vmImage === 'string' && { productImageUrl: vmImage } ),
+
                         };
                       } ) );
 
@@ -774,6 +784,7 @@ export async function storeFixturesv1( req, res ) {
                   layoutPolygon: layoutPolygonWithFixtures,
                   centerFixture: centerFixturesWithStatus,
                   productCount: productCapacity,
+                  fixtureCount: fixtureCount,
                   // productCapacity: productCapacity,
                   otherElements: otherElements,
                 };
@@ -1590,7 +1601,8 @@ export const uploadImage = async ( req, res ) => {
       return res.sendError( { message: 'Something went Wrong' }, 500 );
     }
 
-    return res.sendSuccess( { message: 'Uploaded Successfully', imgUrl: imgUrl } );
+
+    return res.sendSuccess( { message: 'Uploaded Successfully', imgUrl: imgUrl, path: imgUrl.Key } );
   } catch ( e ) {
     logger.error( 'uploadImage =>', e );
     return res.sendError( e, 500 );
@@ -1626,6 +1638,7 @@ export async function storeFixturesTask( req, res ) {
           const floorsWithFixtures = await Promise.all(
               floors.map( async ( floor ) => {
                 let productCapacity = 0;
+                let fixtureCount = 0;
                 const layoutPolygonWithFixtures = await Promise.all(
                     floor.layoutPolygon.map( async ( element ) => {
                       const fixtures = await storeFixtureService.findAndSort( {
@@ -1647,6 +1660,7 @@ export async function storeFixturesTask( req, res ) {
                               fixture.imageUrl = '';
                             }
                             productCapacity += fixture.toObject().fixtureCapacity;
+                            fixtureCount += 1;
                             const productCount = await planoMappingService.count( { fixtureId: fixture._id, type: 'product' } );
 
                             const vmCount = await planoMappingService.count( { fixtureId: fixture._id, type: 'vm' } );
@@ -1677,9 +1691,16 @@ export async function storeFixturesTask( req, res ) {
 
                             const vmDetails = await Promise.all( vms.map( async ( vm ) => {
                               const vmTemplate = await planoProductService.findOne( { _id: vm.toObject().productId } );
+                              const params = {
+                                Bucket: JSON.parse( process.env.BUCKET ).storeBuilder,
+                                file_path: vmTemplate?.productImageUrl,
+                              };
+                              const vmImage = await signedUrl( params );
                               return {
                                 ...vm.toObject(),
                                 ...vmTemplate?.toObject(),
+                                ...( typeof vmImage === 'string' && { productImageUrl: vmImage } ),
+
                               };
                             } ) );
 
@@ -1727,6 +1748,7 @@ export async function storeFixturesTask( req, res ) {
                         fixture.imageUrl = '';
                       }
                       productCapacity += fixture.toObject().fixtureCapacity;
+                      fixtureCount += 1;
                       const productCount = await planoMappingService.count( { fixtureId: fixture._id, type: 'product' } );
 
                       const vmCount = await planoMappingService.count( { fixtureId: fixture._id, type: 'vm' } );
@@ -1758,9 +1780,16 @@ export async function storeFixturesTask( req, res ) {
                       const vmDetails = await Promise.all( vms.map( async ( vm ) => {
                         const vmTemplate = await planoProductService.findOne( { _id: vm.toObject().productId } );
 
+                        const params = {
+                          Bucket: JSON.parse( process.env.BUCKET ).storeBuilder,
+                          file_path: vmTemplate?.productImageUrl,
+                        };
+                        const vmImage = await signedUrl( params );
                         return {
                           ...vm.toObject(),
                           ...vmTemplate?.toObject(),
+                          ...( typeof vmImage === 'string' && { productImageUrl: vmImage } ),
+
                         };
                       } ) );
 
@@ -1790,6 +1819,7 @@ export async function storeFixturesTask( req, res ) {
                   layoutPolygon: layoutPolygonWithFixtures,
                   centerFixture: centerFixturesWithStatus,
                   productCount: productCapacity,
+                  fixtureCount: fixtureCount,
                   // productCapacity: productCapacity,
                   otherElements: otherElements,
                 };
@@ -2630,6 +2660,8 @@ export async function storeFixturesv2( req, res ) {
           const floorsWithFixtures = await Promise.all(
               floors.map( async ( floor ) => {
                 let productCapacity = 0;
+                let fixtureCount = 0;
+                let totalVmCount = 0;
                 const layoutPolygonWithFixtures = await Promise.all(
                     floor.layoutPolygon.map( async ( element ) => {
                       const fixtures = await storeFixtureService.findAndSort( {
@@ -2651,6 +2683,7 @@ export async function storeFixturesv2( req, res ) {
                               fixture.imageUrl = '';
                             }
                             productCapacity += fixture.toObject().fixtureCapacity;
+                            fixtureCount += 1;
                             const productCount = await planoMappingService.count( { fixtureId: fixture._id, type: 'product' } );
 
                             const vmCount = await planoMappingService.count( { fixtureId: fixture._id, type: 'vm' } );
@@ -2694,6 +2727,7 @@ export async function storeFixturesv2( req, res ) {
 
 
                             const vmDetails = await Promise.all( fixture.toObject()?.vmConfig?.map( async ( vm ) => {
+                              totalVmCount += 1;
                               const vmInfo = await planoVmService.findOne( { _id: vm.vmId } );
                               return {
                                 ...vm,
@@ -2745,6 +2779,7 @@ export async function storeFixturesv2( req, res ) {
                         fixture.imageUrl = '';
                       }
                       productCapacity += fixture.toObject().fixtureCapacity;
+                      fixtureCount += 1;
                       const productCount = await planoMappingService.count( { fixtureId: fixture._id, type: 'product' } );
 
                       const vmCount = await planoMappingService.count( { fixtureId: fixture._id, type: 'vm' } );
@@ -2788,6 +2823,7 @@ export async function storeFixturesv2( req, res ) {
 
 
                       const vmDetails = await Promise.all( fixture.toObject().vmConfig.map( async ( vm ) => {
+                        totalVmCount += 1;
                         const vmInfo = await planoVmService.findOne( { _id: vm.vmId } );
 
                         return {
@@ -2819,6 +2855,8 @@ export async function storeFixturesv2( req, res ) {
 
                 return {
                   ...floor.toObject(),
+                  fixtureCount: fixtureCount,
+                  vmCount: totalVmCount,
                   layoutPolygon: layoutPolygonWithFixtures,
                   centerFixture: centerFixturesWithStatus,
                   productCount: productCapacity,
@@ -2942,6 +2980,8 @@ export async function storeFixturesTaskv2( req, res ) {
           const floorsWithFixtures = await Promise.all(
               floors.map( async ( floor ) => {
                 let productCapacity = 0;
+                let fixtureCount = 0;
+                let totalVmCount = 0;
                 const layoutPolygonWithFixtures = await Promise.all(
                     floor.layoutPolygon.map( async ( element ) => {
                       const fixtures = await storeFixtureService.findAndSort( {
@@ -2963,6 +3003,7 @@ export async function storeFixturesTaskv2( req, res ) {
                               fixture.imageUrl = '';
                             }
                             productCapacity += fixture.toObject().fixtureCapacity;
+                            fixtureCount += 1;
                             const productCount = await planoMappingService.count( { fixtureId: fixture._id, type: 'product' } );
 
                             const vmCount = await planoMappingService.count( { fixtureId: fixture._id, type: 'vm' } );
@@ -2971,9 +3012,9 @@ export async function storeFixturesTaskv2( req, res ) {
                               fixtureId: fixture._id,
                               type: req.body?.type ? req.body.type : 'fixture',
                               date_string: req.body?.date,
-                            }, { status: 1 } );
+                            }, { status: 1, answers: 1 } );
 
-                            const shelves = await fixtureShelfService.findAndSort( { fixtureId: fixture._id }, { shelfNumber: 1, sectionName: 1, sectionZone: 1, shelfCapacity: 1, shelfSplitup: 1 }, { shelfNumber: 1 } );
+                            const shelves = await fixtureShelfService.findAndSort( { fixtureId: fixture._id }, { }, { shelfNumber: 1 } );
 
                             const shelfDetails = await Promise.all(
                                 shelves.map( async ( shelf ) => {
@@ -2991,6 +3032,7 @@ export async function storeFixturesTaskv2( req, res ) {
 
 
                             const vmDetails = await Promise.all( fixture.toObject()?.vmConfig?.map( async ( vm ) => {
+                              totalVmCount += 1;
                               const vmInfo = await planoVmService.findOne( { _id: vm.vmId } );
                               return {
                                 ...vm,
@@ -2998,11 +3040,20 @@ export async function storeFixturesTaskv2( req, res ) {
                               };
                             } ) );
 
+                            let disabled = true;
+                            if ( compliance?.status && compliance.status == 'incomplete' ) {
+                              let issueDetails = compliance?.answers?.[0]?.issues.find( ( ele ) => ele.status == 'disagree' );
+                              if ( issueDetails ) {
+                                disabled = false;
+                              }
+                            }
+
                             return {
                               ...fixture.toObject(),
                               status: compliance?.status ? compliance.status : '',
                               shelfCount: shelves.length,
                               productCount: productCount,
+                              disabled: disabled,
                               vmCount: vmCount,
                               shelfConfig: shelfDetails,
                               vmConfig: vmDetails,
@@ -3042,6 +3093,7 @@ export async function storeFixturesTaskv2( req, res ) {
                         fixture.imageUrl = '';
                       }
                       productCapacity += fixture.toObject().fixtureCapacity;
+                      fixtureCount += 1;
                       const productCount = await planoMappingService.count( { fixtureId: fixture._id, type: 'product' } );
 
                       const vmCount = await planoMappingService.count( { fixtureId: fixture._id, type: 'vm' } );
@@ -3052,7 +3104,7 @@ export async function storeFixturesTaskv2( req, res ) {
                         date_string: req.body?.date,
                       }, { status: 1 } );
 
-                      const shelves = await fixtureShelfService.findAndSort( { fixtureId: fixture._id }, { shelfNumber: 1, sectionName: 1, sectionZone: 1, shelfCapacity: 1, shelfSplitup: 1 }, { shelfNumber: 1 } );
+                      const shelves = await fixtureShelfService.findAndSort( { fixtureId: fixture._id }, { }, { shelfNumber: 1 } );
 
                       const shelfDetails = await Promise.all(
                           shelves.map( async ( shelf ) => {
@@ -3069,6 +3121,7 @@ export async function storeFixturesTaskv2( req, res ) {
                       );
 
                       const vmDetails = await Promise.all( fixture.toObject()?.vmConfig?.map( async ( vm ) => {
+                        totalVmCount += 1;
                         const vmInfo = await planoVmService.findOne( { _id: vm.vmId } );
                         return {
                           ...vm,
@@ -3099,6 +3152,8 @@ export async function storeFixturesTaskv2( req, res ) {
 
                 return {
                   ...floor.toObject(),
+                  fixtureCount: fixtureCount,
+                  vmCount: totalVmCount,
                   layoutPolygon: layoutPolygonWithFixtures,
                   centerFixture: centerFixturesWithStatus,
                   productCount: productCapacity,
@@ -3121,3 +3176,116 @@ export async function storeFixturesTaskv2( req, res ) {
     return res.sendError( e, 500 );
   }
 }
+
+export async function planoList( req, res ) {
+  try {
+    let inputData = req.body;
+    let limit = inputData?.limit || 10;
+    let page = inputData?.offset - 1 || 0;
+    let skip = limit * page;
+    let query = [
+      {
+        $match: {
+          clientId: inputData.clientId,
+        },
+      },
+      {
+        $lookup: {
+          from: 'storelayouts',
+          let: { plano: '$_id' },
+          pipeline: [
+            {
+              $match: {
+                $expr: {
+                  $eq: [ '$planoId', '$$plano' ],
+                },
+              },
+            },
+            {
+              $group: {
+                _id: '',
+                layoutDetails: { $push: { k: '$_id', v: '$status', planoId: '$$plano' } },
+              },
+            },
+          ],
+          as: 'layout',
+        },
+      },
+      { $unwind: { path: '$layout', preserveNullAndEmptyArrays: true } },
+      {
+        $lookup: {
+          from: 'storefixtures',
+          let: { plano: '$_id' },
+          pipeline: [
+            {
+              $match: {
+                $expr: {
+                  $eq: [ '$planoId', '$$plano' ],
+                },
+              },
+            },
+            {
+              $group: {
+                _id: '',
+                fixtureCount: { $sum: 1 },
+                vmCount: { $sum: { $size: '$vmConfig' } },
+                fixtureCapacity: { $sum: '$fixtureCapacity' },
+              },
+            },
+          ],
+          as: 'fixtureDetails',
+        },
+      },
+      { $unwind: { path: '$fixtureDetails', preserveNullAndEmptyArrays: true } },
+      {
+        $project: {
+          storeName: 1,
+          layoutName: 1,
+          layoutDetails: '$layout.layoutDetails',
+          fixtureCount: '$fixtureDetails.fixtureCount',
+          vmCount: '$fixtureDetails.vmCount',
+          fixtureCapacity: '$fixtureDetails.fixtureCapacity',
+          status: 1,
+          planoProgress: 1,
+        },
+      },
+    ];
+    if ( inputData.sortColumnName && inputData.sortBy ) {
+      query.push( { $sort: { [inputData.sortColumnName]: inputData.sortBy } } );
+    }
+    if ( inputData.searchValue ) {
+      query.push( {
+        $match: {
+          storeName: { $regex: inputData.searchValue, $options: 'i' },
+        },
+      } );
+    }
+
+    query.push( {
+      $facet: {
+        data: [
+          { $skip: skip },
+          { $limit: limit },
+        ],
+        count: [
+          { $count: 'total' },
+        ],
+      },
+    } );
+
+    let planoDetails = await planoService.aggregate( query );
+
+    if ( !planoDetails[0].data.length ) {
+      return res.sendError( 'No data found', 204 );
+    }
+    let result = {
+      data: planoDetails[0].data,
+      count: planoDetails?.[0]?.count?.[0]?.total || 0,
+    };
+    return res.sendSuccess( result );
+  } catch ( e ) {
+    console.log( e );
+    logger.error( { functionName: 'planoList', error: e } );
+    return res.sendError( e, 500 );
+  }
+}

package/src/controllers/task.controller.js

@@ -11,7 +11,7 @@ import * as checklistService from '../service/checklist.service.js';
 import timeZone from 'dayjs/plugin/timezone.js';
 import * as planoProductService from '../service/planoProduct.service.js';
 import mongoose from 'mongoose';
-const ObjectId = mongoose.Types.ObjectId;
+// const ObjectId = mongoose.Types.ObjectId;
 import * as floorService from '../service/storeBuilder.service.js';
 import * as planoStaticService from '../service/planoStaticData.service.js';
 
@@ -118,10 +118,10 @@ export async function createTask( req, res ) {
     }
     let endDate;
     let scheduleEndTime = '11:59 PM';
-    let taskConfig = await planoStaticService.findOne( { clientId: req.body.clientId } );
+    let taskConfig = await planoStaticService.findOne( { clientId: req.body.clientId, type: 'task' } );
     if ( taskConfig && !req.body?.endTime ) {
-      scheduleEndTime = taskConfig.dueTime;
-      req.body.days = taskConfig?.dueDay || 0;
+      scheduleEndTime = taskConfig?.dueTime || '11:59 PM';
+      req.body.days = taskConfig?.dueDay || 1;
       req.body.geoFencing = taskConfig?.allowedStoreLocation || false;
     }
     if ( req.body?.endTime ) {
@@ -242,15 +242,14 @@ export async function createTask( req, res ) {
             let taskData = { ...data };
             if ( floorDetails.length > 1 ) {
               taskData.checkListName = taskData.checkListName +' - '+ floorDetails[i].floorName;
-              taskData.floorId = floorDetails[i]._id;
             }
+            taskData.floorId = floorDetails[i]._id;
             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;
-            console.log( taskData );
             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() };
@@ -533,8 +532,12 @@ export async function updateAnswers( req, res ) {
 }
 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 taskDetails = await processedService.findOne( { _id: new mongoose.Types.ObjectId( req.body.taskId ) } );
     console.log( taskDetails );
+    if ( !taskDetails ) {
+      return res.sendError( 'No data found', 204 );
+    }
+
     let data = {
       fixtureId: req.body.fixtureId,
       answers: req.body.answers,
@@ -543,9 +546,9 @@ export async function updateAnswersv2( req, res ) {
       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,
+      taskId: req.body.taskId,
+      storeName: req.body?.storeName,
+      storeId: req.body?.storeId,
     };
     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 );
@@ -729,11 +732,11 @@ export async function generatetaskDetails( req, res ) {
       },
       {
         $group: {
-          _id: '$planoId',
+          _id: '$storeName',
           count: { $sum: 1 },
-          storeName: { $first: '$storeName' },
+          planoId: { $last: '$planoId' },
           taskId: { $push: '$_id' },
-          checklistStatus: { $push: '$checklistStatus' },
+          checklistStatus: { $last: '$checklistStatus' },
           date_string: { $push: '$date_string' },
         },
       },
@@ -741,11 +744,11 @@ export async function generatetaskDetails( req, res ) {
         $project: {
           _id: 0,
           taskId: 1,
-          storeName: 1,
+          planoId: 1,
           checklistStatus: 1,
           count: 1,
           date_string: 1,
-          planoId: '$_id',
+          storeName: '$_id',
         },
       },
     ];
@@ -768,7 +771,7 @@ export async function generatetaskDetails( req, res ) {
     } ) );
 
     processedTaskDetails.forEach( ( item ) => {
-      let taskIndex = taskDetails.findIndex( ( taskItem ) => taskItem.checklistStatus.includes( 'submit' ) && taskItem.date_string.includes( item.date_string ) && item.planoId.toString() == taskItem.planoId.toString() );
+      let taskIndex = taskDetails.findIndex( ( taskItem ) => taskItem.checklistStatus =='submit' && taskItem.date_string.includes( item.date_string ) && item.planoId.toString() == taskItem.planoId.toString() );
       console.log( taskIndex, 'index' );
       if ( taskIndex != -1 ) {
         taskDetails[taskIndex].storeStatus = item.status == 'complete' ? 'yes' : 'No';

package/src/dtos/validation.dtos.js

@@ -201,6 +201,7 @@ export const updateTaskConfig = {
 export const uploadBrandListSchema = joi.object( {
   clientId: joi.string().required(),
   brandData: joi.array().items( joi.any() ).min( 1 ).required(),
+  brandUsedList:joi.array().items(joi.any()).min(0)
 } );
 
 export const uploadBrandList = {

package/src/routes/managePlano.routes.js

@@ -13,4 +13,6 @@ managePlanoRouter
     .get( '/templateList', managePlanoController.templateList )
     .get( '/fixtureBrandsList', managePlanoController.fixtureBrandsList )
     .get( '/fixtureVMList', managePlanoController.fixtureVMList )
-    .post( '/updateFixtureStatus', isAllowedSessionHandler, managePlanoController.updateFixtureStatus );
+    .post( '/updateFixtureStatus', isAllowedSessionHandler, managePlanoController.updateFixtureStatus )
+    .post( '/updateStoreFixture', managePlanoController.updateStoreFixture )
+    .post( '/updateStoreFixture', managePlanoController.updateStoreFixture );

package/src/routes/storeBuilder.routes.js

@@ -46,5 +46,7 @@ storeBuilderRouter
     .post( '/qrScan', storeBuilderController.qrScan )
     .post( '/storeFixturesV2', validate( validateDtos.storeList ), storeBuilderController.storeFixturesv2 )
     .post( '/fixtureShelfDetailsv2', validate( validateDtos.fixtureShelfProduct ), storeBuilderController.fixtureShelfProductv2 )
-    .post( '/storeFixturesTaskv2', storeBuilderController.storeFixturesTaskv2 )
-;
+    .post( '/storeFixturesTaskv2', storeBuilderController.storeFixturesTaskv2 );
+
+storeBuilderRouter
+    .post( '/planoList', isAllowedSessionHandler, storeBuilderController.planoList );

package/src/service/fixtureConfig.service.js

@@ -42,3 +42,7 @@ export async function deleteOne( query = {} ) {
 export const findAndSort = async ( query={}, field={}, sort={} ) => {
   return await model.fixtureConfigModel.find( query, field ).sort( sort ).collation( { locale: 'en_US', numericOrdering: true } );
 };
+
+export const sortAndFindOne = async ( query={}, field={}, sort={} ) => {
+  return await model.fixtureConfigModel.find( query, field ).sort( sort ).limit( 1 );
+};

package/src/service/planoproductCategory.service.js

@@ -36,4 +36,12 @@ export const aggregate = async ( query=[] ) => {
   return await model.planoProductCategoryModel.aggregate( query );
 };
 
+export async function upsertOne( query, record ) {
+  return model.planoProductCategoryModel.findOneAndUpdate(
+      query,
+      record,
+      { upsert: true, new: true },
+  );
+}
+