tango-app-api-store-builder 1.0.0-beta-70 → 1.0.0-beta-72

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "tango-app-api-store-builder",
-    "version": "1.0.0-beta-70",
+    "version": "1.0.0-beta-72",
     "description": "storeBuilder",
     "main": "index.js",
     "type": "module",
@@ -21,9 +21,10 @@
         "express-fileupload": "^1.5.1",
         "handlebars": "^4.7.8",
         "joi": "^17.13.3",
+        "jszip": "^3.10.1",
         "mongodb": "^6.12.0",
         "nodemon": "^3.1.9",
-        "tango-api-schema": "^2.2.77",
+        "tango-api-schema": "^2.2.94",
         "tango-app-api-middleware": "^3.1.48",
         "winston": "^3.17.0",
         "winston-daily-rotate-file": "^5.0.0",

package/src/controllers/script.controller.js

@@ -14,6 +14,8 @@ import * as planoTaskService from '../service/planoTask.service.js';
 // import * as planoQrConversionRequestService from '../service/planoQrConversionRequest.service.js';
 import * as fixtureConfigService from '../service/fixtureConfig.service.js';
 import mongoose from 'mongoose';
+import JSZip from 'jszip';
+
 
 export async function getStoreNames( req, res ) {
   try {
@@ -1774,3 +1776,200 @@ export async function getProdTaskData( req, res ) {
     return res.sendError( e.message || 'Internal Server Error', 500 );
   }
 }
+
+export async function updatelayoutFeedback( req, res ) {
+  try {
+    if ( req?.headers?.authorization?.split( ' ' )[1] !== 'hwjXfCD6TgMvc82cuSGZ9bNv9MuXsaiQ6uvx' ) {
+      return res.sendError( 'Unauthorized', 401 );
+    }
+    const layoutFeedbacks = await planoTaskService.find( { type: 'layout' } );
+
+    for ( let i = 0; i < layoutFeedbacks.length; i++ ) {
+      const layoutDoc = layoutFeedbacks[i].toObject();
+
+      const [ q1, q2, q3 ] = layoutDoc.answers;
+
+      if ( q1.value === false ) {
+        const floor = await storeBuilderService.findOne( { _id: layoutDoc.floorId } );
+
+        const floorDoc = floor.toObject();
+
+        const fixtures = await storeFixtureService.find( { floorId: floorDoc._id } );
+
+        const constantFixtureLength = 1220;
+        const constantDetailedFixtureLength = 1220;
+
+        const constantFixtureWidth = 610;
+        const constantDetailedFixtureWidth = 1524;
+
+        const mmToFeet = 305;
+
+
+        function roundToTwo( num ) {
+          return Math.round( num * 100 ) / 100;
+        }
+
+        const leftFixtures = fixtures.filter( ( fixture ) => fixture.toObject().associatedElementType === 'wall' && fixture.toObject().associatedElementNumber === 1 && fixture.toObject().fixtureType === 'wall' );
+        const rightFixtures = fixtures.filter( ( fixture ) => fixture.toObject().associatedElementType === 'wall' && fixture.toObject().associatedElementNumber === 3 && fixture.toObject().fixtureType === 'wall' );
+        const floorFixtures = fixtures.filter( ( fixture ) => fixture.toObject().fixtureType === 'floor' );
+        const backFixtures = fixtures.filter( ( fixture ) => fixture.toObject().associatedElementType === 'wall' && fixture.toObject().associatedElementNumber === 2 && fixture.toObject().fixtureType === 'wall' );
+
+        q2.correctedFixture.forEach( ( cf ) => {
+          switch ( cf.alignment ) {
+            case 'Wall 1':
+              leftFixtures.push( {} );
+              break;
+            case 'Wall 2':
+              backFixtures.push( {} );
+              break;
+            case 'Wall 3':
+              rightFixtures.push( {} );
+              break;
+
+            default:
+              break;
+          }
+        } );
+
+
+        const leftXDistanceFeet = leftFixtures.length ? roundToTwo( ( leftFixtures.length * ( constantFixtureLength / mmToFeet ) ) ) : 0;
+        const leftXDetailedDistanceFeet = leftFixtures.length ? roundToTwo( ( leftFixtures.length * ( constantDetailedFixtureLength / mmToFeet ) ) ) : 0;
+
+        const leftYDistanceFeet = leftFixtures.length ? roundToTwo( ( ( constantFixtureWidth / mmToFeet ) ) ) : 0;
+        const leftYDetailedDistanceFeet = leftFixtures.length ? roundToTwo( ( ( constantDetailedFixtureWidth / mmToFeet ) ) ) : 0;
+
+        const rightXDistanceFeet = rightFixtures.length ? roundToTwo( ( rightFixtures.length * ( constantFixtureLength / mmToFeet ) ) ) : 0;
+        const rightXDetailedDistanceFeet = rightFixtures.length ? roundToTwo( ( rightFixtures.length * ( constantDetailedFixtureLength / mmToFeet ) ) ) : 0;
+
+        const rightYDistanceFeet = rightFixtures.length ? roundToTwo( ( constantFixtureWidth / mmToFeet ) ) : 0;
+        const rightYDetailedDistanceFeet = rightFixtures.length ? roundToTwo( ( constantDetailedFixtureWidth / mmToFeet ) ): 0;
+
+        const maxFixturesPerRow = floorFixtures.length > 4 ? 3 : 2;
+        const totalRows = Math.ceil( floorFixtures.length / maxFixturesPerRow );
+        const floorXDistanceFeet = floorFixtures.length ? roundToTwo( ( maxFixturesPerRow * ( constantFixtureLength / mmToFeet ) ) ) : 0;
+        const floorXDetailedDistanceFeet = floorFixtures.length ? roundToTwo( ( maxFixturesPerRow * ( constantDetailedFixtureLength / mmToFeet ) ) ): 0;
+
+        const floorYDistanceFeet = floorFixtures.length ? roundToTwo( ( totalRows * ( constantFixtureWidth/ mmToFeet ) ) ): 0;
+        const floorYDetailedDistanceFeet = floorFixtures.length ? roundToTwo( totalRows * ( constantDetailedFixtureWidth/mmToFeet ) ): 0;
+
+        const backXDistanceFeet = backFixtures.length ? roundToTwo( ( constantFixtureWidth / mmToFeet ) ) : 0;
+        const backXDetailedDistanceFeet = backFixtures.length ? roundToTwo( ( constantDetailedFixtureLength / mmToFeet ) ) : 0;
+
+        const backYDistanceFeet = backFixtures.length ? roundToTwo( ( ( backFixtures.length * ( constantFixtureLength / mmToFeet ) ) + ( ( ( leftFixtures.length ? 1 : 0 ) + ( rightFixtures.length ? 1 : 0 ) * constantFixtureWidth )/mmToFeet ) ) ) : 0;
+        const backYDetailedDistanceFeet = backFixtures.length ? roundToTwo( ( ( backFixtures.length * ( constantDetailedFixtureWidth / mmToFeet ) ) + ( ( ( leftFixtures.length ? 1 : 0 ) + ( rightFixtures.length ? 1 : 0 ) * constantDetailedFixtureWidth )/mmToFeet ) ) ): 0;
+
+        const maxXDistance = Math.max( leftXDistanceFeet, rightXDistanceFeet, floorXDistanceFeet );
+        const maxXDetailedDistance = Math.max( leftXDetailedDistanceFeet, rightXDetailedDistanceFeet, floorXDetailedDistanceFeet );
+
+        const maxYDistance = Math.max( floorYDistanceFeet, backYDistanceFeet );
+        const maxYDetailedDistance = Math.max( floorYDetailedDistanceFeet, backYDetailedDistanceFeet );
+
+
+        const finalXDistance = maxXDistance < ( backXDistanceFeet + floorXDistanceFeet )? ( ( backXDistanceFeet + floorXDistanceFeet ) + ( ( 2 * constantFixtureLength )/mmToFeet ) ) : ( floorFixtures.length && backFixtures.length ) ? ( maxXDistance + ( ( 2 * constantFixtureLength )/mmToFeet ) ) : maxXDistance;
+        const finalXDetailedDistance = maxXDetailedDistance < ( backXDetailedDistanceFeet + floorXDetailedDistanceFeet )? ( ( backXDetailedDistanceFeet + floorXDetailedDistanceFeet ) + ( ( 2 * constantDetailedFixtureLength )/mmToFeet ) ) : ( floorFixtures.length && backFixtures.length ) ? ( maxXDetailedDistance + ( ( 2 * constantDetailedFixtureLength )/mmToFeet ) ) : maxXDetailedDistance;
+
+        const finalYDistance = maxYDistance < ( leftYDistanceFeet + rightYDistanceFeet + floorYDistanceFeet ) ? ( ( leftYDistanceFeet + rightYDistanceFeet + floorYDistanceFeet ) + ( ( 2 * constantFixtureWidth )/mmToFeet ) ) : ( maxYDistance + ( ( constantFixtureWidth )/mmToFeet ) );
+        const finalYDetailedDistance = maxYDetailedDistance < ( leftYDetailedDistanceFeet + rightYDetailedDistanceFeet + floorYDetailedDistanceFeet ) ? ( ( leftYDetailedDistanceFeet + rightYDetailedDistanceFeet + floorYDetailedDistanceFeet ) + ( ( 2 * constantDetailedFixtureWidth )/mmToFeet ) ) : ( maxYDetailedDistance + ( ( constantDetailedFixtureWidth )/mmToFeet ) );
+
+        const layoutPolygon = [
+          {
+            elementType: 'wall',
+            distance: roundToTwo( finalXDistance ),
+            unit: 'ft',
+            direction: 'right',
+            angle: 90,
+            elementNumber: 1,
+            detailedDistance: roundToTwo( finalXDetailedDistance ),
+          },
+          {
+            elementType: 'wall',
+            distance: roundToTwo( finalYDistance ),
+            unit: 'ft',
+            direction: 'down',
+            angle: 90,
+            elementNumber: 2,
+            detailedDistance: roundToTwo( finalYDetailedDistance ),
+          },
+          {
+            elementType: 'wall',
+            distance: roundToTwo( finalXDistance ),
+            unit: 'ft',
+            direction: 'left',
+            angle: 90,
+            elementNumber: 3,
+            detailedDistance: roundToTwo( finalXDetailedDistance ),
+          },
+          {
+            elementType: 'wall',
+            distance: roundToTwo( ( ( finalYDistance * 40 ) / 100 ) ),
+            unit: 'ft',
+            direction: 'up',
+            angle: 90,
+            elementNumber: 4,
+            detailedDistance: roundToTwo( ( ( finalYDetailedDistance * 35 ) / 100 ) ),
+          },
+          {
+            elementType: 'entrance',
+            distance: roundToTwo( ( ( finalYDistance * 20 ) / 100 ) ),
+            unit: 'ft',
+            direction: 'up',
+            angle: 90,
+            elementNumber: 1,
+            detailedDistance: roundToTwo( ( ( finalYDetailedDistance * 30 ) / 100 ) ),
+          },
+          {
+            elementType: 'wall',
+            distance: roundToTwo( ( ( finalYDistance * 40 ) / 100 ) ),
+            unit: 'ft',
+            direction: 'up',
+            angle: 90,
+            elementNumber: 5,
+            detailedDistance: roundToTwo( ( ( finalYDetailedDistance * 35 ) / 100 ) ),
+          },
+        ];
+
+        await storeBuilderService.updateOne( { _id: floorDoc._id }, { layoutPolygon: layoutPolygon } );
+
+        console.log( layoutPolygon, floorDoc._id );
+      }
+    }
+  } catch ( e ) {
+    logger.error( { functionName: 'updatelayoutFeedback', error: e } );
+    return res.sendError( e.message || 'Internal Server Error', 500 );
+  }
+}
+
+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' ) {
+      return res.sendError( 'Unauthorized', 401 );
+    }
+
+    
+  } catch ( e ) {
+    logger.error( { functionName: 'updatelayoutFeedback', error: e } );
+    return res.sendError( e.message || 'Internal Server Error', 500 );
+  }
+}

package/src/controllers/storeBuilder.controller.js

@@ -14,7 +14,7 @@ import * as planoComplianceService from '../service/planoCompliance.service.js';
 import * as planoTaskComplianceService from '../service/planoTask.service.js';
 import * as planoQrConversionRequestService from '../service/planoQrConversionRequest.service.js';
 import * as fixtureConfigService from '../service/fixtureConfig.service.js';
-import * as planoStaticBrandCategoriesService from '../service/planoStaticBrandCategories.service.js';
+import * as planoStaticData from '../service/planoStaticData.service.js';
 
 
 import path from 'path';
@@ -395,7 +395,11 @@ export async function storeLayout( req, res ) {
 
     const storeLayout = await Promise.all(
         planograms.map( async ( planogram ) => {
-          const floors = await storeBuilderService.find( { planoId: planogram._id }, { floorName: 1, layoutPolygon: 1 } );
+          const floorList = await storeBuilderService.find( { planoId: planogram._id }, { floorName: 1, layoutPolygon: 1, crestLayout: true } );
+
+          const floors = floorList.map( ( floor ) => {
+            return floor.toObject();
+          } );
           return {
             ...planogram.toObject(),
             floors,
@@ -2433,6 +2437,61 @@ export const fixtureQrUpdate = async ( req, res ) => {
   }
 };
 
+export const fixtureQrUpdatev1 = async ( req, res ) => {
+  try {
+    const { fixtureId, date, productQr } = req.body;
+
+    const fixture = await storeFixtureService.findOne( { _id: new mongoose.Types.ObjectId( fixtureId ) }, { _id: 1 } );
+
+    if ( !fixture ) {
+      return res.sendError( { message: 'Invalid fixture Id' }, 400 );
+    }
+
+    const fixtureShelves = await fixtureShelfService.find( { fixtureId: new mongoose.Types.ObjectId( fixtureId ) } );
+
+    let productIndex = 0;
+
+    const complianceData = fixtureShelves.map( ( shelf ) => {
+      const shelfObj = shelf.toObject();
+      const products = shelfObj.shelfCapacity ?
+        Array.from( { length: shelfObj.shelfCapacity }, () => ( {
+          category: shelfObj.sectionName,
+          productIndex: productIndex++,
+          status: 'missing',
+        } ) ) :
+        [];
+
+      return { ...shelfObj, products };
+    } );
+
+    const productMap = new Map();
+    productQr.forEach( ( productCv, i ) => {
+      if ( productCv.parent_brand ) {
+        productMap.set( i, productCv );
+      }
+    } );
+
+    complianceData.forEach( ( shelf ) => {
+      shelf.products.forEach( ( product ) => {
+        const matchedProduct = productMap.get( product.productIndex );
+        if ( matchedProduct && product.category === matchedProduct.parent_brand ) {
+          Object.assign( product, { status: 'proper', barcode: matchedProduct.barcode } );
+        }
+      } );
+    } );
+
+    const currentDate = new Date( date );
+
+    await planoQrConversionRequestService.updateOne( { fixtureId: new mongoose.Types.ObjectId( fixtureId ), date: currentDate }, { status: 'data-received', receivedQr: productQr, processedData: complianceData } );
+
+    res.sendSuccess( complianceData );
+  } catch ( error ) {
+    logger.error( 'fixtureQrUpdate =>', error );
+    return res.sendError( { message: 'Internal Server Error' }, 500 );
+  }
+};
+
+
 export const updateDetailedDistance = async ( req, res ) => {
   try {
     const { floorId, elementNumber, elementType, detailedDistance } = req.body;
@@ -2721,7 +2780,7 @@ export const getFixtureBrands = async ( req, res ) => {
 
     // const [ data ] = sections;
 
-    const brandCategories = await planoStaticBrandCategoriesService.findOne( { } );
+    const brandCategories = await planoStaticData.findOne( { type: 'brandCategory' } );
 
     return res.sendSuccess( brandCategories.toObject().data );
   } catch ( error ) {
@@ -2744,3 +2803,58 @@ export const checkPlanoExist = async ( req, res ) => {
     return res.sendError( 'Internal Server Error', 500 );
   }
 };
+
+export async function storeLayoutElements( req, res ) {
+  try {
+    // const planoIds = req.body.id.map( ( id ) => new mongoose.Types.ObjectId( id ) );
+
+    const planograms = await planoService.find(
+        { _id: new mongoose.Types.ObjectId( req.body.id ) },
+        { storeId: 1, storeName: 1, planoId: '$_id' },
+    );
+
+    if ( !planograms?.length ) {
+      return res.sendError( 'No data found', 204 );
+    }
+
+    const storeLayout = await Promise.all(
+        planograms.map( async ( planogram ) => {
+          const floorList = await storeBuilderService.find(
+              { planoId: planogram._id },
+              { floorName: 1, layoutPolygon: 1, crestLayout: 1 },
+          );
+
+          const floors = floorList.map( ( floor ) => {
+            if ( floor.toObject()?.crestLayout ) {
+              return {
+                floorName: 'floor 1',
+                layoutPolygon: [ 'wall 1', 'wall 2', 'wall 3', 'centre' ],
+              };
+            } else {
+              const layoutPolygon = floor
+                  .toObject()
+                  ?.layoutPolygon.map( ( element ) => {
+                    return `${element?.elementType} ${element?.elementNumber}`;
+                  } );
+              layoutPolygon.push( 'centre' );
+              return {
+                ...floor.toObject(),
+                layoutPolygon,
+              };
+            }
+          } );
+
+          return {
+            ...planogram.toObject(),
+            floors,
+          };
+        } ),
+    );
+
+    return res.sendSuccess( storeLayout );
+  } catch ( e ) {
+    logger.error( { functionName: 'storeLayoutv1', error: e, message: req.body } );
+    return res.sendError( e, 500 );
+  }
+}
+

package/src/controllers/task.controller.js

@@ -9,6 +9,7 @@ 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';
 dayjs.extend( timeZone );
 
 async function createUser( data ) {
@@ -110,6 +111,32 @@ export async function createTask( req, res ) {
     if ( !taskDetails.length ) {
       return res.sendError( 'No data found', 204 );
     }
+    let userEmailList = [ ...new Set( req.body.stores.map( ( ele ) => ele.email ) ) ];
+    for ( let mail of userEmailList ) {
+      let query = [
+        {
+          $addFields: {
+            emailLower: { $toLower: '$email' },
+          },
+        },
+        {
+          $match: {
+            clientId: req.body.clientId,
+            emailLower: mail.toLowerCase(),
+          },
+        },
+      ];
+      userDetails = await userService.aggregate( query );
+      if ( !userDetails.length ) {
+        let userData = {
+          clientId: req.body.clientId,
+          mobileNumber: '',
+          email: mail,
+          userName: mail.split( '@' )[0],
+        };
+        await createUser( userData );
+      }
+    }
     let endDate = dayjs().add( req.body.days, 'day' ).format( 'YYYY-MM-DD' );
     await Promise.all( taskDetails.map( async ( task ) => {
       let data = {
@@ -183,22 +210,22 @@ export async function createTask( req, res ) {
             {
               $match: {
                 clientId: req.body.clientId,
-                email: getUserEmail.email,
+                email: getUserEmail.email.toLowerCase(),
               },
             },
           ];
           userDetails = await userService.aggregate( query );
-          if ( !userDetails.length ) {
-            let userData = {
-              clientId: req.body.clientId,
-              mobileNumber: '',
-              email: getUserEmail.email,
-              userName: getUserEmail.email.split( '@' )[0],
-            };
-            userDetails = await createUser( userData );
-          } else {
-            userDetails = userDetails[0];
-          }
+          // if ( !userDetails.length ) {
+          //   let userData = {
+          //     clientId: req.body.clientId,
+          //     mobileNumber: '',
+          //     email: getUserEmail.email,
+          //     userName: getUserEmail.email.split( '@' )[0],
+          //   };
+          //   userDetails = await createUser( userData );
+          // } else {
+          userDetails = userDetails[0];
+          // }
         }
         let taskData = { ...data };
         taskData.store_id = store.storeId;
@@ -564,3 +591,18 @@ export async function getFixtureDetails( req, res ) {
     return res.sendError( e, 500 );
   }
 }
+
+export async function getVmDetails( req, res ) {
+  try {
+    let getVms = await planoProductService.find( { type: 'vm' }, { productName: 1 } );
+    if ( !getVms.length ) {
+      return res.sendError( 'No data found', 204 );
+    }
+    getVms = [ ...new Set( getVms.map( ( ele ) => ele.productName ) ) ];
+    getVms.push( 'other' );
+    return res.sendSuccess( getVms );
+  } catch ( e ) {
+    logger.error( { functionName: 'getVmDetails', error: e } );
+    return res.sendError( e, 500 );
+  }
+}

package/src/routes/script.routes.js

@@ -16,4 +16,7 @@ scriptRouter
     .post( '/updateinventory', scriptController.updateInventory )
     .post( '/updateRfidProduct', scriptController.updateRfidProduct )
     .post( '/updateRfidProduct2', scriptController.updateRfidProduct2 )
-    .post( '/getProdTaskData', scriptController.getProdTaskData );
+    .post( '/getProdTaskData', scriptController.getProdTaskData )
+    .post( '/updateLayoutFeedback', scriptController.updatelayoutFeedback )
+    .post( '/updateFixtureFeedback', scriptController.updateFixtureFeedback )
+    .post( '/getFileNames', scriptController.extractZipFileNames );

package/src/routes/storeBuilder.routes.js

@@ -34,10 +34,12 @@ storeBuilderRouter
     .post( '/updateQrCvProcessRequest', isAllowedSessionHandler, storeBuilderController.updateQrCvProcessRequest )
     .post( '/getQrCvProcessRequest', isAllowedSessionHandler, storeBuilderController.getQrCvProcessRequest )
     .post( '/fixtureQrUpdate', isAllowedSessionHandler, storeBuilderController.fixtureQrUpdate )
+    .post( '/fixtureQrUpdatev1', isAllowedSessionHandler, storeBuilderController.fixtureQrUpdatev1 )
     .post( '/updateDeatailedDistance', isAllowedSessionHandler, storeBuilderController.updateDetailedDistance )
     .post( '/upsertFixture', isAllowedSessionHandler, storeBuilderController.upsertFixtures )
     .post( '/getshelfSections', isAllowedSessionHandler, storeBuilderController.getShelfSections )
     .post( '/getFixtureTypes', isAllowedSessionHandler, storeBuilderController.getFixtureTypes )
     .post( '/getFixtureLengths', isAllowedSessionHandler, storeBuilderController.getFixtureLengths )
     .post( '/getFixtureBrands', isAllowedSessionHandler, storeBuilderController.getFixtureBrands )
-    .post( '/checkPlanoExist', isAllowedSessionHandler, storeBuilderController.checkPlanoExist );
+    .post( '/checkPlanoExist', isAllowedSessionHandler, storeBuilderController.checkPlanoExist )
+    .post( '/storeLayoutElements', isAllowedSessionHandler, storeBuilderController.storeLayoutElements );

package/src/routes/task.routes.js

@@ -11,4 +11,5 @@ storeBuilderTaskRouter
     .post( '/uploadImage', isAllowedSessionHandler, taskController.uploadImage )
     .post( '/updateStatus', isAllowedSessionHandler, taskController.updateStatus )
     .post( '/updateAnswers', isAllowedSessionHandler, taskController.updateAnswers )
-    .get( '/getFixtureDetails', isAllowedSessionHandler, taskController.getFixtureDetails );
+    .get( '/getFixtureDetails', isAllowedSessionHandler, taskController.getFixtureDetails )
+    .get( '/getVmDetails', isAllowedSessionHandler, taskController.getVmDetails );

package/src/service/{planoStaticBrandCategories.service.js → planoStaticData.service.js}

@@ -1,8 +1,8 @@
 import model from 'tango-api-schema';
 
 export async function find( query={}, field={} ) {
-  return model.planoStaticBrandCategories.find( query, field );
+  return model.planoStaticData.find( query, field );
 }
 export async function findOne( query={}, field={} ) {
-  return model.planoStaticBrandCategories.findOne( query, field );
+  return model.planoStaticData.findOne( query, field );
 }