tango-app-api-trax 1.0.0-alpha.0

package/.eslintrc.cjs

@@ -0,0 +1,41 @@
+
+module.exports = {
+  'env': {
+    'es2021': true,
+    'node': true,
+  },
+  'extends': 'google',
+  'overrides': [
+    {
+      'env': {
+        'node': true,
+      },
+      'files': [
+        '.eslintrc.{js,cjs}',
+      ],
+      'parserOptions': {
+        'sourceType': 'script',
+      },
+    },
+  ],
+  'parserOptions': {
+    'ecmaVersion': 'latest',
+    'sourceType': 'module',
+  },
+  'rules': {
+    'linebreak-style': [ 'error', 'windows' ],
+    'require-jsdoc': 'off',
+    'arrow-spacing': 'error',
+    'key-spacing': [ 'error', { 'beforeColon': false, 'afterColon': true } ],
+    'object-curly-spacing': [ 'error', 'always' ],
+    'space-in-parens': [ 'error', 'always' ],
+    'keyword-spacing': 'error',
+    'array-bracket-spacing': [ 'error', 'always' ],
+    'spaced-comment': [ 'error', 'always' ],
+    'max-len': [ 'error', { 'code': 700 } ],
+    'no-unused-vars': 'error',
+    'new-cap': [ 'error', { 'newIsCap': true, 'capIsNew': false } ],
+    'prefer-const': 'off',
+  },
+};
+

package/README.md

@@ -0,0 +1,29 @@
+# README #
+
+This README would normally document whatever steps are necessary to get your application up and running.
+
+### What is this repository for? ###
+
+* Quick summary
+* Version
+* [Learn Markdown](https://bitbucket.org/tutorials/markdowndemo)
+
+### How do I get set up? ###
+
+* Summary of set up
+* Configuration
+* Dependencies
+* Database configuration
+* How to run tests
+* Deployment instructions
+
+### Contribution guidelines ###
+
+* Writing tests
+* Code review
+* Other guidelines
+
+### Who do I talk to? ###
+
+* Repo owner or admin
+* Other community or team contact

package/index.js

@@ -0,0 +1,6 @@
+
+
+import { traxDashboardRouter } from './src/routes/traxDashboard.routes.js';
+
+export { traxDashboardRouter };
+

package/package.json

@@ -0,0 +1,37 @@
+{
+    "name": "tango-app-api-trax",
+    "version": "1.0.0-alpha.0",
+    "description": "Trax",
+    "main": "index.js",
+    "type": "module",
+    "scripts": {
+        "start": "nodemon --exec \"eslint --fix . && node index.js\""
+    },
+    "engines": {
+        "node": ">=18.10.0"
+    },
+    "author": "praveenraj",
+    "license": "ISC",
+    "dependencies": {
+        "aws-sdk": "^2.1665.0",
+        "dayjs": "^1.11.13",
+        "dotenv": "^16.4.5",
+        "express": "^4.19.2",
+        "handlebars": "^4.7.8",
+        "lodash": "^4.17.21",
+        "mongodb": "^6.8.0",
+        "nodemon": "^3.1.4",
+        "tango-api-schema": "^2.1.45",
+        "tango-app-api-middleware": "^3.1.41",
+        "winston": "^3.13.1",
+        "winston-daily-rotate-file": "^5.0.0"
+    },
+    "devDependencies": {
+        "eslint": "^8.57.0",
+        "eslint-config-google": "^0.14.0",
+        "eslint-config-semistandard": "^17.0.0",
+        "eslint-config-standard": "^17.1.0",
+        "eslint-plugin-import": "^2.29.1",
+        "eslint-plugin-promise": "^6.6.0"
+    }
+}

package/src/controllers/traxDashboard.controllers.js

@@ -0,0 +1,402 @@
+import { logger } from 'tango-app-api-middleware';
+import * as processedchecklistService from '../services/processedchecklist.services.js';
+
+export const welcome = async ( req, res ) => {
+  try {
+    let result = {
+      'Message': 'Welcome',
+    };
+    return res.sendSuccess( result );
+  } catch ( error ) {
+    logger.error( { error: error, message: req.query, function: 'welcome' } );
+    return res.sendError( { error: error }, 500 );
+  }
+};
+
+export const overallCards = async ( req, res ) => {
+  try {
+    let reqestData = req.body;
+    let fromDate = new Date( reqestData.fromDate );
+    let toDate = new Date( reqestData.toDate );
+    let userTimezoneOffset = toDate.getTimezoneOffset() * 60000;
+    toDate = new Date( toDate.getTime() - userTimezoneOffset );
+    toDate.setUTCHours( 23, 59, 59, 59 );
+    let activeUnique = 0;
+    let total = 0;
+    let notSubmitted = 0;
+    let open = 0;
+    let inprogress = 0;
+    let submitted = 0;
+    let totalFlags = {
+      'count': '',
+      'comparisonData': '',
+      'ComparisonFlag': '',
+    };
+    let completionScore = {
+      'count': '',
+      'comparisonData': '',
+      'ComparisonFlag': '',
+    };
+    let complianceScore = {
+      'count': '',
+      'comparisonData': '',
+      'ComparisonFlag': '',
+    };
+    let result = {};
+
+    let overallChecklistDataQuery = [
+      {
+        $match: {
+          client_id: reqestData.clientId,
+          $and: [
+            { store_id: { $in: reqestData.storeId } },
+            { date_iso: { $gte: fromDate } },
+            { date_iso: { $lte: toDate } },
+          ],
+        },
+      },
+      {
+        $project: {
+          sourceCheckList_id: 1,
+          checkListId: 1,
+          checklistStatus: 1,
+          timeFlag: 1,
+          questionFlag: 1,
+          mobileDetectionFlag: 1,
+          storeOpenCloseFlag: 1,
+          uniformDetectionFlag: 1,
+          markasread: 1,
+          checkListType: 1,
+        },
+      },
+      {
+        $group: {
+          _id: '',
+          totalChecklist: { $sum: 1 },
+          notSubmittedChecklist: {
+            $sum: {
+              $cond: [
+                {
+                  $and: [
+                    { $ne: [ '$checklistStatus', 'submit' ] },
+                  ],
+                }, 1, 0 ],
+            },
+          },
+          openChecklist: {
+            $sum: {
+              $cond: [
+                {
+                  $and: [
+                    { $eq: [ '$checklistStatus', 'open' ] },
+                  ],
+                }, 1, 0 ],
+            },
+          },
+          inprogressChecklist: {
+            $sum: {
+              $cond: [
+                {
+                  $and: [
+                    { $eq: [ '$checklistStatus', 'inprogress' ] },
+                  ],
+                }, 1, 0 ],
+            },
+          },
+          submittedChecklist: {
+            $sum: {
+              $cond: [
+                {
+                  $and: [
+                    { $eq: [ '$checklistStatus', 'submit' ] },
+                  ],
+                }, 1, 0 ],
+            },
+          },
+          flaggedChecklist: {
+            $sum: {
+              $cond: [ {
+                $or: [
+                  { $gt: [ '$timeFlag', 0 ] },
+                  { $gt: [ '$mobileDetectionFlag', 0 ] },
+                  { $gt: [ '$storeOpenCloseFlag', 0 ] },
+                  { $gt: [ '$uniformDetectionFlag', 0 ] },
+                ],
+              }, 1, 0 ],
+            },
+          },
+        },
+      },
+    ];
+    let getOverallChecklistData = await processedchecklistService.aggregate( overallChecklistDataQuery );
+    let uniqueChecklistDataQuery = [
+      {
+        $match: {
+          client_id: reqestData.clientId,
+          $and: [
+            { store_id: { $in: reqestData.storeId } },
+            { date_iso: { $gte: fromDate } },
+            { date_iso: { $lte: toDate } },
+          ],
+        },
+      },
+      {
+        $project: {
+          sourceCheckList_id: 1,
+        },
+      },
+      {
+        $group: {
+          _id: '$sourceCheckList_id',
+        },
+      },
+      {
+        $count: 'totalUniqueChecklist',
+      },
+    ];
+    let getUniqueChecklistData = await processedchecklistService.aggregate( uniqueChecklistDataQuery );
+    if ( !getUniqueChecklistData.length && !getOverallChecklistData.length ) {
+      return res.sendError( { error: 'No Data Found' }, 204 );
+    }
+
+    if ( getUniqueChecklistData.length && getUniqueChecklistData.length>0 ) {
+      if ( getUniqueChecklistData[0].totalUniqueChecklist ) {
+        activeUnique = getUniqueChecklistData[0]?.totalUniqueChecklist;
+      }
+    }
+
+    if ( getOverallChecklistData.length && getOverallChecklistData.length>0 ) {
+      if ( getOverallChecklistData[0].totalChecklist ) {
+        total = getOverallChecklistData[0]?.totalChecklist;
+      }
+      if ( getOverallChecklistData[0].notSubmittedChecklist ) {
+        notSubmitted = getOverallChecklistData[0]?.notSubmittedChecklist;
+      }
+      if ( getOverallChecklistData[0].openChecklist ) {
+        open = getOverallChecklistData[0]?.openChecklist;
+      }
+      if ( getOverallChecklistData[0].inprogressChecklist ) {
+        inprogress = getOverallChecklistData[0]?.inprogressChecklist;
+      }
+      if ( getOverallChecklistData[0].submittedChecklist ) {
+        submitted = getOverallChecklistData[0]?.submittedChecklist;
+      }
+      if ( getOverallChecklistData[0].flaggedChecklist ) {
+        totalFlags.count = getOverallChecklistData[0]?.flaggedChecklist;
+      }
+    }
+
+    result.overallCards = {
+      'activeUnique': activeUnique,
+      'total': total,
+      'notSubmitted': notSubmitted,
+      'open': open,
+      'inprogress': inprogress,
+      'submitted': submitted,
+      'totalFlags': totalFlags,
+      'completionScore': completionScore,
+      'complianceScore': complianceScore,
+    };
+    return res.sendSuccess( result );
+  } catch ( error ) {
+    logger.error( { error: error, message: req.query, function: 'overallCards' } );
+    return res.sendError( { error: error }, 500 );
+  }
+};
+
+export const checklistPerformance = async ( req, res ) => {
+  try {
+    let reqestData = req.body;
+    let fromDate = new Date( reqestData.fromDate );
+    let toDate = new Date( reqestData.toDate );
+    let userTimezoneOffset = toDate.getTimezoneOffset() * 60000;
+    toDate = new Date( toDate.getTime() - userTimezoneOffset );
+    toDate.setUTCHours( 23, 59, 59, 59 );
+    let result = {};
+
+    let findQuery = [];
+    let findAndQuery = [];
+    findAndQuery.push(
+        { client_id: reqestData.clientId },
+        { store_id: { $in: reqestData.storeId } },
+        { date_iso: { $gte: fromDate } },
+        { date_iso: { $lte: toDate } },
+    );
+
+    findQuery.push( { $match: { $and: findAndQuery } } );
+
+    if ( reqestData.searchValue && reqestData.searchValue != '' ) {
+      findQuery.push( { $match: { $or: [ { checkListName: { $regex: reqestData.searchValue, $options: 'i' } } ] } } );
+    }
+
+    findQuery.push( {
+      $project: {
+        sourceCheckList_id: 1,
+        checkListId: 1,
+        checkListName: 1,
+        storeCount: 1,
+        createdBy: 1,
+        createdByName: 1,
+        checklistStatus: 1,
+        timeFlag: 1,
+        questionFlag: 1,
+        mobileDetectionFlag: 1,
+        storeOpenCloseFlag: 1,
+        uniformDetectionFlag: 1,
+        checkListType: 1,
+        scheduleRepeatedType: 1,
+      },
+    } );
+
+    findQuery.push( {
+      $group: {
+        _id: '$sourceCheckList_id',
+        sourceCheckList_id: { $last: '$sourceCheckList_id' },
+        checkListName: { $last: '$checkListName' },
+        checkListChar: { $last: { $substr: [ '$checkListName', 0, 2 ] } },
+        scheduleRepeatedType: { $last: '$scheduleRepeatedType' },
+        storeCount: { $max: '$storeCount' },
+        submittedChecklist: {
+          $sum: {
+            $cond: [ { $eq: [ '$checklistStatus', 'submit' ] }, 1, 0 ],
+          },
+        },
+        flaggedChecklist: {
+          $sum: {
+            $cond: [ {
+              $or: [
+                { $gt: [ '$timeFlag', 0 ] },
+                { $gt: [ '$questionFlag', 0 ] },
+                { $gt: [ '$mobileDetectionFlag', 0 ] },
+                { $gt: [ '$storeOpenCloseFlag', 0 ] },
+                { $gt: [ '$uniformDetectionFlag', 0 ] },
+              ],
+            }, 1, 0 ],
+          },
+        },
+        checkListType: { $last: '$checkListType' },
+      },
+    } );
+
+    let getTotalCount = await processedchecklistService.aggregate( findQuery );
+    if ( !getTotalCount.length ) {
+      return res.sendError( { error: 'No Data Found' }, 204 );
+    }
+
+    if ( reqestData.sortColumnName && reqestData.sortColumnName != '' && reqestData.sortBy && reqestData.sortBy !='' ) {
+      findQuery.push( { $sort: { [reqestData.sortColumnName]: reqestData.sortBy } } );
+    } else {
+      findQuery.push( { $sort: { ['submittedChecklist']: -1 } } );
+    }
+
+    let limit = parseInt( reqestData?.limit ) || 10;
+    let skip = limit * ( reqestData?.offset ) || 0;
+    findQuery.push( { $skip: skip }, { $limit: limit } );
+    let getChecklistPerformanceData = await processedchecklistService.aggregate( findQuery );
+
+    result.totalCount = getTotalCount.length;
+    result.checklistPerformance = getChecklistPerformanceData;
+    return res.sendSuccess( result );
+  } catch ( error ) {
+    console.log( 'error =>', error );
+    logger.error( { error: error, message: req.query, function: 'checklistPerformance' } );
+    return res.sendError( { error: error }, 500 );
+  }
+};
+
+export const storePerformance = async ( req, res ) => {
+  try {
+    let reqestData = req.body;
+    let fromDate = new Date( reqestData.fromDate );
+    let toDate = new Date( reqestData.toDate );
+    let userTimezoneOffset = toDate.getTimezoneOffset() * 60000;
+    toDate = new Date( toDate.getTime() - userTimezoneOffset );
+    toDate.setUTCHours( 23, 59, 59, 59 );
+    let result = {};
+
+    let checklistPerformanceQuery = [
+      {
+        $match: {
+          client_id: reqestData.clientId,
+          $and: [
+            { store_id: { $in: reqestData.storeId } },
+            { date_iso: { $gte: fromDate } },
+            { date_iso: { $lte: toDate } },
+          ],
+        },
+      },
+      {
+        $project: {
+          sourceCheckList_id: 1,
+          checkListId: 1,
+          checkListName: 1,
+          storeCount: 1,
+          createdBy: 1,
+          createdByName: 1,
+          checklistStatus: 1,
+          timeFlag: 1,
+          questionFlag: 1,
+          mobileDetectionFlag: 1,
+          storeOpenCloseFlag: 1,
+          uniformDetectionFlag: 1,
+          checkListType: 1,
+          scheduleRepeatedType: 1,
+          store_id: 1,
+          storeName: 1,
+          userEmail: 1,
+        },
+      },
+      {
+        $group: {
+          _id: '$store_id',
+          storeName: { $last: '$storeName' },
+          userEmail: { $last: '$userEmail' },
+          checkListCount: { $sum: '$store_id' },
+          flaggedChecklist: {
+            $sum: {
+              $cond: [ {
+                $or: [
+                  { $gt: [ '$timeFlag', 0 ] },
+                  { $gt: [ '$questionFlag', 0 ] },
+                  { $gt: [ '$mobileDetectionFlag', 0 ] },
+                  { $gt: [ '$storeOpenCloseFlag', 0 ] },
+                  { $gt: [ '$uniformDetectionFlag', 0 ] },
+                ],
+              }, 1, 0 ],
+            },
+          },
+          submittedChecklist: {
+            $sum: {
+              $cond: [ { $eq: [ '$checklistStatus', 'submit' ] }, 1, 0 ],
+            },
+          },
+          checkListType: { $last: '$checkListType' },
+        },
+      },
+    ];
+
+    let getTotalCount = await processedchecklistService.aggregate( checklistPerformanceQuery );
+    if ( !getTotalCount.length ) {
+      return res.sendError( { error: 'No Data Found' }, 204 );
+    }
+
+    if ( reqestData.sortColumnName && reqestData.sortColumnName != '' && reqestData.sortBy && reqestData.sortBy !='' ) {
+      checklistPerformanceQuery.push( { $sort: { [reqestData.sortColumnName]: reqestData.sortBy } } );
+    } else {
+      checklistPerformanceQuery.push( { $sort: { ['submittedChecklist']: -1 } } );
+    }
+
+    let limit = parseInt( reqestData?.limit ) || 10;
+    let skip = limit * ( reqestData?.offset ) || 0;
+    checklistPerformanceQuery.push( { $skip: skip }, { $limit: limit } );
+    let getChecklistPerformanceData = await processedchecklistService.aggregate( checklistPerformanceQuery );
+
+    result.totalCount = getTotalCount.length;
+    result.checklistPerformance = getChecklistPerformanceData;
+    return res.sendSuccess( result );
+  } catch ( error ) {
+    console.log( 'error =>', error );
+    logger.error( { error: error, message: req.query, function: 'storePerformance' } );
+    return res.sendError( { error: error }, 500 );
+  }
+};

package/src/dtos/validation.dtos.js

@@ -0,0 +1,226 @@
+import joi from 'joi';
+
+// Base schema
+const baseSchema = {
+  clientId: joi.string().required(),
+  storeId: joi.array().required().empty(),
+  fromDate: joi.string().required(),
+  toDate: joi.string().required(),
+  valueType: joi.string().optional().allow( '' ),
+  nob: joi.boolean().optional().allow( '' ),
+};
+
+// Schema for Card Funnel
+export const validateCardFunnelSchema = joi.object( {
+  ...baseSchema,
+} );
+
+export const validateCardFunnelParams = {
+  body: validateCardFunnelSchema,
+};
+
+// Schema for Card Graph (extends baseSchema with additional fields)
+export const validateCardGraphSchema = joi.object( {
+  ...baseSchema,
+  dateType: joi.string().required(),
+} );
+
+export const validateCardGraphParams = {
+  body: validateCardGraphSchema,
+};
+
+export const validateRecapVideoSchema = joi.object( {
+  clientId: joi.string().required(),
+  storeId: joi.array().required().empty(),
+  recapVideoDate: joi.string().required(),
+  valueType: joi.string().optional().allow( '' ),
+  nob: joi.boolean().optional().allow( '' ),
+} );
+
+export const validateRecapVideoParams = {
+  body: validateRecapVideoSchema,
+};
+
+export const validateDensityDwellSchema = joi.object( {
+  ...baseSchema,
+  dateRange: joi.number().required(),
+} );
+
+export const validateDensityDwellParams = {
+  body: validateDensityDwellSchema,
+};
+
+export const validateOverallCardsSchema = joi.object( {
+  ...baseSchema,
+  revenue: joi.number().required(),
+  processType: joi.string().required(),
+} );
+
+export const validateOverallCardsParams = {
+  body: validateOverallCardsSchema,
+};
+
+export const validateOverallHourlyChartSchema = joi.object( {
+  ...baseSchema,
+  processType: joi.string().required(),
+} );
+
+export const validateOverallHourlyChartParams = {
+  body: validateOverallHourlyChartSchema,
+};
+
+export const validateOverallCharSchema = joi.object( {
+  ...baseSchema,
+  limit: joi.number().required(),
+  offset: joi.number().required(),
+  processType: joi.string().required(),
+} );
+
+export const validateOverallCharParams = {
+  body: validateOverallCharSchema,
+};
+
+export const validateSingleStoreChartSchema = joi.object( {
+  ...baseSchema,
+  limit: joi.number().required(),
+  offset: joi.number().required(),
+  processType: joi.string().required(),
+} );
+
+export const validateSingleStoreChartParams = {
+  body: validateSingleStoreChartSchema,
+};
+
+export const validateDemographicChartSchema = joi.object( {
+  ...baseSchema,
+  processType: joi.string().required(),
+} );
+
+export const validateDemographicChartParams = {
+  body: validateDemographicChartSchema,
+};
+
+export const validateBuyerChartSchema = joi.object( {
+  ...baseSchema,
+  processType: joi.string().required(),
+} );
+
+export const validateBuyerChartParams = {
+  body: validateBuyerChartSchema,
+};
+
+export const validateFootfallDirectoryFoldersSchema = joi.object( {
+  clientId: joi.string().required(),
+  storeId: joi.array().required().empty(),
+  footfallDate: joi.string().required(),
+  processType: joi.string().required(),
+  valueType: joi.string().optional().allow( '' ),
+  nob: joi.boolean().optional().allow( '' ),
+} );
+
+export const validateFootfallDirectoryFoldersParams = {
+  body: validateFootfallDirectoryFoldersSchema,
+};
+
+export const validateFootfallDirectorySchema = joi.object( {
+  clientId: joi.string().required(),
+  storeId: joi.array().required().empty(),
+  footfallDate: joi.string().required(),
+  processType: joi.string().required(),
+  folderName: joi.string().required(),
+  valueType: joi.string().optional().allow( '' ),
+  nob: joi.boolean().optional().allow( '' ),
+} );
+
+export const validateFootfallDirectoryParams = {
+  body: validateFootfallDirectorySchema,
+};
+
+export const validateSummaryTableSchema = joi.object( {
+  ...baseSchema,
+  valueType: joi.string().required(),
+  search: joi.string().optional().allow( '' ),
+  sortBy: joi.number().optional().allow( '' ),
+  sort: joi.string().optional().allow( '' ),
+  limit: joi.number().required(),
+  offset: joi.number().required(),
+  export: joi.boolean().required(),
+} );
+
+export const validateSummaryTableParams = {
+  body: validateSummaryTableSchema,
+};
+
+export const validateFootfallTrendSchema = joi.object( {
+  ...baseSchema,
+  dateType: joi.string().required(),
+  filterBy: joi.string().required(),
+  processType: joi.string().optional().allow( '' ),
+  forecast: joi.boolean().optional(),
+  limit: joi.number().required(),
+  offset: joi.number().required(),
+  sortBy: joi.number().optional().allow( '' ),
+  sort: joi.string().optional().allow( '' ),
+} );
+
+export const validateFootfallTrendParams = {
+  body: validateFootfallTrendSchema,
+};
+
+export const validateStoreOperationSchema = joi.object( {
+  ...baseSchema,
+} );
+
+export const validateStoreOperationParams = {
+  body: validateStoreOperationSchema,
+};
+
+export const validateStoresMapSchema = joi.object( {
+  clientId: joi.string().required(),
+  storeId: joi.array().required().empty(),
+  storeDate: joi.string().required(),
+  nob: joi.boolean().optional().allow( '' ),
+} );
+
+export const validateStoresMapParams = {
+  body: validateStoresMapSchema,
+};
+
+export const validateperformanceMatrixSchema = joi.object( {
+  ...baseSchema,
+  processtype1: joi.string().required(),
+  processtype2: joi.string().required(),
+} );
+
+export const validateperformanceMatrixParams = {
+  body: validateperformanceMatrixSchema,
+};
+
+export const validateHeaderSchema = joi.object( {
+  clientId: joi.string().required(),
+  city: joi.array().required(),
+  group: joi.array().required(),
+} );
+
+export const validateHeaderParams = {
+  body: validateHeaderSchema,
+};
+
+export const getMyProductSchema = joi.object( {
+  clientId: joi.string().required(),
+  storeId: joi.array().optional().empty(),
+} );
+
+export const getMyProductParams = {
+  body: getMyProductSchema,
+};
+
+export const getStoreCameraImageSchema = joi.object( {
+  clientId: joi.string().required(),
+  storeId: joi.array().optional().empty(),
+  storeDate: joi.string().required(),
+} );
+
+export const getStoreCameraImageParams = {
+  body: getStoreCameraImageSchema,
+};

package/src/routes/traxDashboard.routes.js

@@ -0,0 +1,21 @@
+import express from 'express';
+// import { validate, isAllowedSessionHandler, authorize, isAllowedClient } from 'tango-app-api-middleware';
+// import * as validationDtos from '../dtos/validation.dtos.js';
+
+export const traxDashboardRouter = express.Router();
+
+import {
+  welcome,
+  overallCards,
+  checklistPerformance,
+  storePerformance,
+} from '../controllers/traxDashboard.controllers.js';
+
+traxDashboardRouter
+    .get( '/welcome', welcome )
+    .post( '/overallCards', overallCards )
+    .post( '/checklistPerformance', checklistPerformance )
+    .post( '/storePerformance', storePerformance )
+    .post( '/userPerformance', overallCards );
+
+export default traxDashboardRouter;

package/src/services/clients.services.js

@@ -0,0 +1,23 @@
+import model from 'tango-api-schema';
+
+export const find = ( query = {}, record = {} ) => {
+  return model.clientModel.find( query, record );
+};
+
+export const findOne = ( query = {}, record = {} ) => {
+  return model.clientModel.findOne( query, record ).sort( { updatedAt: -1 } );
+};
+
+export const updateOne = ( query = {}, record = {} ) => {
+  return model.clientModel.updateOne( query, { $set: record } );
+};
+
+export const aggregate = ( query = [] ) => {
+  return model.clientModel.aggregate( query );
+};
+
+export const getClientCount = ( query = {} ) => {
+  return model.clientModel.count( query );
+};
+
+

package/src/services/processedchecklist.services.js

@@ -0,0 +1,23 @@
+import model from 'tango-api-schema';
+
+export const find = ( query = {}, record = {} ) => {
+  return model.processedchecklistModel.find( query, record );
+};
+
+export const findOne = ( query = {}, record = {} ) => {
+  return model.processedchecklistModel.findOne( query, record ).sort( { updatedAt: -1 } );
+};
+
+export const updateOne = ( query = {}, record = {} ) => {
+  return model.processedchecklistModel.updateOne( query, { $set: record } );
+};
+
+export const aggregate = ( query = [] ) => {
+  return model.processedchecklistModel.aggregate( query );
+};
+
+export const getClientCount = ( query = {} ) => {
+  return model.processedchecklistModel.count( query );
+};
+
+

package/src/services/processedchecklistconfig.services.js

@@ -0,0 +1,23 @@
+import model from 'tango-api-schema';
+
+export const find = ( query = {}, record = {} ) => {
+  return model.processedchecklistconfigModel.find( query, record );
+};
+
+export const findOne = ( query = {}, record = {} ) => {
+  return model.processedchecklistconfigModel.findOne( query, record ).sort( { updatedAt: -1 } );
+};
+
+export const updateOne = ( query = {}, record = {} ) => {
+  return model.processedchecklistconfigModel.updateOne( query, { $set: record } );
+};
+
+export const aggregate = ( query = [] ) => {
+  return model.processedchecklistconfigModel.aggregate( query );
+};
+
+export const getClientCount = ( query = {} ) => {
+  return model.processedchecklistconfigModel.count( query );
+};
+
+