tango-app-api-payment-subscription 3.0.3 → 3.0.5

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "tango-app-api-payment-subscription",
-    "version": "3.0.3",
+    "version": "3.0.5",
     "description": "paymentSubscription",
     "main": "index.js",
     "type": "module",
@@ -14,12 +14,13 @@
     "license": "ISC",
     "dependencies": {
         "aws-sdk": "^2.1572.0",
+        "dayjs": "^1.11.10",
         "dotenv": "^16.4.5",
         "express": "^4.18.3",
         "handlebars": "^4.7.8",
         "mongodb": "^6.4.0",
         "nodemon": "^3.1.0",
-        "tango-api-schema": "^2.0.4",
+        "tango-api-schema": "^2.0.41",
         "tango-app-api-middleware": "^1.0.15",
         "winston": "^3.12.0",
         "winston-daily-rotate-file": "^5.0.0"

package/src/controllers/paymentSubscription.controllers.js

@@ -1,20 +1,20 @@
 import { logger } from 'tango-app-api-middleware';
-import paymentService from '../services/paymentSubscription.services.js';
-// import mongoose from 'mongoose';
-// const ObjectId = mongoose.Types.ObjectId;
+import * as paymentService from '../services/clientPayment.services.js';
+import * as storeService from '../services/store.service.js';
+import * as basePricingService from '../services/basePrice.service.js';
+import * as clientRequestService from '../services/clientRequest.service.js';
+import mongoose from 'mongoose';
+import dayjs from 'dayjs';
+const ObjectId = mongoose.Types.ObjectId;
 
 
 export const addBilling = async ( req, res ) => {
   try {
-    let details = await paymentService.findOne( { _id: req.body.client }, { _id: 1 } );
-    if ( !details ) {
-      return res.sendNoContent( 'client Not Found' );
-    }
     let params = {
       'billingDetails.gstNumber': req.body.gstNo,
       'billingDetails.billingAddress': req.body.billingAddress,
     };
-    let result = await paymentService.updateOne( { _id: req.body.client }, params );
+    let result = await paymentService.updateOne( { _id: req.body.clientId }, params );
     if ( result.modifiedCount ) {
       logger.info( 'Billing Details Added Successfully' );
       return res.sendSuccess( { message: 'Bank Details Added Successfully' } );
@@ -32,27 +32,41 @@ export const addBilling = async ( req, res ) => {
 
 export const billingInfo = async ( req, res, next ) => {
   try {
-    let clientInfo;
-    clientInfo = await paymentService.findOne( { _id: req.params.clientId } );
+    let query = [
+      {
+        $match: {
+          _id: new ObjectId( req.params.clientId ),
+          status: 'active',
+        },
+      },
+      {
+        $project: {
+          clientName: 1,
+          _id: 1,
+          planDetails: 1,
+          billingDetails: 1,
+          price: 1,
+          priceType: 1,
+          virtualAccount: 1,
+        },
+      },
+      {
+        $project: {
+          'planDetails.product._id': 0,
+        },
+      },
+    ];
+    let clientInfo = await paymentService.aggregate( query );
     if ( !clientInfo ) {
       return res.sendNoContent( 'Client is not Found' );
     }
-    let storeCount = await paymentService.storeCount( { clientId: clientInfo.clientId } );
+    let storeCount = await storeService.count( { clientId: clientInfo.clientId } );
 
-    let virtualBankInfo = await paymentService.VirtualAccFind( {}, { _id: 0, createdAt: 0, updatedAt: 0 } );
-    let description;
-    if ( clientInfo?.planDetails?.subscriptionType && clientInfo?.planDetails?.subscriptionType == 'free' ) {
-      description = 'You will not be billed during your free subscription. To explore other products, upgrade to a paid subscription.';
-    } else if ( clientInfo?.planDetails?.subscriptionType && clientInfo.planDetails.subscriptionType == 'premium' ) {
-      description = 'You will not be billed during your free trial.To keep your dashboard running after the trial end, upgrade to a paid subscription.';
-    } else if ( clientInfo?.planDetails?.subscriptionType && clientInfo.planDetails.subscriptionType == 'enterprice' ) {
-      description = 'You will not be billed during your free trial.To keep your dashboard running after the trial end, upgrade to a paid subscription.';
-    }
     let data = {
-      clientDetails: clientInfo,
-      bankDetails: virtualBankInfo,
-      storeCount: storeCount,
-      description: description,
+      _id: clientInfo[0]._id,
+      currentPlanInfo: { ...clientInfo[0].planDetails, storeCount: storeCount, price: clientInfo[0].price, priceType: clientInfo[0].priceType },
+      billingDetails: { ...clientInfo[0].billingDetails, nextBillingDate: '--' },
+      BankDetails: clientInfo[0].virtualAccount,
     };
 
     return res.sendSuccess( data );
@@ -65,7 +79,7 @@ export const billingInfo = async ( req, res, next ) => {
 
 export const getStoreList = async ( req, res ) => {
   try {
-    let storeList = await paymentService.storeFind( { clientId: req.query.clientId, status: 'active' }, { _id: 1, storeId: 1, storeName: 1 } );
+    let storeList = await storeService.find( { clientId: req.query.clientId, status: 'active' }, { _id: 1, storeId: 1, storeName: 1 } );
 
     if ( !storeList.length ) {
       return res.sendNoContent( 'No Stores Found' );
@@ -80,7 +94,7 @@ export const getStoreList = async ( req, res ) => {
 
 export const getClientList = async ( req, res ) => {
   try {
-    let storeList = await paymentService.find( {}, { clientId: 1, _id: 1, clientName: 1 } );
+    let storeList = await paymentService.find( { status: 'active' }, { clientId: 1, _id: 1, clientName: 1 } );
 
     if ( !storeList.length ) {
       return res.sendNoContent( 'No Stores Found' );
@@ -114,10 +128,11 @@ export const pricingInfo = async ( req, res ) => {
         },
       },
     ];
-    let pricingDetails = await paymentService.getprice( query );
+    let pricingDetails = await basePricingService.aggregate( query );
 
     return res.sendSuccess( { price: pricingDetails } );
   } catch ( e ) {
+    console.log( 'pricingInfo=>', e );
     logger.error( e );
     return res.sendError( e, 500 );
   }
@@ -125,22 +140,28 @@ export const pricingInfo = async ( req, res ) => {
 
 export const updateSubscription = async ( req, res ) => {
   try {
-    let clientDetails = await paymentService.findOne( { _id: req.params.clientId }, { _id: 1 } );
-    if ( !clientDetails ) {
-      return res.sendNoContent( 'No Content' );
-    }
-    let features = req.body.clientDetails.planDetails.subscribedFeatures;
-    for ( const key in features ) {
-      if ( features[key].active ) {
-        features[key].status = 'live';
-        features[key].subscribedDate = new Date();
+    let price = req.body.currentPlanInfo.price;
+    let priceType = req.body.currentPlanInfo.priceType;
+    delete req.body.currentPlanInfo.price;
+    delete req.body.currentPlanInfo.priceType;
+    delete req.body.currentPlanInfo.storeCount;
+    let products = req.body.currentPlanInfo.product;
+    products.forEach( ( element, index ) => {
+      if ( !element.subscribedDate || element.subscribedDate != null ) {
+        req.body.currentPlanInfo.product[index].subscribedDate = new Date();
+        req.body.currentPlanInfo.product[index].status = 'live';
+        req.body.currentPlanInfo.product[index].trialStartDate = element?.trialStartDate || '';
+        req.body.currentPlanInfo.product[index].trialEndDate = element?.trialEndDate || '';
       }
-    }
-    req.body.clientDetails.planDetails.subscribedFeatures = features;
-    let input = req.body.clientDetails;
+    } );
+    let details = {
+      planDetails: req.body.currentPlanInfo,
+      price: price,
+      priceType: priceType,
+    };
 
-    let result = await paymentService.updateOne( { _id: req.params.clientId }, input );
-    console.log( input );
+    let result = await paymentService.updateOne( { _id: req.params.clientId }, details );
+    console.log( details );
 
     if ( result.modifiedCount ) {
       return res.sendSuccess( { message: 'Subscription Updated Successfully' } );
@@ -153,3 +174,455 @@ export const updateSubscription = async ( req, res ) => {
     return res.sendError( e, 500 );
   }
 };
+
+export const trailProductList = async ( req, res ) => {
+  try {
+    let date = new Date();
+    let getClientInfo = await paymentService.findOne( { '_id': req.query.clientId, 'status': 'active', 'planDetails.product.status': 'trail' }, { 'planDetails.product': 1 } );
+
+    if ( !getClientInfo ) {
+      return res.sendNoContent();
+    }
+    let products;
+    if ( getClientInfo.planDetails.product.length ) {
+      products = getClientInfo.planDetails.product.filter( ( item ) => item.trialEndDate >= date ).map( ( item ) => item.productName );
+    }
+    return res.sendSuccess( products );
+  } catch ( e ) {
+    console.log( 'trialRequest =>', e );
+    logger.error( e );
+    return res.sendError( e, 500 );
+  }
+};
+
+export const unsubscribeProduct = async ( req, res ) => {
+  try {
+    let checkExistRequest = await clientRequestService.findOne( { client: req.body.clientId, status: 'pending' } );
+    if ( checkExistRequest ) {
+      return res.sendSuccess( 'Request is Already initiated waiting for admin approval' );
+    }
+    let params = {
+      user: '65e966e12b1991393cf8ce30', // need to login user id here
+      client: req.body.client._id,
+      clientId: req.body.client.clientId,
+      reason: req.body.reason,
+      description: req.body.description,
+      category: 'Request for unsubscribe',
+      status: 'pending',
+    };
+    await clientRequestService.insert( params );
+
+    return res.sendSuccess( 'Request Send Successfully' );
+  } catch ( e ) {
+    console.log( 'unsubscribeProduct =>', e );
+    logger.error( e );
+    return res.sendError( e, 500 );
+  }
+};
+
+export const trialExtendRequest = async ( req, res ) => {
+  try {
+    let checkExistRequest = await clientRequestService.findOne( { client: req.body.clientId, status: 'pending' } );
+    if ( checkExistRequest ) {
+      return res.sendSuccess( 'Request is Already initiated waiting for admin approval' );
+    }
+    let params = {
+      user: '65e966e12b1991393cf8ce30', // need to login user id here
+      client: req.body.client._id,
+      clientId: req.body.client.clientId,
+      name: req.body.product,
+      description: 'Request for extend Trail',
+      category: 'TrailExtend',
+      status: 'pending',
+    };
+    await clientRequestService.insert( params );
+
+    return res.sendSuccess( 'Request Send Successfully' );
+  } catch ( e ) {
+    console.log( 'trialExtendRequest =>', e );
+    logger.error( e );
+    return res.sendError( e, 500 );
+  }
+};
+
+
+export const trialRequest = async ( req, res ) => {
+  try {
+    let checkExistRequest = await clientRequestService.findOne( { client: req.body.clientId, status: 'pending' } );
+    if ( checkExistRequest ) {
+      return res.sendSuccess( 'Request is Already initiated waiting for admin approval' );
+    }
+    let params = {
+      user: '65e966e12b1991393cf8ce30', // need to login user id here
+      client: req.body.client._id,
+      clientId: req.body.client.clientId,
+      name: req.body.product,
+      description: 'Request for Trail',
+      category: 'Trail',
+      status: 'pending',
+    };
+    await clientRequestService.insert( params );
+
+    return res.sendSuccess( 'Request Send Successfully' );
+  } catch ( e ) {
+    console.log( 'trialExtendRequest =>', e );
+    logger.error( e );
+    return res.sendError( e, 500 );
+  }
+};
+
+export const invoiceDetails = async ( req, res ) => {
+  try {
+    let clientInvoiceDetails = await paymentService.findOne( { _id: req.params.clientId, status: 'active' }, { paymentInvoice: 1 } );
+    if ( !clientInvoiceDetails ) {
+      return res.sendNoContent( 'No client Found' );
+    }
+    let data = {
+      proRate: clientInvoiceDetails?.paymentInvoice?.proRate || '',
+      paymenttype: clientInvoiceDetails?.paymentInvoice?.paymentType || '',
+      paymentCycle: clientInvoiceDetails?.paymentInvoice?.paymentCycle || '',
+      currencyType: clientInvoiceDetails?.paymentInvoice?.currencyType || '',
+      invoiceTo: clientInvoiceDetails?.paymentInvoice?.invoiceTo || [],
+      paymentAgreementTo: clientInvoiceDetails?.paymentInvoice?.paymentAgreementTo || [],
+      invoiceOn: clientInvoiceDetails?.paymentInvoice?.invoiceOn || '',
+      extendPaymentPeriodDays: clientInvoiceDetails?.paymentInvoice?.extendPaymentPeriodDays || '',
+    };
+    return res.sendSuccess( data );
+  } catch ( e ) {
+    console.log( 'invoiceDetails =>', e );
+    logger.error( e );
+    return res.sendError( e, 500 );
+  }
+};
+
+
+export const updateInvoiceDetails = async ( req, res ) => {
+  try {
+    let clientInvoiceDetails = await paymentService.findOne( { _id: req.params.clientId, status: 'active' }, { paymentInvoice: 1 } );
+    if ( !clientInvoiceDetails ) {
+      return res.sendNoContent( 'No client Found' );
+    }
+    let data = req.body;
+    clientInvoiceDetails.paymentInvoice.proRate = data.proRate;
+    clientInvoiceDetails.paymentInvoice.paymentType = data.paymenttype;
+    clientInvoiceDetails.paymentInvoice.paymentCycle = data.paymentCycle;
+    clientInvoiceDetails.paymentInvoice.currencyType = data.currencyType;
+    clientInvoiceDetails.paymentInvoice.invoiceTo = data.invoiceTo;
+    clientInvoiceDetails.paymentInvoice.paymentAgreementTo = data.paymentAgreementTo;
+    clientInvoiceDetails.paymentInvoice.invoiceOn = data.invoiceOn;
+    clientInvoiceDetails.paymentInvoice.extendPaymentPeriodDays = data.extendPaymentPeriodDays;
+    clientInvoiceDetails.save().then( () => {
+      return res.sendSuccess( 'Invoice Updated Successfully' );
+    } ).catch( ( e ) => {
+      return res.sendError( e );
+    } );
+  } catch ( e ) {
+    console.log( 'invoiceDetails =>', e );
+    logger.error( e );
+    return res.sendError( e, 500 );
+  }
+};
+
+
+export const notificationList = async ( req, res ) => {
+  try {
+    let query = {};
+    query.status = 'pending';
+    if ( req?.query?.clientId ) {
+      query.client = req?.query?.clientId;
+    }
+    let notificationList = await clientRequestService.find( query, { createdAt: 0, updatedAt: 0 } );
+    if ( !notificationList.length ) {
+      return res.sendNoContent( 'no list found' );
+    }
+    return res.sendSuccess( notificationList );
+  } catch ( e ) {
+    console.log( 'approvalList =>', e );
+    logger.error( e );
+    return res.sendError( e, 500 );
+  }
+};
+
+
+export const trialApproval = async ( req, res ) => {
+  try {
+    let requestData = await clientRequestService.findOne( { _id: req.body.id } );
+    if ( !requestData ) {
+      return res.sendNoContent();
+    }
+    requestData.status = 'complete';
+    requestData.save().then( async () => {
+      if ( req.body.type == 'approve' ) {
+        let clientProducts = await paymentService.findOne( { _id: requestData.client, status: 'active' }, { planDetails: 1 } );
+        if ( !clientProducts ) {
+          return res.sendNoContent( 'No client Found' );
+        }
+        let productIndex = clientProducts.planDetails.product.findIndex( ( item ) => item.productName == requestData.name );
+        if ( productIndex != -1 ) {
+          clientProducts.planDetails.product[productIndex].status =
+          clientProducts.planDetails.product[productIndex].status = 'trail';
+          clientProducts.planDetails.product[productIndex].trialStartDate = new Date();
+          clientProducts.planDetails.product[productIndex].trialEndDate = new Date( dayjs().add( 13, 'days' ).format( 'YYYY-MM-DD' ) );
+        } else {
+          clientProducts.planDetails.product.push( {
+            productName: requestData.name,
+            status: 'trail',
+            trialStartDate: new Date(),
+            trialEndDate: new Date( dayjs().add( 13, 'days' ).format( 'YYYY-MM-DD' ) ),
+          } );
+        }
+        clientProducts.save();
+      }
+      return res.sendSuccess( 'updated Successfully' );
+    } );
+  } catch ( e ) {
+    console.log( 'approvalList =>', e );
+    logger.error( e );
+    return res.sendError( e, 500 );
+  }
+};
+
+
+export const trialExtendRequestApproval = async ( req, res ) => {
+  try {
+    let clientDetails = await paymentService.findOne( { _id: req.body.client, status: 'active' }, { planDetails: 1 } );
+    if ( !clientDetails ) {
+      return res.sendNoContent();
+    }
+    clientDetails.planDetails.product.forEach( ( item ) => {
+      if ( item.productName == req.body.product && item.status == 'trail' ) {
+        item.trialEndDate = new Date( dayjs( item.trialEndDate ).add( req.body.days, 'days' ).format( 'YYYY-MM-DD' ) );
+      }
+    } );
+    clientDetails.save().then( async () => {
+      let requestData = await clientRequestService.findOne( { client: req.body.client, status: 'pending', name: req.body.product, category: 'TrailExtend' } );
+      if ( requestData ) {
+        requestData.status = 'complete';
+        requestData.save();
+      }
+      return res.sendSuccess( 'Trial Extended Successfully' );
+    } ).catch( ( e ) => {
+      return res.sendError( e, 500 );
+    } );
+  } catch ( e ) {
+    console.log( 'trialExtendRequestApproval =>', e );
+    logger.error( e );
+    return res.sendError( e );
+  }
+};
+
+export const productSubscribe = async ( req, res ) => {
+  try {
+    let clientinfo = await paymentService.findOne( { _id: req.body.clientId, status: 'active' }, { planDetails: 1 } );
+    if ( !clientinfo ) {
+      return res.sendNoContent();
+    }
+    let productIndex = clientinfo.planDetails.product.findIndex( ( item ) => item.productName == req.body.product );
+    if ( productIndex != -1 ) {
+      clientinfo.planDetails.product[productIndex].status = 'live',
+      clientinfo.planDetails.product[productIndex].subscribedDate = new Date();
+    } else {
+      clientinfo.planDetails.product.push(
+          {
+            productName: req.body.product,
+            status: 'live',
+            subscribedDate: new Date(),
+          },
+      );
+    }
+
+    clientinfo.save().then( async () => {
+      return res.sendSuccess( 'Product Subscribed Successfully' );
+    } );
+  } catch ( e ) {
+    console.log( 'updateProductSubscribe =>', e );
+    logger.error( e );
+    return res.sendError( e, 500 );
+  }
+};
+
+export const unsubscribeApproval = async ( req, res ) => {
+  try {
+    let requestData = await clientRequestService.findOne( { _id: req.body.id, status: 'pending' } );
+    if ( !requestData ) {
+      return res.sendNoContent();
+    }
+    requestData.status = 'complete';
+    requestData.save().then( async () => {
+      if ( req.body.type == 'unsubscribe' ) {
+        let clientProducts = await paymentService.findOne( { _id: requestData.client, status: 'active' }, { status: 1 } );
+        if ( !clientProducts ) {
+          return res.sendNoContent( 'No client Found' );
+        }
+        clientProducts.status = 'deactive';
+        clientProducts.save();
+      }
+      return res.sendSuccess( 'updated Successfully' );
+    } );
+  } catch ( e ) {
+    console.log( 'subscribeApproval =>', e );
+    logger.error( e );
+    return res.sendError( e, 500 );
+  }
+};
+
+export const productViewList = async ( req, res ) => {
+  try {
+    let query = [
+      {
+        $match: {
+          clientId: req.body.client.clientId,
+          status: 'active',
+        },
+      },
+      { $unwind: '$product' },
+      {
+        $group: {
+          '_id': '$product',
+          'count': { $sum: 1 },
+        },
+      },
+      {
+        $project: {
+          _id: 0,
+          product: '$_id',
+          storeCount: '$count',
+        },
+      },
+    ];
+    let storeProductCount = await storeService.aggregate( query );
+    if ( !storeProductCount.length ) {
+      return res.sendNoContent();
+    }
+    let productPrice = await basePricingService.find();
+    storeProductCount.forEach( ( item ) => {
+      let productBasePrice = productPrice.find( ( product ) => product.product_name == item.product );
+      if ( productBasePrice ) {
+        item.basePrice = productBasePrice.base_price;
+      }
+    } );
+    return res.sendSuccess( storeProductCount );
+  } catch ( e ) {
+    console.log( 'productViewList =>', e );
+    logger.error( e );
+    return res.sendError( e, 500 );
+  }
+};
+
+export const storeViewList = async ( req, res ) => {
+  try {
+    let limit = req.body?.limit || 10;
+    let offset = req.body.offset || 0;
+    let skip = offset * limit;
+    let query = [
+      {
+        $match: {
+          clientId: req.body.client.clientId,
+          status: 'active',
+        },
+      },
+    ];
+
+    if ( req.body?.searchValue && req.body.searchValue != '' ) {
+      query.push(
+          {
+            $match: {
+              $or: [
+                { storeName: { $regex: req.body?.searchValue } },
+                { storeId: { $regex: req.body?.searchValue } },
+              ],
+            },
+          },
+      );
+    }
+
+    if ( req.body?.product && req.body.product.length ) {
+      query.push(
+          {
+            $match: {
+              product: { $in: req.body?.product },
+            },
+          },
+      );
+    }
+
+    if ( req.body?.store && req.body.store.length ) {
+      query.push(
+          {
+            $match: {
+              storeName: { $in: req.body?.store },
+            },
+          },
+      );
+    }
+
+    if ( req.body?.location && req.body.location.length ) {
+      query.push(
+          {
+            $match: {
+              'storeProfile.city': req.body.location,
+            },
+          },
+      );
+    }
+
+    if ( req.body?.sortColumn && req.body.sortColumn != '' && req.body.sortBy != '' ) {
+      query.push( { $sort: { [req.body.sortColumn]: req.body.sortBy } } );
+    }
+    let storeCount = await storeService.aggregate( query );
+
+    query.push( { $skip: skip }, { $limit: limit } );
+
+    let storeDetails = await storeService.aggregate( query );
+
+    if ( !storeDetails.length ) {
+      return res.sendNoContent();
+    }
+    let data = {
+      count: storeCount.length,
+      data: storeDetails,
+    };
+
+    return res.sendSuccess( data );
+  } catch ( e ) {
+    console.log( 'storeViewList =>', e );
+    logger.error( e );
+    return res.sendError( e, 500 );
+  }
+};
+
+export const storeLocationList = async ( req, res ) => {
+  try {
+    let storeDetails = await storeService.find( { clientId: req.body.client.clientId, status: 'active' }, { 'storeId': 1, 'storeName': 1, 'storeProfile.city': 1 } );
+    if ( !storeDetails.length ) {
+      return res.sendNoContent();
+    }
+    let store = storeDetails.map( ( item ) => {
+      return { id: item.id, storeId: item.storeId, storeName: item.storeName };
+    } );
+    let location = storeDetails.filter( ( item ) => item.storeProfile.city != '' && item.storeProfile.city != null && typeof ( item.storeProfile.city ) != undefined ).map( ( item ) => item.storeProfile.city );
+    let productDetails = await basePricingService.find( {}, { product_name: 1, _id: 0 } );
+    let product = productDetails.map( ( item ) => item.product_name );
+    return res.sendSuccess( { store, location, product } );
+  } catch ( e ) {
+    console.log( 'storeLocationList =>', e );
+    logger.error( e );
+    return res.sendError( e, 500 );
+  }
+};
+
+
+export const addStoreProduct = async ( req, res ) => {
+  try {
+    let storeDetails = await storeService.find( { storeName: { $in: req.body.store }, clientId: req.body.client.clientId } );
+    if ( !storeDetails.length ) {
+      return res.sendNoContent();
+    }
+    await storeService.updateProduct( { storeName: { $in: req.body.store }, clientId: req.body.client.clientId }, req.body.product );
+    return res.sendSuccess( 'product updated Successfully' );
+  } catch ( e ) {
+    console.log( 'addStoreProduct => ', e );
+    logger.error( e );
+    return res.sendError( e, 500 );
+  }
+};

package/src/dtos/validation.dtos.js

@@ -2,7 +2,7 @@ import joi from 'joi';
 
 export const validateBillingParams = {
   body: joi.object( {
-    client: joi.string().required(),
+    clientId: joi.string().required(),
     gstNo: joi.string().required(),
     billingAddress: joi.string().required(),
   } ),
@@ -20,9 +20,8 @@ export const validateStoreParams = {
   } ),
 };
 
-
 export const validateProducts = {
-  post: joi.object( {
+  body: joi.object( {
     camara_per_sqft: joi.string().required(),
     currency_type: joi.string().required(),
     plan_name: joi.string().required(),
@@ -30,3 +29,58 @@ export const validateProducts = {
     stores_count: joi.string().required(),
   } ),
 };
+
+export const validateunsubscribeParams = {
+  body: joi.object( {
+    reason: joi.string().required(),
+    description: joi.string().required(),
+    clientId: joi.string().required(),
+  } ),
+};
+
+export const validateTrailExtendandSubscibeParams = {
+  body: joi.object( {
+    product: joi.string().required(),
+    clientId: joi.string().required(),
+  } ),
+};
+
+export const validateTrailandUnsubscribeParams = {
+  body: joi.object( {
+    id: joi.string().required(),
+    type: joi.string().required(),
+  } ),
+};
+
+
+export const validateTrailExtendRequestParams = {
+  body: joi.object( {
+    client: joi.string().required(),
+    days: joi.string().required(),
+    product: joi.string().required(),
+  } ),
+};
+
+
+export const validateStoreViewParams = {
+  body: joi.object( {
+    limit: joi.number().required(),
+    offset: joi.number().required(),
+    clientId: joi.string().required(),
+    sortColumn: joi.string().optional(),
+    sortBy: joi.number().optional(),
+    searchValue: joi.string().optional(),
+    product: joi.array().optional(),
+    store: joi.array().optional(),
+    location: joi.array().optional(),
+  } ),
+};
+
+export const validateAddStoreProductParams = {
+  body: joi.object( {
+    clientId: joi.string().required(),
+    store: joi.array().required(),
+    product: joi.array().required(),
+  } ),
+};
+

package/src/routes/paymentSubscription.routes.js

@@ -1,17 +1,31 @@
 
 import express from 'express';
-import { addBilling, billingInfo, getStoreList, getClientList, pricingInfo, updateSubscription } from '../controllers/paymentSubscription.controllers.js';
+import * as paymentController from '../controllers/paymentSubscription.controllers.js';
 import { validate } from 'tango-app-api-middleware';
-import { validateBillingParams, validateBrandParams, validateStoreParams, validateProducts } from '../dtos/validation.dtos.js';
-
+import * as validationDtos from '../dtos/validation.dtos.js';
+import { validateClient } from '../utils/validations/client.validation.js';
 export const paymentSubscriptionRouter = express.Router();
 
-paymentSubscriptionRouter.post( '/addBilling', validate( validateBillingParams ), addBilling );
-paymentSubscriptionRouter.get( '/clientBillingInfo/:clientId', validate( validateBrandParams ), billingInfo );
-paymentSubscriptionRouter.get( '/storeList', validate( validateStoreParams ), getStoreList );
-paymentSubscriptionRouter.get( '/clientList', getClientList );
-paymentSubscriptionRouter.post( '/basePricing', validate( validateProducts ), pricingInfo );
-paymentSubscriptionRouter.put( '/update/subscription/:clientId', validate( validateBrandParams ), updateSubscription );
-paymentSubscriptionRouter.put( '/startTrail/', validate( validateBrandParams ), updateSubscription );
+paymentSubscriptionRouter.post( '/addBilling', validate( validationDtos.validateBillingParams ), validateClient, paymentController.addBilling );
+paymentSubscriptionRouter.get( '/clientBillingInfo/:clientId', validate( validationDtos.validateBrandParams ), paymentController.billingInfo );
+paymentSubscriptionRouter.get( '/storeList', validate( validationDtos.validateStoreParams ), paymentController.getStoreList );
+paymentSubscriptionRouter.get( '/clientList', paymentController.getClientList );
+paymentSubscriptionRouter.post( '/basePricing', validate( validationDtos.validateProducts ), paymentController.pricingInfo );
+paymentSubscriptionRouter.put( '/update/subscription/:clientId', validate( validationDtos.validateBrandParams ), validateClient, paymentController.updateSubscription );
+paymentSubscriptionRouter.get( '/getTrailProducts', validate( validationDtos.validateStoreParams ), paymentController.trailProductList );
+paymentSubscriptionRouter.post( '/unsubscribe', validate( validationDtos.validateunsubscribeParams ), validateClient, paymentController.unsubscribeProduct );
+paymentSubscriptionRouter.post( '/trialExtendRequest', validate( validationDtos.validateTrailExtendandSubscibeParams ), validateClient, paymentController.trialExtendRequest );
+paymentSubscriptionRouter.post( '/trialRequest', validate( validationDtos.validateTrailExtendandSubscibeParams ), validateClient, paymentController.trialRequest );
+paymentSubscriptionRouter.get( '/InvoiceDetails/:clientId', validate( validationDtos.validateBrandParams ), paymentController.invoiceDetails );
+paymentSubscriptionRouter.put( '/update/InvoiceDetails/:clientId', validate( validationDtos.validateBrandParams ), paymentController.updateInvoiceDetails );
+paymentSubscriptionRouter.get( '/admin/notificationList', paymentController.notificationList );
+paymentSubscriptionRouter.post( '/admin/trialApproval', validate( validationDtos.validateTrailandUnsubscribeParams ), paymentController.trialApproval );
+paymentSubscriptionRouter.post( '/admin/trialExtendApproval', validate( validationDtos.validateTrailExtendRequestParams ), paymentController.trialExtendRequestApproval );
+paymentSubscriptionRouter.post( '/admin/subscribeproduct', validate( validationDtos.validateTrailExtendandSubscibeParams ), paymentController.productSubscribe );
+paymentSubscriptionRouter.post( '/admin/unsubscribeApproval', validate( validationDtos.validateTrailandUnsubscribeParams ), paymentController.unsubscribeApproval );
+paymentSubscriptionRouter.get( '/admin/getProductViewList', validate( validationDtos.validateStoreParams ), validateClient, paymentController.productViewList );
+paymentSubscriptionRouter.post( '/admin/getstoreViewList', validate( validationDtos.validateStoreViewParams ), validateClient, paymentController.storeViewList );
+paymentSubscriptionRouter.get( '/admin/getStoreLocationList', validate( validationDtos.validateStoreParams ), validateClient, paymentController.storeLocationList );
+paymentSubscriptionRouter.post( '/admin/addStoreProduct', validate( validationDtos.validateAddStoreProductParams ), validateClient, paymentController.addStoreProduct );
 
 

package/src/services/basePrice.service.js

@@ -0,0 +1,9 @@
+import model from 'tango-api-schema';
+
+export const aggregate = ( query = {} ) => {
+  return model.basePricingModel.aggregate( query );
+};
+
+export const find = ( query = {}, record = {} ) => {
+  return model.basePricingModel.find( query, record );
+};

package/src/services/clientPayment.services.js

@@ -0,0 +1,19 @@
+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 );
+};
+
+

package/src/services/clientRequest.service.js

@@ -0,0 +1,18 @@
+import model from 'tango-api-schema';
+
+
+export const insert = async ( record ) => {
+  return await model.clientRequestModel.create( record );
+};
+
+export const findOne = async ( query = {}, record = {} ) => {
+  return await model.clientRequestModel.findOne( query, record );
+};
+
+export const find = async ( query ={}, record={} ) => {
+  return await model.clientRequestModel.find( query, record );
+};
+
+export const updateone = async ( query = {}, record ={} ) => {
+  return await model.clientRequestModel.updateOne( query, { $set: record } );
+};

package/src/services/store.service.js

@@ -0,0 +1,17 @@
+import model from 'tango-api-schema';
+
+export const find = ( query = {}, record = {} ) => {
+  return model.storeModel.find( query, record );
+};
+
+export const count = ( query = {} ) => {
+  return model.storeModel.count( query );
+};
+
+export const aggregate = ( query = {} ) => {
+  return model.storeModel.aggregate( query );
+};
+
+export const updateProduct = ( query = {}, record = {} ) => {
+  return model.storeModel.updateMany( query, { $push: { product: { $each: record } } } );
+};

package/src/utils/validations/client.validation.js

@@ -0,0 +1,28 @@
+import * as clientPayment from '../../services/clientPayment.services.js';
+
+
+export const validateClient = async ( req, res, next ) => {
+  try {
+    let data;
+    if ( req?.body?.clientId ) {
+      data = req.body.clientId;
+    }
+    if ( req?.query?.clientId ) {
+      data = req.query.clientId;
+    }
+    if ( req?.params?.clientId ) {
+      data = req.params.clientId;
+    }
+
+    let clientExists = await clientPayment.findOne( { _id: data, status: 'active' }, { _id: 1, clientId: 1 } );
+    if ( !clientExists ) {
+      return res.sendNoContent();
+    }
+    req.body.client = clientExists;
+    next();
+  } catch ( e ) {
+    console.log( 'validateClient =>', e );
+    logger.error( e );
+    res.sendError( e, 500 );
+  }
+};

package/src/services/paymentSubscription.services.js

@@ -1,46 +0,0 @@
-import model from 'tango-api-schema';
-
-
-const findOne = ( query = {}, record = {} ) => {
-  return model.clientModel.findOne( query, record ).sort( { updatedAt: -1 } );
-};
-
-const updateOne = ( query = {}, record = {} ) => {
-  return model.clientModel.updateOne( query, { $set: record } );
-};
-
-const VirtualAccFind = ( query = {}, record ={} ) => {
-  return model.virtualAccountModel.findOne( query, record );
-};
-
-const storeFind = ( query = {}, record = {} ) => {
-  return model.storeModel.find( query, record );
-};
-
-const aggregate = ( query = [] ) => {
-  return model.clientModel.aggregate( query );
-};
-
-const find = ( query = {}, record = {} ) => {
-  return model.clientModel.find( query, record );
-};
-
-const storeCount = ( query= {} ) => {
-  return model.storeModel.count( query );
-};
-
-const getprice = ( query= {} ) => {
-  return model.basePricingModel.aggregate( query );
-};
-
-
-export default {
-  findOne,
-  updateOne,
-  VirtualAccFind,
-  storeFind,
-  aggregate,
-  find,
-  storeCount,
-  getprice,
-};