tango-app-api-client 3.6.5-vms.11 → 3.6.5-vms.13

package/index.js

@@ -2,7 +2,6 @@
 
 import { clientRouter } from './src/routes/client.routes.js';
 import { clientDocs } from './src/docs/client.docs.js';
-import { vmsauditRouter } from './src/routes/vmsAudit.routes.js';
 
-export { clientRouter, clientDocs, vmsauditRouter };
+export { clientRouter, clientDocs };
 

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "tango-app-api-client",
-  "version": "3.6.5-vms.11",
+  "version": "3.6.5-vms.13",
   "description": "client",
   "main": "index.js",
-  "type": "module", 
+  "type": "module",
   "scripts": {
-    "start": "nodemon --exec \"eslint --fix . && node index.js\"",
+    "start": "nodemon --exec \"eslint --fix . && node app.js\"",
     "build:patch": "node build.js patch && npm publish",
     "build:minor": "node build.js minor && npm publish",
     "build:major": "node build.js major && npm publish"
@@ -31,7 +31,7 @@
     "npm": "^10.9.1",
     "sharp": "^0.34.3",
     "swagger-ui-express": "^5.0.0",
-    "tango-api-schema": "^2.4.27",
+    "tango-api-schema": "^2.5.2",
     "tango-app-api-middleware": "^3.6.0",
     "winston": "^3.11.0",
     "winston-daily-rotate-file": "^5.0.0"

package/src/controllers/client.controllers.js

@@ -2967,10 +2967,89 @@ export async function updateFDConfig( req, res ) {
 export async function getFDConfig( req, res ) {
   try {
     const inputData = req.query;
-    let result = await findOneClient( { clientId: inputData.clientId }, { footfallDirectoryConfigs: 1 } );
-    if ( result===null ) {
+    // let result = await findOneClient( { clientId: inputData.clientId }, { footfallDirectoryConfigs: 1 } );
+    const configQuery = [
+      {
+        $match: {
+          clientId: inputData?.clientId,
+        },
+      },
+
+      // Convert all effectiveFrom to proper Date
+      {
+        $addFields: {
+          taggingLimitationWithDate: {
+            $map: {
+              input: '$footfallDirectoryConfigs.taggingLimitation',
+              as: 'item',
+              in: {
+                effectiveFrom: { $toDate: '$$item.effectiveFrom' },
+                values: '$$item.values',
+              },
+            },
+          },
+        },
+      },
+
+      // Filter items <= input date
+      {
+        $addFields: {
+          matchedLimitation: {
+            $filter: {
+              input: '$taggingLimitationWithDate',
+              as: 'item',
+              cond: {
+                $lte: [
+                  '$$item.effectiveFrom',
+                  { $toDate: inputData.dateString },
+                ],
+              },
+            },
+          },
+        },
+      },
+
+      // Sort DESC and pick ONLY top 1 -> latest effective record
+      {
+        $addFields: {
+          effectiveLimitation: {
+            $arrayElemAt: [
+              {
+                $slice: [
+                  {
+                    $sortArray: {
+                      input: '$matchedLimitation',
+                      sortBy: { effectiveFrom: -1 },
+                    },
+                  },
+                  1,
+                ],
+              },
+              0,
+            ],
+          },
+        },
+      },
+
+      {
+        $project: {
+          'config': 1,
+          'effectiveLimitation': 1,
+          'footfallDirectoryConfigs': 1,
+
+        },
+      },
+    ];
+
+
+    const getData = await aggregateClient( configQuery );
+    let result = getData[0];
+    if ( !result || result===null ) {
       return res.sendError( 'no data found', 204 );
     }
+    result.footfallDirectoryConfigs.taggingLimitation = result?.effectiveLimitation?.values;
+    delete result.effectiveLimitation;
+
     return res.sendSuccess( result );
   } catch ( error ) {
     const err = error.message || 'Internal Server Error';
@@ -2983,38 +3062,38 @@ export async function getFDConfig( req, res ) {
 export async function updateTaggingType( req, res ) {
   try {
     const inputData = req.body;
-
-    const inputQuery = req.query; // up
-    const types = inputData?.taggingLimitation?.map( ( x ) => x.type );
-    // Step 1: remove existing items with same "type"
-    await clientModel.updateOne(
-        { clientId: inputQuery.clientId },
+    const newValues = inputData.taggingLimitation;
+    const today = new Date().toISOString().split( 'T' )[0];
+    logger.info( { today, newValues } );
+    const result = await clientModel.updateOne(
         {
-          $pull: {
-            'footfallDirectoryConfigs.taggingLimitation': {
-              type: { $in: types },
-            },
-          },
+          'clientId': inputData?.clientId,
+          'footfallDirectoryConfigs.taggingLimitation.effectiveFrom': today,
         },
-    );
-
-    // Remove duplicate entries by type
-    const uniqueData = uniqueByType( inputData.taggingLimitation );
-
-    // Step 2: insert fresh new items
-    let result =await clientModel.updateOne(
-        { clientId: inputQuery.clientId },
         {
-          $addToSet: {
-            'footfallDirectoryConfigs.taggingLimitation': {
-              $each: uniqueData,
-            },
+          $set: {
+            'footfallDirectoryConfigs.taggingLimitation.$.values': newValues,
           },
         },
     );
+    logger.info( { result } );
+    if ( result?.matchedCount === 0 ) {
+      await clientModel.updateOne(
+          { clientId: inputData.clientId },
+          {
+            $push: {
+              'footfallDirectoryConfigs.taggingLimitation': {
+                effectiveFrom: today,
+                values: newValues,
+              },
+            },
+          },
+      );
+    }
+
 
     if ( result?.acknowledged === true ) {
-      return res.sendSuccess( result );
+      return res.sendSuccess( 'Tagging limitation has been updated' );
     } else {
       return res.sendError( 'no data', 204 );
     }
@@ -3025,14 +3104,14 @@ export async function updateTaggingType( req, res ) {
   }
 }
 
-function uniqueByType( arr ) {
-  const seen = new Set();
-  return arr.filter( ( item ) => {
-    if ( seen.has( item.type ) ) return false;
-    seen.add( item.type );
-    return true;
-  } );
-}
+// function uniqueByType( arr ) {
+//   const seen = new Set();
+//   return arr.filter( ( item ) => {
+//     if ( seen.has( item.type ) ) return false;
+//     seen.add( item.type );
+//     return true;
+//   } );
+// }
 
 export async function createStoreRequest( req, res ) {
   try {

package/src/dtos/client.dtos.js

@@ -377,8 +377,12 @@ export const updateFDConfigQuerySchema = joi.object( {
   clientId: joi.string().required(),
 } );
 
+
+const todayDate = () => new Date().toISOString().split( 'T' )[0];
+
 export const getFDConfigSchema = joi.object( {
   clientId: joi.string().required(),
+  dateString: joi.string().optional().default( () => todayDate() ),
 } );
 
 export const updateFDConfigValid = {
@@ -395,6 +399,9 @@ export const updateTaggingTypeSchema = joi.object( {
     type: joi.string().required(),
     value: joi.number().required(),
     unit: joi.string().required(),
+    name: joi.string().required(),
+    iconName: joi.string().required(),
+    key: joi.string().required(),
   } ) ).required(),
 
 } );