tango-app-api-store-builder 1.0.31 → 1.0.33

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "tango-app-api-store-builder",
-    "version": "1.0.31",
+    "version": "1.0.33",
     "description": "storeBuilder",
     "main": "index.js",
     "type": "module",
@@ -32,7 +32,7 @@
         "path": "^0.12.7",
         "selenium-webdriver": "^4.31.0",
         "sharp": "^0.34.1",
-        "tango-api-schema": "^2.5.17",
+        "tango-api-schema": "^2.5.23",
         "tango-app-api-middleware": "3.1.48",
         "url": "^0.11.4",
         "winston": "^3.17.0",

package/src/controllers/fixtureTemplate.controller.js

@@ -690,6 +690,8 @@ export async function TemplateStoresList( req, res ) {
         storeName: 1,
         planoId: 1,
         floorId: 1,
+        isMerchEdited: 1,
+        isVmEdited: 1,
       },
     },
     {
@@ -699,6 +701,8 @@ export async function TemplateStoresList( req, res ) {
         planoId: { $first: '$planoId' },
         storeId: { $first: '$storeId' },
         floorId: { $first: '$floorId' },
+        isMerchEdited: { $push: '$isMerchEdited' },
+        isVmEdited: { $push: '$isVmEdited' },
       },
     },
     {
@@ -758,6 +762,8 @@ export async function TemplateStoresList( req, res ) {
               spocEmail: { $ifNull: [ '$storeData.spocDetails.email', '' ] },
               floorDetails: 1,
               _id: '$_id.store',
+              isMerchEdited: 1,
+              isVmEdited: 1,
             },
           },
       );
@@ -818,6 +824,335 @@ export async function TemplateStoresList( req, res ) {
       );
     }
 
+    query.push(
+        {
+          $lookup: {
+            from: 'processedtasks',
+            let: { store: '$storeId' },
+            pipeline: [
+              {
+                $match: {
+                  $expr: {
+                    $and: [
+                      { $lte: [ '$date_iso', new Date( dayjs().format( 'YYYY-MM-DD' ) ) ] },
+                      { $eq: [ '$store_id', '$$store' ] },
+                      { $eq: [ '$isPlano', true ] },
+                      { $in: [ '$planoType', [ 'merchRollout', 'vmRollout' ] ] },
+                    ],
+                  },
+                },
+              },
+              {
+                $sort: { _id: -1 },
+              },
+              {
+                $group: {
+                  _id: '$planoType',
+                  type: { $first: '$planoType' },
+                  status: { $first: '$checklistStatus' },
+                  taskId: { $first: '$_id' },
+                  scheduleEndTime_iso: { $first: '$scheduleEndTime_iso' },
+                },
+              },
+              {
+                $project: {
+                  _id: 0,
+                  type: 1,
+                  status: 1,
+                  taskId: 1,
+                  breach: {
+                    $cond: {
+                      if: {
+                        $gte: [ '$scheduleEndTime_iso', new Date() ],
+                      },
+                      then: false,
+                      else: true,
+                    },
+                  },
+                },
+              },
+            ],
+            as: 'taskDetails',
+          },
+        },
+        {
+          $lookup: {
+            from: 'planotaskcompliances',
+            let: { taskId: '$taskDetails.taskId' },
+            pipeline: [
+              {
+                $match: {
+                  $expr: {
+                    $and: [
+                      { $in: [ '$taskId', '$$taskId' ] },
+                      { $in: [ '$type', [ 'merchRollout', 'vmRollout' ] ] },
+                      // { $eq: [ '$status', 'incomplete' ] },
+                    ],
+                  },
+                },
+              },
+              {
+                $sort: { _id: -1 },
+              },
+              {
+                $set: {
+                  hasCompletedAnswers: {
+                    $anyElementTrue: {
+                      $map: {
+                        input: '$answers',
+                        as: 'ans',
+                        in: { $eq: [ '$$ans.status', null ] },
+                      },
+                    },
+                  },
+                  hasPendingIssues: {
+                    $anyElementTrue: {
+                      $map: {
+                        input: {
+                          $concatArrays: [
+                            {
+                              $reduce: {
+                                input: '$answers',
+                                initialValue: [],
+                                in: {
+                                  $concatArrays: [
+                                    '$$value',
+                                    {
+                                      $reduce: {
+                                        input: { $ifNull: [ '$$this.issues', [] ] },
+                                        initialValue: [],
+                                        in: {
+                                          $concatArrays: [
+                                            '$$value',
+                                            { $ifNull: [ '$$this.Details', [] ] },
+                                          ],
+                                        },
+                                      },
+                                    },
+                                  ],
+                                },
+                              },
+                            },
+                          ],
+                        },
+                        as: 'detail',
+                        in: {
+                          $or: [ { $eq: [ '$$detail.status', 'pending' ] } ],
+                        },
+                      },
+                    },
+                  },
+                  hasDisagreeIssues: {
+                    $anyElementTrue: {
+                      $map: {
+                        input: {
+                          $concatArrays: [
+                            '$answers',
+                            {
+                              $reduce: {
+                                input: '$answers',
+                                initialValue: [],
+                                in: {
+                                  $concatArrays: [
+                                    '$$value',
+                                    {
+                                      $reduce: {
+                                        input: { $ifNull: [ '$$this.issues', [] ] },
+                                        initialValue: [],
+                                        in: {
+                                          $concatArrays: [
+                                            '$$value',
+                                            { $ifNull: [ '$$this.Details', [] ] },
+                                          ],
+                                        },
+                                      },
+                                    },
+                                  ],
+                                },
+                              },
+                            },
+                          ],
+                        },
+                        as: 'detail',
+                        in: {
+                          $or: [ { $eq: [ '$$detail.status', 'disagree' ] } ],
+                        },
+                      },
+                    },
+                  },
+                },
+              },
+              {
+                $group: {
+                  _id: { taskId: '$taskId' },
+
+                  // merch counters
+                  merchDisagree: {
+                    $sum: {
+                      $cond: [
+                        { $and: [ { $eq: [ '$type', 'merchRollout' ] }, '$hasDisagreeIssues' ] },
+                        1,
+                        0,
+                      ],
+                    },
+                  },
+                  merchPending: {
+                    $sum: {
+                      $cond: [
+                        {
+                          $and: [
+                            { $eq: [ '$type', 'merchRollout' ] },
+                            { $or: [ '$hasPendingIssues', '$hasCompletedAnswers' ] },
+                          ],
+                        },
+                        1,
+                        0,
+                      ],
+                    },
+                  },
+                  merchApproved: {
+                    $push: {
+                      $cond: [
+                        {
+                          $and: [
+                            { $eq: [ '$type', 'merchRollout' ] },
+                            { $eq: [ '$approvalStatus', 'approved' ] },
+                          ],
+                        },
+                        '$approvalStatus',
+                        '$$REMOVE',
+                      ],
+                    },
+                  },
+
+                  // vm counters
+                  vmDisagree: {
+                    $sum: {
+                      $cond: [
+                        { $and: [ { $eq: [ '$type', 'vmRollout' ] }, '$hasDisagreeIssues' ] },
+                        1,
+                        0,
+                      ],
+                    },
+                  },
+                  vmPending: {
+                    $sum: {
+                      $cond: [
+                        {
+                          $and: [
+                            { $eq: [ '$type', 'vmRollout' ] },
+                            { $or: [ '$hasPendingIssues', '$hasCompletedAnswers' ] },
+                          ],
+                        },
+                        1,
+                        0,
+                      ],
+                    },
+                  },
+                  vmApproved: {
+                    $push: {
+                      $cond: [
+                        {
+                          $and: [
+                            { $eq: [ '$type', 'vmRollout' ] },
+                            { $eq: [ '$approvalStatus', 'approved' ] },
+                          ],
+                        },
+                        '$approvalStatus',
+                        '$$REMOVE',
+                      ],
+                    },
+                  },
+
+                  // counts
+                  merchCount: {
+                    $sum: {
+                      $cond: [ { $eq: [ '$type', 'merchRollout' ] }, 1, 0 ],
+                    },
+                  },
+                  vmCount: {
+                    $sum: {
+                      $cond: [ { $eq: [ '$type', 'vmRollout' ] }, 1, 0 ],
+                    },
+                  },
+                },
+              },
+              {
+                $project: {
+                  _id: 0,
+                  fixtureStatus: {
+                    $switch: {
+                      branches: [
+                        {
+                          case: { $eq: [ '$merchCount', 0 ] },
+                          then: '',
+                        },
+                        {
+                          case: { $gt: [ '$merchPending', 0 ] },
+                          then: 'pending',
+                        },
+                        {
+                          case: { $gt: [ '$merchDisagree', 0 ] },
+                          then: 'disagree',
+                        },
+                        {
+                          case: {
+                            $and: [
+                              { $eq: [ '$merchPending', 0 ] },
+                              { $eq: [ '$merchDisagree', 0 ] },
+                              { $eq: [ { $size: '$merchApproved' }, '$merchCount' ] },
+                            ],
+                          },
+                          then: 'complete',
+                        },
+                      ],
+                      default: 'pending',
+                    },
+                  },
+                  vmStatus: {
+                    $switch: {
+                      branches: [
+                        {
+                          case: { $eq: [ '$vmCount', 0 ] },
+                          then: '',
+                        },
+                        {
+                          case: { $gt: [ '$vmPending', 0 ] },
+                          then: 'pending',
+                        },
+                        {
+                          case: { $gt: [ '$vmDisagree', 0 ] },
+                          then: 'disagree',
+                        },
+                        {
+                          case: {
+                            $and: [
+                              { $eq: [ '$vmPending', 0 ] },
+                              { $eq: [ '$vmDisagree', 0 ] },
+                              { $eq: [ { $size: '$vmApproved' }, '$vmCount' ] },
+                            ],
+                          },
+                          then: 'complete',
+                        },
+                      ],
+                      default: 'pending',
+                    },
+                  },
+                },
+              },
+            ],
+            as: 'taskFeedback',
+          },
+        },
+        {
+          $set: {
+            taskFeedback: {
+              $ifNull: [ { $arrayElemAt: [ '$taskFeedback', 0 ] }, {} ],
+            },
+          },
+        },
+    );
+
     let floorQuery = [
       {
         $match: {
@@ -873,6 +1208,10 @@ export async function replaceFixtureDetails( req, res ) {
     if ( !replaceFixtureData ) {
       return res.sendError( 'No data found', 204 );
     }
+
+    if ( inputData?.revoke && inputData?.assignedStores?.length ) {
+      await processedTaskService.deleteMany( { storeName: { $in: inputData?.assignedStores }, isPlano: true, planoType: { $nin: [ 'layout', 'fixture' ] }, checklistStatus: { $ne: 'submit' } } );
+    }
     if ( inputData.storeList.length == 0 && inputData.publishAll ) {
       await fixtureConfigService.updateOne( { _id: inputData.replaceFixture }, { isEdited: false } );
       let query = [

package/src/controllers/managePlano.controller.js

@@ -1,6 +1,6 @@
 import * as floorService from '../service/storeBuilder.service.js';
-import { logger, insertOpenSearchData, getOpenSearchData, updateOpenSearchData, getOpenSearchById } from 'tango-app-api-middleware';
-// import * as storeService from '../service/store.service.js';
+import { logger, insertOpenSearchData, getOpenSearchData, updateOpenSearchData, getOpenSearchById, fileUpload } from 'tango-app-api-middleware';
+import * as storeService from '../service/store.service.js';
 import * as planoService from '../service/planogram.service.js';
 import * as storeFixtureService from '../service/storeFixture.service.js';
 import * as fixtureShelfService from '../service/fixtureShelf.service.js';
@@ -1372,7 +1372,7 @@ export async function updateStoreFixture( req, res ) {
           };
           vmDetails = await planoVmService.create( planovmData );
         }
-        vmConfig.push( { ...vm, vmId: vmDetails._id, vmName: vmDetails.vmName, vmImage: vmDetails.vmImageUrl } );
+        vmConfig.push({ ...vm, vmId: vmDetails._id, vmName: vmDetails.vmName, vmImage: vmDetails.vmImageUrl });
       }
       data.vmConfig = vmConfig;
       let groupName = {
@@ -1826,9 +1826,9 @@ export async function createPlanoRevision( req, res ) {
     await planoRevisionService.create( data );
 
     await storeBuilderService.updateOne( { _id: floorId },
-        { ...( req.body.type == 'merchRollout' ) ? { merchRolloutStatus: true } :{},
-          ...( req.body.type == 'vmRollout' ) ? { vmRolloutStatus: true } : {},
-          ...( ![ 'merchRollout', 'vmRollout' ].includes( req.body.type ) && { verificationStatus: true } ), planoProgress: 100 } );
+        { ...( req.body.type.includes( 'merchRollout' ) ) ? { merchRolloutStatus: true } :{},
+          ...( req.body.type.includes( 'vmRollout' ) ) ? { vmRolloutStatus: true } : {},
+          ...( !req.body?.type && { verificationStatus: true } ), planoProgress: 100 } );
 
     res.sendSuccess( 'Plano published successfully' );
   } catch ( e ) {
@@ -2363,3 +2363,261 @@ export async function getPlanoStoreVideoPageParams( req, res ) {
     res.sendError( 'Failed to fetch plano store video page params', 500 );
   }
 }
+
+export async function createPlanoFromCAD(req, res) {
+  try {
+    const user = req.user;
+    const file = req.files.file;
+    const { storeId, floorNumber } = req.body;
+
+    if (!req?.files?.file) return res.sendError('File is required', 400);
+
+    if (!storeId || !floorNumber) return res.sendError('storeId and floorNumber are required', 400);
+
+    if (!file.name.endsWith('.dxf')) return res.sendError('Only DXF files are allowed', 400);
+
+
+    // if (file.size > 20 * 1024 * 1024) {
+    //   return res.sendError('File size exceeds 20MB limit', 400);
+    // }
+
+    // File Upload
+    const fileUploadPayload = {
+      Bucket: JSON.parse(process.env.BUCKET).storeBuilder,
+      Key: `planoCad/`,
+      fileName: Date.now() + '.' + file.name?.split('.')?.slice(-1)?.[0],
+      ContentType: file.mimetype,
+      body: file.data,
+    };
+
+    const fileRes = await fileUpload(fileUploadPayload);
+
+    if (!fileRes?.Key) return res.sendError('Failed to upload file to storage', 502);
+
+    // CAD Extraction
+    const dataExtractPayload = {
+      s3Bucket: fileUploadPayload.Bucket,
+      filePath: fileRes.Key,
+    };
+
+    const cadRes = await fetch(
+      JSON.parse(process.env.LAMBDAURL).extractCADDetails,
+      {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(dataExtractPayload),
+      }
+    );
+
+    if (!cadRes.ok) {
+      const errorText = await cadRes.text();
+      logger.error({ cadLambdaError: errorText });
+      return res.sendError('CAD extraction service failed', 502);
+    }
+
+    const cadData = await cadRes.json();
+
+    logger.info({
+      functionName: 'CAD DATA: ',
+      body: { cadData, input: dataExtractPayload },
+    });
+
+    if (
+      cadData?.status !== 'success' ||
+      !cadData?.data?.layoutPolygon
+    ) {
+      return res.sendError('Invalid CAD layout data', 502);
+    }
+
+    const userMeta = {
+      createdBy: user._id,
+      createdByEmail: user.email,
+      createdByName: user.userName,
+    }
+
+    // PLANOGRAM
+    let planoData = await planoService.findOne({ storeId }, { _id: 1, clientId: 1, storeName: 1, });
+
+    if (!planoData) {
+      const storeData = await storeService.findOne({ storeId }, { clientId: 1, storeName: 1 });
+      if (!storeData) return res.sendError('Unable to find the store to create planogram', 400);
+
+      const newPlano = {
+        clientId: storeData.clientId,
+        storeName: storeData.storeName,
+        storeId,
+        layoutName: `${storeData.storeName} - Layout`,
+        attachments: [],
+        status: 'completed',
+        productResolutionLevel: 'L2',
+        scanType: 'qr',
+        planoStrategy: "nonIvm",
+        ...userMeta
+      };
+
+      planoData = await planoService.create(newPlano);
+      if (!planoData) return res.sendError('Failed to create new planogram', 400);
+    }
+
+    const floorPayload = {
+      layoutPolygon: processWallData(cadData.data.layoutPolygon),
+      planoProgress: 25,
+      floorName: `Floor ${floorNumber}`,
+      isEdited: false,
+      cadLayout: true
+    };
+
+    let floorData = await floorService.findOne({ planoId: planoData._id, floorNumber }, { _id: 1, clientId: 1, storeName: 1, storeId: 1, planoId: 1 });
+    if (floorData) {
+      await floorService.updateOne({ _id: floorData._id }, { ...floorPayload, updatedBy: user._id });
+    } else {
+      const newFloor = {
+        clientId: planoData.clientId,
+        planoId: planoData._id,
+        layoutName: `${planoData.storeName} - Layout`,
+        status: 'completed',
+        storeName: planoData.storeName,
+        floorNumber,
+        storeId,
+        ...floorPayload,
+        ...userMeta,
+      };
+
+      floorData = await floorService.create(newFloor);
+      if (!floorData) return res.sendError('Failed to create new floor layout', 400);
+    }
+
+    const meta = {
+      clientId: floorData.clientId,
+      storeName: floorData.storeName,
+      storeId: floorData.storeId,
+      planoId: floorData.planoId,
+      floorId: floorData._id,
+    }
+
+    // Create Fixtures
+    const processedFixtures = createStoreFixtures(cadData.data, meta);
+
+    try {
+      await storeFixtureService.deleteMany({ floorId: meta.floorId });
+      await fixtureShelfService.deleteMany({ floorId: meta.floorId });
+      for (let i = 0; i < processedFixtures.length; i++) {
+        const fix = processedFixtures[i];
+        await storeFixtureService.create(fix);
+      }
+    } catch (e) {
+      logger.error({
+        functionName: 'createPlanoFromCAD [Create Fixtures]',
+        error: e,
+      });
+    }
+
+    return res.sendSuccess(meta);
+
+  } catch (error) {
+    logger.error({
+      functionName: 'createPlanoFromCAD',
+      error,
+    });
+
+    return res.sendError('Failed to create planogram.', 500);
+  }
+}
+
+function processWallData(cadRes) {
+  return cadRes.map((w) => {
+    return {
+      "elementType": w?.elementType ?? 'wall',
+      "distance": w?.distance ?? 16,
+      "elementNumber": w?.elementNumber ?? 0,
+      "unit": w?.unit ?? "ft",
+      "direction": w?.direction ?? "right",
+      "angle": w?.angle ?? 0,
+      "relativePosition": w?.relativePosition,
+    }
+  });
+}
+
+function createStoreFixtures(data, meta) {
+
+  let fixtures = [];
+  const walls = data?.layoutPolygon ?? [];
+  for (let i = 1; i <= walls.length; i++) {
+    const w = walls[i - 1];
+    const wFixtures = w?.fixtures ?? [];
+
+    for (let j = 1; j <= wFixtures.length; j++) {
+      const f = wFixtures[j - 1];
+
+      const fixtureInfo = {
+        f: f,
+        meta: meta,
+        wallNumber: w.elementNumber,
+        fixtureNumber: j,
+      }
+
+      fixtures.push(processFixtureData(fixtureInfo));
+    }
+  }
+
+  const centerFixtures = data?.centerFixture ?? [];
+  for (let i = 1; i <= centerFixtures.length; i++) {
+    const f = centerFixtures[i - 1];
+
+    const fixtureInfo = {
+      f: f,
+      meta: meta,
+      wallNumber: undefined,
+      fixtureNumber: i,
+    }
+
+    fixtures.push(processFixtureData(fixtureInfo));
+  }
+
+  return fixtures;
+}
+
+function processFixtureData(data) {
+  const f = data.f;
+
+  function normalizeCadText(value) {
+    if (typeof value !== 'string') return value;
+    return value.replace(/^\\[^;]+;/, '').trim();
+  }
+
+  return {
+    ...data.meta,
+    fixtureName: normalizeCadText(f?.header?.label ?? ''),
+    relativePosition: f?.relativePosition,
+    fixtureType: f?.associatedElementType,
+    header: {
+      ...f?.header,
+      label: normalizeCadText(f?.header?.label ?? '')
+    },
+    footer: f?.footer,
+    fixtureWidth: f?.fixtureWidth,
+    fixtureLength: f?.fixtureLength,
+    fixtureNumber: f?.fixtureNumber,
+    associatedElementNumber: data?.wallNumber,
+    associatedElementFixtureNumber: data.fixtureNumber,
+    associatedElementType: f?.associatedElementType === 'wall' ? 'wall' : undefined,
+    productBrandName: Array.isArray(f?.productBrandName) ? f?.productBrandName?.map(normalizeCadText) : normalizeCadText(f?.productBrandName),
+
+    fixtureHeight: {
+      value: 0,
+      unit: 'mm',
+    },
+    fixtureStaticLength: {
+      value: 1524,
+      unit: 'mm',
+    },
+    fixtureStaticWidth: {
+      value: 1220,
+      unit: 'mm',
+    },
+    productResolutionLevel: 'L2',
+    isBodyEnabled: true,
+    isMerchEdited: false,
+    isVmEdited: false,
+  };
+}

package/src/controllers/script.controller.js

@@ -9573,8 +9573,8 @@ export async function productMappings( req, res ) {
 
     const { fixtureId, Top, Mid, Bottom } = payload;
 
-    const storeName = 'LKST11';
-    const storeId = '11-259';
+    const storeName = 'LKST2681';
+    const storeId = '11-2362';
     const clientId = '11';
 
     if ( !fixtureId ) {