tango-app-api-payment-subscription 3.0.62-dev → 3.0.63-dev

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "tango-app-api-payment-subscription",
-    "version": "3.0.62-dev",
+    "version": "3.0.63-dev",
     "description": "paymentSubscription",
     "main": "index.js",
     "type": "module",

package/src/controllers/billing.controllers.js

@@ -2,6 +2,7 @@ import { download, logger } from 'tango-app-api-middleware';
 import { aggregate } from '../services/store.service.js';
 import * as invoice from '../services/invoice.service.js';
 import { aggregatebilling, countDocuments, create, deleteOne, find, findOne, updateMany, updateOne } from '../services/billing.service.js';
+import * as invoiceService from '../services/invoice.service.js';
 import mongoose from 'mongoose';
 import dayjs from 'dayjs';
 
@@ -470,7 +471,7 @@ export const getInvoices = async ( req, res ) => {
       filterEndDate = new Date( dayjs().subtract( 1, 'month' ).endOf( 'month' ).format( 'YYYY-MM-DD' ) );
     }
     if ( req.body?.filter && req.body.filter == 'last' ) {
-      filterStartDate = new Date( dayjs().subtract( 2, 'month' ).startOf( 'month' ).format( 'YYYY-MM-DD' ) );
+      filterStartDate = new Date( dayjs().subtract( 3, 'month' ).startOf( 'month' ).format( 'YYYY-MM-DD' ) );
       filterEndDate = new Date( dayjs().endOf( 'month' ).format( 'YYYY-MM-DD' ) );
     }
 
@@ -613,8 +614,8 @@ export const getInvoices = async ( req, res ) => {
 
         const billingDate = invoiceData.billingDate;
 
-        if ( !groups[billingDate] ) {
-          groups[billingDate] = {
+        if ( !groups[dayjs( billingDate ).format( 'MMMM' )] ) {
+          groups[dayjs( billingDate ).format( 'MMMM' )] = {
             summary: `Summary - ${dayjs( billingDate ).format( 'MMM YYYY' )}`,
             products: new Set(),
             stores: 0,
@@ -626,23 +627,23 @@ export const getInvoices = async ( req, res ) => {
           };
         }
 
-        groups[billingDate].invoices.push( invoiceData );
-        groups[billingDate].stores += invoiceData.stores;
-        groups[billingDate].totalAmount += invoiceData.totalAmount;
+        groups[dayjs( billingDate ).format( 'MMMM' )].invoices.push( invoiceData );
+        groups[dayjs( billingDate ).format( 'MMMM' )].stores += invoiceData.stores;
+        groups[dayjs( billingDate ).format( 'MMMM' )].totalAmount += invoiceData.totalAmount;
 
         if ( invoiceData.paymentStatus === 'unpaid' ) {
           const currentDate = dayjs();
           const givenDate = dayjs( invoiceData.billingDate );
           const daysDifference = currentDate.diff( givenDate, 'day' );
           if ( daysDifference <= invoiceData.paymentTerm && daysDifference >= 0 ) {
-            groups[billingDate].paymentStatus = 'due';
+            groups[dayjs( billingDate ).format( 'MMMM' )].paymentStatus = 'due';
           } else {
-            groups[billingDate].paymentStatus = 'unpaid';
+            groups[dayjs( billingDate ).format( 'MMMM' )].paymentStatus = 'unpaid';
           }
         }
 
         invoiceData.products.forEach( ( product ) => {
-          groups[billingDate].products.add( product );
+          groups[dayjs( billingDate ).format( 'MMMM' )].products.add( product );
         } );
       } );
 
@@ -669,4 +670,53 @@ export const getInvoices = async ( req, res ) => {
   }
 };
 
+export const onetimePayment = async ( req, res ) => {
+  try {
+    const invoice = await invoiceService.findOne( { invoice: req.params.invoice } );
+    if ( !invoice ) {
+      return res.sendError( 'Invoice not found', 404 );
+    }
+
+    const onetimefeeObj = {
+      amount: req.body.oneTimeFee,
+      productName: 'installationFee',
+      description: 'One time setup & installation',
+      month: dayjs( invoice.billingDate ).format( 'MMM YYYY' ),
+      HsnNumber: '998314',
+      price: 0,
+    };
+
+    await invoiceService.invoiceUpdateOne( { invoice: invoice.invoice }, { $push: { products: onetimefeeObj } } );
+
+
+    if ( invoice.currency === 'inr' ) {
+      let totalTaxRate = 0;
+
+      if ( invoice.tax.length ) {
+        for ( let i = 0; i<invoice._doc.tax.length; i++ ) {
+          totalTaxRate += invoice._doc.tax[i].value;
+          invoice._doc.tax[i].taxAmount = Number( invoice._doc.tax[i].taxAmount ) + ( req.body.oneTimeFee * invoice._doc.tax[i].value ) / 100;
+        }
+      }
+
+
+      invoice._doc.amount += req.body.oneTimeFee;
+
+      invoice._doc.totalAmount = ( ( invoice._doc.amount * totalTaxRate ) / 100 ) + invoice._doc.amount;
+    } else {
+      invoice._doc.amount += req.body.oneTimeFee;
+      invoice._doc.totalAmount += req.body.oneTimeFee;
+    }
+
+
+    await invoiceService.invoiceUpdateOne( { invoice: invoice.invoice }, { $set: { 'tax': invoice._doc.tax, 'amount': invoice._doc.amount, 'totalAmount': invoice._doc.totalAmount } } );
+
+
+    return res.sendSuccess( 'Fee added successfully to invoice' );
+  } catch ( error ) {
+    logger.error( { error: error, function: 'onetimePayment' } );
+    return res.sendError( error, 500 );
+  }
+};
+
 

package/src/controllers/payment.controller.js

@@ -1,17 +1,115 @@
 
-import { createOrder } from 'tango-app-api-middleware';
-import { findOneAccount } from '../services/paymentAccount.service.js';
+import { createOrder, download, logger } from 'tango-app-api-middleware';
+import { findOneAccount, updateOneAccount } from '../services/paymentAccount.service.js';
 import * as invoiceService from '../services/invoice.service.js';
+import { updateOrder, verifySignature, verifyWebhook } from 'tango-app-api-middleware/src/utils/razorPay.js';
+import { aggregateTransaction, createTransaction } from '../services/transaction.service.js';
+import dayjs from 'dayjs';
 
 
+export const getVirtualAccount = async ( req, res ) => {
+  try {
+    const account = await findOneAccount( { clientId: req.query.clientId }, { accountNumber: 1, ifsc: 1, branch: 1, paymentType: 1, credit: 1, currency: 1, _id: 0 } );
+
+    if ( !account ) {
+      return res.sendError( 'No data found', 204 );
+    }
+
+    return res.sendSuccess( account );
+  } catch ( error ) {
+    logger.error( { error: error, function: 'getVirtualAccount' } );
+    return res.sendError( error, 500 );
+  }
+};
+
+export const payUsingVallet = async ( req, res ) => {
+  try {
+    const invoice = await invoiceService.findOne( { invoice: req.params.invoice } );
+    if ( !invoice ) {
+      return res.sendError( 'Invoice not found', 404 );
+    }
+
+    const account = await findOneAccount( { clientId: invoice.clientId } );
+
+    if ( !account ) {
+      return res.sendError( 'Wallet not found', 404 );
+    }
+
+    if ( account.credit < invoice.totalAmount ) {
+      return res.sendError( 'Insufficient balance for payment', 409 );
+    }
+
+    const reducedCredit = Math.round( account.credit - invoice.totalAmount );
+
+    const deductFromVallet = await updateOneAccount( { clientId: invoice.clientId }, { credit: reducedCredit } );
+
+    let statusChange;
+
+    if ( deductFromVallet.modifiedCount ) {
+      statusChange = await invoiceService.updateOne( { invoice: req.params.invoice }, { paymentStatus: 'paid' } );
+
+      const transaction = {
+        clientId: account.clientId,
+        debtType: 'wallet',
+        billingDate: invoice.billingDate,
+        invoice: invoice.invoice,
+        groupName: invoice.groupName,
+        groupId: invoice.groupId,
+        amount: invoice.totalAmount,
+        currency: invoice.currency,
+        transactionType: 'debt',
+        balanceCredit: Math.round( account.credit - invoice.totalAmount ),
+        balanceCreditCurrency: account.currency,
+      };
+
+      await createTransaction( transaction );
+    }
+
+    if ( !statusChange?.modifiedCount ) {
+      logger.error( { error: { ...account, ...invoice }, function: 'payUsingVallet' } );
+    }
+
+    return res.sendSuccess( 'Payment successful !' );
+  } catch ( error ) {
+    logger.error( { error: error, function: 'payUsingVallet' } );
+    return res.sendError( error, 500 );
+  }
+};
+
 export const generateOrder = async ( req, res ) => {
   try {
-    const order = await createOrder( { amount: req.body.amount, currency: req.body.currency } );
+    const invoice = await invoiceService.findOne( { invoice: req.params.invoice } );
+    if ( !invoice ) {
+      return res.sendError( 'Invoice not found', 404 );
+    }
+    const orderData = {
+      amount: Number( Math.round( invoice.totalAmount ) + '00' ),
+      currency: invoice.currency === 'inr' ? 'INR' : 'USD',
+      receipt: invoice.invoice,
+    };
 
-    if ( !order ) {
-      return res.sendError( 'Failed to generate order id', 500 );
+    const createdOrder = await createOrder( orderData );
+
+    if ( !createdOrder ) {
+      return res.sendError( 'Payment order generation failed', 500 );
     }
 
+    const updatedOrder = await updateOrder( { orderId: createdOrder.id, notes: { oid: createdOrder.id } } );
+
+    if ( !updatedOrder ) {
+      return res.sendError( 'Failed to generate order', 500 );
+    }
+
+    await invoiceService.updateOne( { invoice: invoice.invoice }, { orderId: createdOrder.id } );
+
+    const order = {
+      ...createdOrder,
+      apiKey: process.env.RAZORPAY_KEY_ID,
+      name: req.user.userName,
+      email: req.user.email,
+      contact: req.user.mobileNumber,
+    };
+
     return res.sendSuccess( order );
   } catch ( error ) {
     logger.error( { error: error, function: 'generateOrder' } );
@@ -19,29 +117,223 @@ export const generateOrder = async ( req, res ) => {
   }
 };
 
-export const getVirtualAccount = async ( req, res ) => {
+export const verifyPayment = async ( req, res ) => {
   try {
-    const account = await findOneAccount( { clientId: req.query.clientId }, { accountNumber: 1, ifsc: 1, branch: 1, paymentType: 1, credit: 1, _id: 0 } );
+    const invoice = await invoiceService.findOne( { invoice: req.params.invoice } );
+    if ( !invoice ) {
+      return res.sendError( 'Invoice not found', 404 );
+    }
 
-    if ( !account ) {
-      return res.sendError( 'No data found', 204 );
+    const verify = await verifySignature( { razorpayOrderId: invoice.orderId, razorpayPaymentId: req.body.razorpay_payment_id, signature: req.body.razorpay_signature } );
+
+    if ( !verify ) {
+      return res.sendError( 'Invalid signature', 409 );
     }
 
-    return res.sendSuccess( account );
+    return res.sendSuccess( 'Payment successful !' );
   } catch ( error ) {
-    logger.error( { error: error, function: 'getVirtualAccount' } );
+    logger.error( { error: error, function: 'verifyPayment' } );
     return res.sendError( error, 500 );
   }
 };
 
-export const payUsingVallet = async ( req, res ) => {
+export const paymentHook = async ( req, res ) => {
   try {
-    const invoice = await invoiceService.findOne( { ivoice: req.params.invoice } );
-    if ( !invoice ) {
+    const signature = req.headers['x-razorpay-signature'];
+    const isValid = await verifyWebhook( { body: req.body, signature: signature } );
+    if ( isValid ) {
+      const { event, payload } = req.body;
+
+      switch ( event ) {
+        case 'payment.captured':
+          await handlePaymentCapture( payload );
+          break;
+        default:
+          logger.error( { error: payload, function: `Unhandled event: ${event}` } );
+          break;
+      }
+    }
+    res.status( 200 ).send();
+  } catch ( error ) {
+    logger.error( { error: error, function: 'paymentHook' } );
+    return res.sendError( error, 500 );
+  }
+};
+
+async function handlePaymentCapture( responseBody ) {
+  const paidInvoice = await invoiceService.findOne( { orderId: responseBody?.payment?.entity?.notes?.oid } );
+
+  if ( !paidInvoice ) {
+    return;
+  }
+
+  const account = await findOneAccount( { clientId: paidInvoice.clientId } );
+
+  await invoiceService.updateOne( { invoice: paidInvoice.invoice }, { paymentStatus: 'paid', paymentReferenceId: responseBody?.payment?.entity?.notes?.oid } );
+
+  const transaction = {
+    debtType: 'razor',
+    clientId: account.clientId,
+    billingDate: paidInvoice.billingDate,
+    invoice: paidInvoice.invoice,
+    groupName: paidInvoice.groupName,
+    groupId: paidInvoice.groupId,
+    amount: paidInvoice.totalAmount,
+    currency: paidInvoice.currency,
+    transactionType: 'debt',
+    balanceCredit: Math.round( account.credit ),
+    balanceCreditCurrency: account.currency,
+  };
+
+  await createTransaction( transaction );
+
+  return;
+}
+
+export const transactionList = async ( req, res ) => {
+  try {
+    const matchStage = {
+      $match: {
+        clientId: req.body.clientId,
+      },
+    };
+
+    let filterStartDate = '';
+    let filterEndDate = '';
+
+    if ( req.body?.filter && req.body.filter == 'current' ) {
+      filterStartDate = new Date( dayjs().startOf( 'month' ).format( 'YYYY-MM-DD' ) );
+      filterEndDate = new Date( dayjs().endOf( 'month' ).format( 'YYYY-MM-DD' ) );
+    }
+    if ( req.body?.filter && req.body.filter == 'prev' ) {
+      filterStartDate = new Date( dayjs().subtract( 1, 'month' ).startOf( 'month' ).format( 'YYYY-MM-DD' ) );
+      filterEndDate = new Date( dayjs().subtract( 1, 'month' ).endOf( 'month' ).format( 'YYYY-MM-DD' ) );
+    }
+    if ( req.body?.filter && req.body.filter == 'last' ) {
+      filterStartDate = new Date( dayjs().subtract( 3, 'month' ).startOf( 'month' ).format( 'YYYY-MM-DD' ) );
+      filterEndDate = new Date( dayjs().endOf( 'month' ).format( 'YYYY-MM-DD' ) );
+    }
+
+    if ( req.body?.filter && !req.body?.searchValue ) {
+      matchStage.$match['$and'] = [
+        { billingDate: { $gte: filterStartDate } },
+        { billingDate: { $lte: filterEndDate } },
+      ];
+    }
+
+    if ( req.body.searchValue ) {
+      matchStage.$match.$or = [
+        {
+          groupName: {
+            $regex: req.body.searchValue,
+            $options: 'i',
+          },
+        },
+      ];
+    }
+
+
+    const pipeline = [
+      matchStage,
+      {
+        $project: {
+          '_id': 1,
+          'groupName': 1,
+          'billingDate': 1,
+          'amount': 1,
+          'currency': 1,
+          'transactionType': 1,
+          'balanceCredit': 1,
+          'balanceCreditCurrency': 1,
+        },
+      },
+    ];
+
+    if ( req.body?.sortColumn && req.body?.sortBy ) {
+      pipeline.push(
+          {
+            $addFields: {
+              sortField: {
+                $toLower: `$${req.body.sortColumn}`,
+              },
+            },
+          },
+          {
+            $sort: {
+              [req.body.sortColumn]: req.body.sortBy,
+            },
+          },
+      );
+    }
+
+    pipeline.push(
+        {
+          $project: {
+            sortField: 0,
+          },
+        },
+
+    );
+
+    const facetStage = {
+      $facet: {
+        data: [
+          {
+            $skip: ( ( req.body.offset - 1 ) * req.body.limit ),
+          },
+          {
+            $limit: ( req.body.limit  ),
+          },
+        ],
+        pageInfo: [
+          {
+            $count: 'count',
+          },
+        ],
+      },
+    };
+
+    if ( req.body?.isExport ) {
+      facetStage.$facet.data = [];
+    }
+
+    pipeline.push( facetStage );
+
+    pipeline.push( {
+      $unwind: {
+        path: '$pageInfo',
+      },
+    } );
+
+    const transactionList = await aggregateTransaction( pipeline );
+
+    if ( !transactionList[0] ) {
       return res.sendError( 'No data found', 204 );
     }
+
+    if ( req.body.isExport ) {
+      const exportResult = [];
+      for ( let transaction of transactionList[0].data ) {
+        exportResult.push( {
+          'Billing date': transaction?.billingDate ? dayjs( transaction.billingDate ).format( 'DD MMM, YYYY' ) : '',
+          'Transaction': transaction?.transactionType === 'debt' ? `Consumption for ${dayjs( transaction?.billingDate ).format( 'MMM YYYY' )}- ${transaction?.groupName}` : 'Paid Credit',
+          'Debit': transaction?.transactionType === 'debt' ? `${transaction?.currency === 'inr' ? '₹' : '$'} ${transaction.amount}` : '',
+          'Credit': transaction?.transactionType === 'credit' ? `${transaction?.currency === 'inr' ? '₹' : '$'} ${transaction.amount}` : '',
+          'Balance credit': `${transaction?.balanceCreditCurrency === 'inr' ? '₹' : '$'} ${transaction.balanceCredit}` || '',
+
+        } );
+      }
+
+      await download( exportResult, res );
+      return;
+    }
+
+
+    return res.sendSuccess( transactionList[0] );
   } catch ( error ) {
-    logger.error( { error: error, function: 'payUsingVallet' } );
+    logger.error( { error: error, function: 'transactionList' } );
     return res.sendError( error, 500 );
   }
 };
+
+

package/src/dtos/isUniqueEvent.js

@@ -0,0 +1,16 @@
+
+import { logger } from 'tango-app-api-middleware';
+
+const processedEventIds = new Set();
+
+export const checkDuplicateEvent = ( req, res, next ) => {
+  const eventId = req.headers['x-razorpay-event-id'];
+
+  if ( processedEventIds.has( eventId ) ) {
+    logger.error( { error: `Duplicate event with ID ${eventId}. Skipping processing.`, function: 'checkDuplicateEvent' } );
+    res.status( 200 ).send();
+  } else {
+    processedEventIds.add( eventId );
+    next();
+  }
+};

package/src/dtos/validation.dtos.js

@@ -298,14 +298,14 @@ export const createBillingGroupBody = joi.object(
       groupName: joi.string().required(),
       groupTag: joi.string().required(),
       registeredCompanyName: joi.string().required(),
-      gst: joi.string().required(),
+      gst: joi.string().optional(),
       addressLineOne: joi.string().optional(),
       addressLineTwo: joi.string().optional(),
       city: joi.string().optional(),
       state: joi.string().optional(),
       country: joi.string().optional(),
       pinCode: joi.string().optional(),
-      placeOfSupply: joi.string().required(),
+      placeOfSupply: joi.string().optional(),
       po: joi.string().optional(),
       stores: joi.array().optional(),
       proRata: joi.string().optional(),
@@ -409,3 +409,31 @@ export const valletPayParam = joi.object().keys( {
 export const valletPayValid = {
   params: valletPayParam,
 };
+
+export const verifyPaymentParam = joi.object().keys( {
+  invoice: joi.string().required(),
+} );
+
+export const verifyPaymentBody = joi.object().keys( {
+  razorpay_payment_id: joi.string().required(),
+  razorpay_order_id: joi.string().required(),
+  razorpay_signature: joi.string().required(),
+} );
+
+export const verifyPaymentValid = {
+  params: verifyPaymentParam,
+  body: verifyPaymentBody,
+};
+
+export const onetimeFeeParam = joi.object().keys( {
+  invoice: joi.string().required(),
+} );
+
+export const onetimeFeeBody = joi.object().keys( {
+  oneTimeFee: joi.number().required(),
+} );
+
+export const onetimeFeeValid = {
+  params: onetimeFeeParam,
+  body: onetimeFeeBody,
+};

package/src/routes/billing.routes.js

@@ -1,8 +1,8 @@
 import express from 'express';
 export const billingRouter = express.Router();
 import { authorize, isAllowedSessionHandler, validate } from 'tango-app-api-middleware';
-import { createBillingGroup, deleteBillingGroup, getAllBillingGroups, getBillingGroups, getInvoices, subscribedStoreList, updateBillingGroup } from '../controllers/billing.controllers.js';
-import { billingGroupSchema, createBillingGroupsSchema, deleteBillingGroupsSchema, getBillingGroupsSchema, getInvoiceSchema, subscribedStoreListSchema, updateBillingGroupsSchema } from '../dtos/validation.dtos.js';
+import { createBillingGroup, deleteBillingGroup, getAllBillingGroups, getBillingGroups, getInvoices, onetimePayment, subscribedStoreList, updateBillingGroup } from '../controllers/billing.controllers.js';
+import { billingGroupSchema, createBillingGroupsSchema, deleteBillingGroupsSchema, getBillingGroupsSchema, getInvoiceSchema, onetimeFeeValid, subscribedStoreListSchema, updateBillingGroupsSchema } from '../dtos/validation.dtos.js';
 
 
 billingRouter.post( '/get-subscribed-store-list', isAllowedSessionHandler, authorize( {
@@ -48,3 +48,9 @@ billingRouter.post( '/get-invoices', isAllowedSessionHandler, authorize( {
   ],
 } ), validate( getInvoiceSchema ), getInvoices );
 
+billingRouter.post( '/onetime-payment/:invoice', isAllowedSessionHandler, authorize( {
+  userType: [ 'tango' ], access: [
+    { featureName: 'settings', name: 'paymentSubscriptions', permissions: [ 'isEdit' ] },
+  ],
+} ), validate( onetimeFeeValid ), onetimePayment );
+

package/src/routes/payment.routes.js

@@ -1,9 +1,10 @@
 import express from 'express';
 export const paymentRouter = express.Router();
 import { authorize, isAllowedSessionHandler, validate } from 'tango-app-api-middleware';
-import { generateOrder, payUsingVallet } from '../controllers/payment.controller.js';
+import { generateOrder, paymentHook, payUsingVallet, transactionList, verifyPayment } from '../controllers/payment.controller.js';
 import { getVirtualAccount } from '../controllers/payment.controller.js';
-import { getVirtualAccountSchema, valletPayValid } from '../dtos/validation.dtos.js';
+import { getInvoiceSchema, getVirtualAccountSchema, valletPayValid, verifyPaymentValid } from '../dtos/validation.dtos.js';
+import { checkDuplicateEvent } from '../dtos/isUniqueEvent.js';
 
 
 paymentRouter.get( '/get-virtual-account', isAllowedSessionHandler, authorize( {
@@ -12,15 +13,29 @@ paymentRouter.get( '/get-virtual-account', isAllowedSessionHandler, authorize( {
   ],
 } ), validate( getVirtualAccountSchema ), getVirtualAccount );
 
-paymentRouter.post( '/generate-order', isAllowedSessionHandler, authorize( {
+paymentRouter.get( '/wallet-pay/:invoice', isAllowedSessionHandler, authorize( {
   userType: [ 'tango' ], access: [
     { featureName: 'settings', name: 'paymentSubscriptions', permissions: [ 'isEdit' ] },
   ],
-} ), generateOrder );
+} ), validate( valletPayValid ), payUsingVallet );
 
-paymentRouter.get( '/wallet-pay/:invoice', isAllowedSessionHandler, authorize( {
+paymentRouter.get( '/generate-order/:invoice', isAllowedSessionHandler, authorize( {
   userType: [ 'tango' ], access: [
     { featureName: 'settings', name: 'paymentSubscriptions', permissions: [ 'isEdit' ] },
   ],
-} ), validate( valletPayValid ), payUsingVallet );
+} ), validate( valletPayValid ), generateOrder );
+
+paymentRouter.post( '/verify-payment/:invoice', isAllowedSessionHandler, authorize( {
+  userType: [ 'tango' ], access: [
+    { featureName: 'settings', name: 'paymentSubscriptions', permissions: [ 'isEdit' ] },
+  ],
+} ), validate( verifyPaymentValid ), verifyPayment );
+
+paymentRouter.post( '/get-transactions', isAllowedSessionHandler, authorize( {
+  userType: [ 'tango' ], access: [
+    { featureName: 'settings', name: 'paymentSubscriptions', permissions: [ 'isView' ] },
+  ],
+} ), validate( getInvoiceSchema ), transactionList );
+
+paymentRouter.post( '/payment-hook', checkDuplicateEvent, paymentHook );
 

package/src/services/invoice.service.js

@@ -26,6 +26,10 @@ export const count = async ( query ) => {
   return await model.invoiceModel.count( query );
 };
 
+export const invoiceUpdateOne = async ( query ={}, record={} ) => {
+  return await model.invoiceModel.updateOne( query, record );
+};
+
 export const deleteRecord = async ( query ) => {
   return await model.invoiceModel.deleteOne( query );
 };

package/src/services/paymentAccount.service.js

@@ -6,6 +6,9 @@ export const findOneAccount = ( query = {}, record = {} ) => {
   return model.paymentAccountModel.findOne( query, record );
 };
 
+export const updateOneAccount = async ( query ={}, record={} ) => {
+  return await model.paymentAccountModel.updateOne( query, { $set: record } );
+};
 export const aggregate = ( query = [] ) => {
   return model.paymentAccountModel.aggregate( query );
 };

package/src/services/transaction.service.js

@@ -0,0 +1,10 @@
+import model from 'tango-api-schema';
+
+
+export const createTransaction = async ( data ) => {
+  return await model.transactionModel.create( data );
+};
+
+export const aggregateTransaction = async ( query ={} ) => {
+  return await model.transactionModel.aggregate( query );
+};