tango-app-api-trax 3.9.29 → 3.9.31

package/src/services/domain.service.js

@@ -1,33 +1,28 @@
-import model from 'tango-api-schema';
-import { createLoggableService } from '../logging/createLoggableService.js';
-
-
-const _methods = {
-  async findOne( query={}, field={} ) {
-    return model.domainModel.findOne( query, field );
-  },
-
-  async find( query={}, field={} ) {
-    return model.domainModel.find( query, field );
-  },
-
-  async create( document = {} ) {
-    return model.domainModel.create( document );
-  },
-
-  async deleteOne( query = {} ) {
-    return model.domainModel.deleteOne( query );
-  },
-
-  async aggregate( query = {} ) {
-    return model.domainModel.aggregate( query );
-  },
-};
-
-const _svc = createLoggableService( _methods, 'domains' );
-
-export const findOne   = ( ...args ) => _svc.findOne( ...args );
-export const find      = ( ...args ) => _svc.find( ...args );
-export const create    = ( ...args ) => _svc.create( ...args );
-export const deleteOne = ( ...args ) => _svc.deleteOne( ...args );
-export const aggregate = ( ...args ) => _svc.aggregate( ...args );
+import model from 'tango-api-schema';
+
+
+export const findOne = async ( query={}, field={} ) => {
+  return model.domainModel.findOne( query, field );
+};
+
+
+export const find = async ( query={}, field={} ) => {
+  return model.domainModel.find( query, field );
+};
+
+
+export const create = async ( document = {} ) => {
+  return model.domainModel.create( document );
+};
+
+
+export const deleteOne = async ( query = {} ) => {
+  return model.domainModel.deleteOne( query );
+};
+
+
+export const aggregate = async ( query = {} ) => {
+  return model.domainModel.aggregate( query );
+};
+
+

package/src/services/download.services.js

@@ -1,48 +1,38 @@
-import model from 'tango-api-schema';
-import { createLoggableService } from '../logging/createLoggableService.js';
-
-
-const _methods = {
-  async findOne( query={}, field={} ) {
-    return model.downloadModel.findOne( query, field );
-  },
-
-  async find( query={}, field={} ) {
-    return model.downloadModel.find( query, field );
-  },
-
-  async create( document = {} ) {
-    return model.downloadModel.create( document );
-  },
-
-  async insert( document = {} ) {
-    return model.downloadModel.create( document );
-  },
-
-  async deleteOne( query = {} ) {
-    return model.downloadModel.deleteOne( query );
-  },
-
-  async aggregate( query = {} ) {
-    return model.downloadModel.aggregate( query );
-  },
-
-  async getCount( query = {} ) {
-    return model.downloadModel.count( query );
-  },
-
-  async updateOne( query = {}, record={} ) {
-    return model.downloadModel.updateOne( query, { $set: record }, { upsert: true } );
-  },
-};
-
-const _svc = createLoggableService( _methods, 'downloads' );
-
-export const findOne = ( ...args ) => _svc.findOne( ...args );
-export const find = ( ...args ) => _svc.find( ...args );
-export const create = ( ...args ) => _svc.create( ...args );
-export const insert = ( ...args ) => _svc.insert( ...args );
-export const deleteOne = ( ...args ) => _svc.deleteOne( ...args );
-export const aggregate = ( ...args ) => _svc.aggregate( ...args );
-export const getCount = ( ...args ) => _svc.getCount( ...args );
-export const updateOne = ( ...args ) => _svc.updateOne( ...args );
+import model from 'tango-api-schema';
+
+
+export const findOne = async ( query={}, field={} ) => {
+  return model.downloadModel.findOne( query, field );
+};
+
+
+export const find = async ( query={}, field={} ) => {
+  return model.downloadModel.find( query, field );
+};
+
+
+export const create = async ( document = {} ) => {
+  return model.downloadModel.create( document );
+};
+
+export const insert = async ( document = {} ) => {
+  return model.downloadModel.create( document );
+};
+
+
+export const deleteOne = async ( query = {} ) => {
+  return model.downloadModel.deleteOne( query );
+};
+
+
+export const aggregate = async ( query = {} ) => {
+  return model.downloadModel.aggregate( query );
+};
+
+export const getCount = async ( query = {} ) => {
+  return model.downloadModel.count( query );
+};
+
+export const updateOne = async ( query = {}, record={} ) => {
+  return model.downloadModel.updateOne( query, { $set: record }, { upsert: true } );
+};

package/src/services/group.service.js

@@ -1,28 +1,22 @@
-import groupModel from 'tango-api-schema/schema/group.model.js';
-import { createLoggableService } from '../logging/createLoggableService.js';
-
-const _methods = {
-  async updateOneGroup( query, record ) {
-    return await groupModel.updateOne( query, { $set: record } );
-  },
-  async updateGroup( query, record ) {
-    return await groupModel.updateOne( query, record );
-  },
-  async aggregateGroup( query ) {
-    return await groupModel.aggregate( query );
-  },
-  async findOneGroup( query ={}, field={} ) {
-    return await groupModel.findOne( query, field );
-  },
-  async createGroupModel( query ={}, field={} ) {
-    return await groupModel.create( query, field );
-  },
-};
-
-const _svc = createLoggableService( _methods, 'groups' );
-
-export const updateOneGroup   = ( ...args ) => _svc.updateOneGroup( ...args );
-export const updateGroup      = ( ...args ) => _svc.updateGroup( ...args );
-export const aggregateGroup   = ( ...args ) => _svc.aggregateGroup( ...args );
-export const findOneGroup     = ( ...args ) => _svc.findOneGroup( ...args );
-export const createGroupModel = ( ...args ) => _svc.createGroupModel( ...args );
+import groupModel from 'tango-api-schema/schema/group.model.js';
+
+export async function updateOneGroup( query, record ) {
+  return await groupModel.updateOne( query, { $set: record } );
+};
+
+export async function updateGroup( query, record ) {
+  return await groupModel.updateOne( query, record );
+};
+
+export async function aggregateGroup( query ) {
+  return await groupModel.aggregate( query );
+};
+
+export async function findOneGroup( query ={}, field={} ) {
+  return await groupModel.findOne( query, field );
+};
+
+export async function createGroupModel( query ={}, field={} ) {
+  return await groupModel.create( query, field );
+};
+

package/src/services/lenskartEmployeeMapping.service.js

@@ -1,20 +1,15 @@
-import model from 'tango-api-schema';
-import { createLoggableService } from '../logging/createLoggableService.js';
-
-const _methods = {
-  async updateOne( query={}, record={} ) {
-    return model.lenskartEmployeeMappingModel.updateOne( query, { $set: record }, { upsert: true } );
-  },
-  async find( query={}, field={} ) {
-    return model.lenskartEmployeeMappingModel.find( query, field );
-  },
-  async aggregate( query={} ) {
-    return model.lenskartEmployeeMappingModel.aggregate( query );
-  },
-};
-
-const _svc = createLoggableService( _methods, 'lenskartemployeemappings' );
-
-export const updateOne = ( ...args ) => _svc.updateOne( ...args );
-export const find      = ( ...args ) => _svc.find( ...args );
-export const aggregate = ( ...args ) => _svc.aggregate( ...args );
+import model from 'tango-api-schema';
+
+export const updateOne = async ( query={}, record={} ) => {
+  return model.lenskartEmployeeMappingModel.updateOne( query, { $set: record }, { upsert: true } );
+};
+
+export const find = async ( query={}, field={} ) => {
+  return model.lenskartEmployeeMappingModel.find( query, field );
+};
+
+export const aggregate = async ( query={} ) => {
+  return model.lenskartEmployeeMappingModel.aggregate( query );
+};
+
+

package/src/services/locus.service.js

@@ -1,41 +1,34 @@
-import locusOrderModel from 'tango-api-schema/schema/locusOrder.model.js';
-import lenskartemployeemapping from 'tango-api-schema/schema/lenskartEmployeeMapping.model.js';
-import locusorderuser from 'tango-api-schema/schema/locusOrderUser.model.js';
-import { createLoggableService } from '../logging/createLoggableService.js';
-
-
-const _methods = {
-  async getMany( query = {}, fields = {} ) {
-    return await locusOrderModel.find( query, fields ).sort( { createdAt: -1 } );
-  },
-  async getOne( query = {}, fields = { } ) {
-    return await locusOrderModel.findOne( query, fields );
-  },
-  async upsertOne( query = {}, fields = { } ) {
-    return await locusOrderModel.updateOne( query, fields, { upsert: true } );
-  },
-  async getOneEmployeeMapping( query = {}, fields = { } ) {
-    return await lenskartemployeemapping.findOne( query, fields );
-  },
-  async insert( record ) {
-    // eslint-disable-next-line new-cap
-    const document = new locusOrderModel( record );
-    return await document.save();
-  },
-  async deleteOne( query = {} ) {
-    return await locusOrderModel.deleteOne( query );
-  },
-  async locusUserGetOne( query = {}, fields = { } ) {
-    return await locusorderuser.findOne( query, fields );
-  },
-};
-
-const _svc = createLoggableService( _methods, 'locusorders' );
-
-export const getMany = ( ...args ) => _svc.getMany( ...args );
-export const getOne = ( ...args ) => _svc.getOne( ...args );
-export const upsertOne = ( ...args ) => _svc.upsertOne( ...args );
-export const getOneEmployeeMapping = ( ...args ) => _svc.getOneEmployeeMapping( ...args );
-export const insert = ( ...args ) => _svc.insert( ...args );
-export const deleteOne = ( ...args ) => _svc.deleteOne( ...args );
-export const locusUserGetOne = ( ...args ) => _svc.locusUserGetOne( ...args );
+import locusOrderModel from 'tango-api-schema/schema/locusOrder.model.js';
+import lenskartemployeemapping from 'tango-api-schema/schema/lenskartEmployeeMapping.model.js';
+import locusorderuser from 'tango-api-schema/schema/locusOrderUser.model.js';
+
+
+export async function getMany( query = {}, fields = {} ) {
+  return await locusOrderModel.find( query, fields ).sort( { createdAt: -1 } );
+};
+
+export async function getOne( query = {}, fields = { } ) {
+  return await locusOrderModel.findOne( query, fields );
+};
+
+export async function upsertOne( query = {}, fields = { } ) {
+  return await locusOrderModel.updateOne( query, fields, { upsert: true } );
+};
+
+export async function getOneEmployeeMapping( query = {}, fields = { } ) {
+  return await lenskartemployeemapping.findOne( query, fields );
+};
+
+export async function insert( record ) {
+  // eslint-disable-next-line new-cap
+  const document = new locusOrderModel( record );
+  return await document.save();
+};
+
+export async function deleteOne( query = {} ) {
+  return await locusOrderModel.deleteOne( query );
+};
+
+export async function locusUserGetOne( query = {}, fields = { } ) {
+  return await locusorderuser.findOne( query, fields );
+};

package/src/services/notification.service.js

@@ -1,40 +1,31 @@
-import notificationModel from 'tango-api-schema/schema/notification.model.js';
-import { createLoggableService } from '../logging/createLoggableService.js';
-
-const _methods = {
-  async updateOnenotification( query, record ) {
-    return await notificationModel.updateOne( query, { $set: record } );
-  },
-  async updatenotification( query, record ) {
-    return await notificationModel.updateOne( query, record );
-  },
-  async updateManynotification( query, record ) {
-    return await notificationModel.updateMany( query, record );
-  },
-  async aggregatenotification( query ) {
-    return await notificationModel.aggregate( query );
-  },
-  async findOnenotification( query ={}, field={} ) {
-    return await notificationModel.findOne( query, field );
-  },
-  async findnotification( query ={}, field={} ) {
-    return await notificationModel.find( query, field );
-  },
-  async createnotificationModel( query ={}, field={} ) {
-    return await notificationModel.create( query, field );
-  },
-  async insertManynotificationModel( query ={}, field={} ) {
-    return await notificationModel.insertMany( query, field );
-  },
-};
-
-const _svc = createLoggableService( _methods, 'notifications' );
-
-export const updateOnenotification     = ( ...args ) => _svc.updateOnenotification( ...args );
-export const updatenotification        = ( ...args ) => _svc.updatenotification( ...args );
-export const updateManynotification    = ( ...args ) => _svc.updateManynotification( ...args );
-export const aggregatenotification     = ( ...args ) => _svc.aggregatenotification( ...args );
-export const findOnenotification       = ( ...args ) => _svc.findOnenotification( ...args );
-export const findnotification          = ( ...args ) => _svc.findnotification( ...args );
-export const createnotificationModel   = ( ...args ) => _svc.createnotificationModel( ...args );
-export const insertManynotificationModel = ( ...args ) => _svc.insertManynotificationModel( ...args );
+import notificationModel from 'tango-api-schema/schema/notification.model.js';
+
+export async function updateOnenotification( query, record ) {
+  return await notificationModel.updateOne( query, { $set: record } );
+};
+
+export async function updatenotification( query, record ) {
+  return await notificationModel.updateOne( query, record );
+};
+export async function updateManynotification( query, record ) {
+  return await notificationModel.updateMany( query, record );
+};
+
+export async function aggregatenotification( query ) {
+  return await notificationModel.aggregate( query );
+};
+
+export async function findOnenotification( query ={}, field={} ) {
+  return await notificationModel.findOne( query, field );
+};
+export async function findnotification( query ={}, field={} ) {
+  return await notificationModel.find( query, field );
+};
+
+export async function createnotificationModel( query ={}, field={} ) {
+  return await notificationModel.create( query, field );
+};
+export async function insertManynotificationModel( query ={}, field={} ) {
+  return await notificationModel.insertMany( query, field );
+};
+

package/src/services/otp.service.js

@@ -1,24 +1,17 @@
-import otpModel from 'tango-api-schema/schema/otp.model.js';
-import { createLoggableService } from '../logging/createLoggableService.js';
-
-const _methods = {
-  async findOTP( query, fields ) {
-    try {
-      return otpModel.find( query, fields );
-    } catch ( error ) {
-      return error;
-    }
-  },
-  async updateOneOTP( query, record ) {
-    return otpModel.updateOne( query, record, { upsert: true } );
-  },
-  async aggregate( query = {} ) {
-    return otpModel.aggregate( query );
-  },
-};
-
-const _svc = createLoggableService( _methods, 'otps' );
-
-export const findOTP       = ( ...args ) => _svc.findOTP( ...args );
-export const updateOneOTP  = ( ...args ) => _svc.updateOneOTP( ...args );
-export const aggregate     = ( ...args ) => _svc.aggregate( ...args );
+import otpModel from 'tango-api-schema/schema/otp.model.js';
+
+export async function findOTP( query, fields ) {
+  try {
+    return otpModel.find( query, fields );
+  } catch ( error ) {
+    return error;
+  }
+}
+
+export async function updateOneOTP( query, record ) {
+  return otpModel.updateOne( query, record, { upsert: true } );
+}
+
+export const aggregate = async ( query = {} ) => {
+  return otpModel.aggregate( query );
+};

package/src/services/planogram.service.js

@@ -1,12 +1,5 @@
-import model from 'tango-api-schema';
-import { createLoggableService } from '../logging/createLoggableService.js';
-
-const _methods = {
-  async findOne( query ={}, field={} ) {
-    return model.planogramModel.findOne( query, field );
-  },
-};
-
-const _svc = createLoggableService( _methods, 'planograms' );
-
-export const findOne = ( ...args ) => _svc.findOne( ...args );
+import model from 'tango-api-schema';
+
+export const findOne = async ( query ={}, field={} ) => {
+  return model.planogramModel.findOne( query, field );
+};

package/src/services/processedTaskConfig.service.js

@@ -1,40 +1,32 @@
-import model from 'tango-api-schema';
-import { createLoggableService } from '../logging/createLoggableService.js';
-
-const _methods = {
-  async find( query = {}, field={} ) {
-    return model.taskProcessedConfigModel.find( query, field );
-  },
-  async findOne( query = {}, field={} ) {
-    return model.taskProcessedConfigModel.findOne( query, field );
-  },
-  async updateMany( query = {}, record={} ) {
-    return model.taskProcessedConfigModel.updateMany( query, { $set: record } );
-  },
-  async updateOne( query = {}, record={} ) {
-    return model.taskProcessedConfigModel.updateOne( query, { $set: record } );
-  },
-  async insertMany( data = [] ) {
-    return model.taskProcessedConfigModel.insertMany( data );
-  },
-  async deleteMany( query = [] ) {
-    return model.taskProcessedConfigModel.deleteMany( query );
-  },
-  async aggregate( query = [] ) {
-    return model.taskProcessedConfigModel.aggregate( query );
-  },
-  async insert( data = [] ) {
-    return model.taskProcessedConfigModel.create( data );
-  },
-};
-
-const _svc = createLoggableService( _methods, 'processedtaskconfigs' );
-
-export const find       = ( ...args ) => _svc.find( ...args );
-export const findOne    = ( ...args ) => _svc.findOne( ...args );
-export const updateMany = ( ...args ) => _svc.updateMany( ...args );
-export const updateOne  = ( ...args ) => _svc.updateOne( ...args );
-export const insertMany = ( ...args ) => _svc.insertMany( ...args );
-export const deleteMany = ( ...args ) => _svc.deleteMany( ...args );
-export const aggregate  = ( ...args ) => _svc.aggregate( ...args );
-export const insert     = ( ...args ) => _svc.insert( ...args );
+import model from 'tango-api-schema';
+
+export const find = async ( query = {}, field={} ) => {
+  return model.taskProcessedConfigModel.find( query, field );
+};
+
+export const findOne = async ( query = {}, field={} ) => {
+  return model.taskProcessedConfigModel.findOne( query, field );
+};
+
+export const updateMany = async ( query = {}, record={} ) => {
+  return model.taskProcessedConfigModel.updateMany( query, { $set: record } );
+};
+export const updateOne = async ( query = {}, record={} ) => {
+  return model.taskProcessedConfigModel.updateOne( query, { $set: record } );
+};
+
+export const insertMany = async ( data = [] ) => {
+  return model.taskProcessedConfigModel.insertMany( data );
+};
+
+export const deleteMany = async ( query = [] ) => {
+  return model.taskProcessedConfigModel.deleteMany( query );
+};
+
+export const aggregate = async ( query = [] ) => {
+  return model.taskProcessedConfigModel.aggregate( query );
+};
+
+export const insert = async ( data = [] ) => {
+  return model.taskProcessedConfigModel.create( data );
+};

package/src/services/processedTaskList.service.js

@@ -1,36 +1,30 @@
-import model from 'tango-api-schema';
-import { createLoggableService } from '../logging/createLoggableService.js';
-
-const _methods = {
-  async find( query = {}, field={} ) {
-    return model.taskProcessedModel.find( query, field );
-  },
-  async findOne( query = {}, field={} ) {
-    return model.taskProcessedModel.findOne( query, field );
-  },
-  async updateMany( query = {}, record={} ) {
-    return model.taskProcessedModel.updateMany( query, { $set: record } );
-  },
-  async insertMany( data = [] ) {
-    return model.taskProcessedModel.insertMany( data );
-  },
-  async deleteMany( query = [] ) {
-    return model.taskProcessedModel.deleteMany( query );
-  },
-  async aggregate( query = [] ) {
-    return model.taskProcessedModel.aggregate( query );
-  },
-  updateOne( query = {}, record = {} ) {
-    return model.taskProcessedModel.updateOne( query, { $set: record } );
-  },
-};
-
-const _svc = createLoggableService( _methods, 'processedtasks' );
-
-export const find       = ( ...args ) => _svc.find( ...args );
-export const findOne    = ( ...args ) => _svc.findOne( ...args );
-export const updateMany = ( ...args ) => _svc.updateMany( ...args );
-export const insertMany = ( ...args ) => _svc.insertMany( ...args );
-export const deleteMany = ( ...args ) => _svc.deleteMany( ...args );
-export const aggregate  = ( ...args ) => _svc.aggregate( ...args );
-export const updateOne  = ( ...args ) => _svc.updateOne( ...args );
+import model from 'tango-api-schema';
+
+export const find = async ( query = {}, field={} ) => {
+  return model.taskProcessedModel.find( query, field );
+};
+
+export const findOne = async ( query = {}, field={} ) => {
+  return model.taskProcessedModel.findOne( query, field );
+};
+
+export const updateMany = async ( query = {}, record={} ) => {
+  return model.taskProcessedModel.updateMany( query, { $set: record } );
+};
+
+export const insertMany = async ( data = [] ) => {
+  return model.taskProcessedModel.insertMany( data );
+};
+
+export const deleteMany = async ( query = [] ) => {
+  return model.taskProcessedModel.deleteMany( query );
+};
+
+export const aggregate = async ( query = [] ) => {
+  return model.taskProcessedModel.aggregate( query );
+};
+
+export const updateOne = ( query = {}, record = {} ) => {
+  return model.taskProcessedModel.updateOne( query, { $set: record } );
+};
+