Software: Apache/2.4.41 (Ubuntu). PHP/8.0.30 

uname -a: Linux apirnd 5.4.0-204-generic #224-Ubuntu SMP Thu Dec 5 13:38:28 UTC 2024 x86_64 

uid=33(www-data) gid=33(www-data) groups=33(www-data) 

Safe-mode: OFF (not secure)

/var/www/html/wincloud_gateway/checking/   drwxr-xr-x
Free 13.02 GB of 57.97 GB (22.46%)
                            Encoder    Tools    Proc.    FTP brute    Sec.    SQL    PHP-code    Update    Self remove    Logout    

Viewing file:     balance.js (7.06 KB)      -rw-r--r--

'use strict';

var { client } = require('./redisClient');
const winston = require('winston');
const rateLimit = require('./rateLimit');
const ip_rateLimit = require('./Ip_RateLimit');

///balance check start

module.exports = {
    balance: async function (token,api_name,action,user_ip,query){
var api_name=api_name.replace("/",'');
let err="no balance";
var service_id=query.serviceId;

var keyWord=query.keyWord;
// console.log(keyWord);
var service_id_keyWord=service_id+"_"+keyWord;

// partner information start
async function getPartnerInfo() {
  return new Promise((resolve, reject) => {
    return client.exists(service_id_keyWord, function(err, reply) {
  if (reply === 1) {
     client.hgetall(service_id_keyWord, function (err, object) {
      var partner_rate = object.partner_rate;
      resolve([partner_rate]); // partner vendor full information
            });
  } else {
    // get partner information from mysql when it is not exist in redis cache
    async function getPartner(){
          const partner = await strapi.query('service').findOne({keyWord:keyWord,serviceId:service_id});

          var partner_rate = partner.rate;
          client.hmset(service_id_keyWord, {partner_rate:parseFloat(partner_rate).toFixed(2)});
          resolve([partner_rate]);
    }
    getPartner();
  }
  });
});
}
// partner information end

// user information start
  async function getUSerInfo(token,rate) {
    return new Promise((resolve, reject) => {
      return client.exists(token, function(err, reply) {
    if (reply === 1) {
       client.hgetall(token, function (err, object) {
            resolve(object); // user full information
              });
    } else {
     
      // get user information from mysql when it is not exist in redis cache
      async function getUser(token,rate){
            const user = await strapi .query('user', 'users-permissions').findOne({token:token});
            console.log(user.balance+'='+rate);
            if(user.balance>=parseFloat(rate).toFixed(2))
            {
              client.hmset(token, { user_id: user.id,m_balance:parseFloat(user.balance).toFixed(2),r_balance:parseFloat(user.balance).toFixed(2),rate_limit:parseInt(user.rate_limit,10),ip_whiteList:user.ip_whiteList});
              resolve(user);
            }
            else {
              // console.log("not correct");
              var no_balance="no balance";
              resolve(no_balance);
            }
      }
      getUser(token,rate);
    }
    });
  });
}
// User information end

//logging start .............

// const logConfiguration = {
  
//   transports: [
     
//     new winston.transports.File({level: 'error', filename: '../no_balance.log'}),
//     new winston.transports.File({level: 'info', filename: '../info.log' }),
//     // new winston.transports.File({level: 'warn',filename: '../warn.log'})

//   ] ,
//   format: winston.format.combine(
//       winston.format.label({
//           label: `Label🏷️`
//       }),
//       winston.format.timestamp({
//          format: 'MMM-DD-YYYY HH:mm:ss:ms'
//      }),
//       winston.format.printf(info => `${info.level}: ${[info.timestamp]}: ${info.message}`),
//   )
// };
// const logger = winston.createLogger(logConfiguration);

// logging end..................

//calling user information from redis
let partner= await getPartnerInfo();
// var token=partner[0];
var rate=partner[0];
const user = await getUSerInfo(token,rate);

if (user==="no balance")
{
// logger.error("data={'user_id' : "+user_id+" ,'api_name' : "+api_name+", 'method' : "+action+"} ");
return [user];
}

else{
var user_id=user.user_id;   //user id  from redis 
var rate_limit=user.rate_limit; // user rate limit for an interval
var r_balance =parseFloat(user.r_balance);  //user remaining balance from redis 
var whiteList = user.ip_whiteList.toString();


// calling api rate from  redis
if ("amount" in user){
  console.log('dddd')
    var user_id=user.id; //user id from my sql
      if(whiteList=="true")
      {
        const whiteList_ip = await strapi .query('ip-whitelist','ip-whitelist').findOne({ip:user_ip});

        if(whiteList_ip==null)
        {
          return ["not valid"];
        } 
        else
        {
              var ip_rate_limit= whiteList_ip.rate_limit;
              if (ip_rate_limit<1) {
                return ["exceed"];
              }
              else{
                client.hmset(user_ip, {ip_rateLimit:ip_rate_limit});
                var keyData = await ip_rateLimit.getLimit(user_id,user_ip,ip_rate_limit);
                return [keyData,rate];
              }
          }
      }
      else
      {

        if (rate_limit<1) {
          return ["exceed"];
        }
        else
        {
          var keyData = await rateLimit.getLimit(user_id,rate_limit);
          return [keyData,rate];
        }
      }
}

else if( rate<r_balance)
{
  console.log(parseFloat(r_balance).toFixed(2));
      if(whiteList=="true")
      {
        async function getIpLimit() {0
          return new Promise((resolve, reject) => {
            return client.exists(user_ip, async function(err, reply) {
              if (reply === 1) {
              client.hgetall(user_ip, function (err, object) {
                var ip_rateLimit=object.ip_rateLimit; // api rate 
               resolve(ip_rateLimit);
                 });
                }
                else{
                    const whiteList_ip = await strapi .query('ip-whitelist','ip-whitelist').findOne({ip:user_ip});
                    if(whiteList_ip==null)
                    {
                      resolve("empty");
                    } 
                    
                    else{
                      var ip_rate_limit= whiteList_ip.rate_limit;
                          if (ip_rate_limit<1) {
                            resolve("exceed");
                          }
                          else{
                            client.hmset(user_ip, {ip_rateLimit:ip_rate_limit});
                            resolve(ip_rate_limit);
                            }
                       }
                }
            });
          });
          }
          var ip_rate_limit = await getIpLimit();
          if (ip_rate_limit=="empty") {
            return ["not valid"];
          }
          else if (ip_rate_limit=="exceed") {
            return ["exceed"];
          }
          else
          {
            var keyData = await ip_rateLimit.getLimit(user_id,user_ip,ip_rate_limit);
            return [keyData,rate];
          }

      }
      else
      {

        if (rate_limit<1) {
          return ["exceed"];
        }
        else
        {
          var keyData = await rateLimit.getLimit(user_id,rate_limit);
          return [keyData,rate];
        }
      }
}
else{
// logger.error("not sufficient balance ");
// logger.error("data={'user_id' : "+user+" ,'api_name' : "+api_name+", 'method' : "+action+"} ");
console.log('dddaaa')

return ["no balance"];
}
 
}
}
}
//balance check ends