ktvmanager/lib/checker.js

const { getStreamsNew } = require('../routes/getStreams')
const { updateStreamData } = require('./updateStreams')
const { decryptPassword } = require('./password')
const { getUserAccountsCheck, getAllUniqueAccounts, getAllUserAccounts } = require('./getUser')
const { storeAccountToDB } = require('../lib/Accounts')
const { syncApache } = require('./apache_functions')


const axios = require('axios')
const tor_axios = require('tor-axios');
const tor = tor_axios.torSetup({
    ip: process.env.TORSSRV,
    port: 9050,
    controlPort: 9051,
    controlPassword: process.env.TORSPWD,
})

axios.defaults.timeout = 3000;
tor.defaults.timeout = 3000

const inst = axios.create({
    httpAgent: tor.httpAgent(),
    httpsagent: tor.httpsAgent(),
});

let axiosOptions = {
    headers: {
        'User-Agent': 'IPTV Smarters Pro'
    }
}


const delay = ms => new Promise(res => setTimeout(res, ms));


async function buildURL(streamURL, username, password) {
    let url = streamURL + "/player_api.php?username=" + username + "&password=" + password
    return url
}

async function splitURL(url) {
    try {
        let extractedURL = url.match(/[^/]*\/\/[^/]*/)[0]
        let extractedUserPass = url.match(/\/player_api\.php\?username=([\s\S]*)$/)[1]
        let UserPass = extractedUserPass.split('&password=')
        return {
            "extractedUrl": extractedURL,
            "username": UserPass[0],
            "password": UserPass[1]
        }
    } catch {

    }
}

async function updateAccounts(userAccounts, data, url) {
    try {
        let URL = await splitURL(url)

        let account = userAccounts.filter(account => account.username == URL.username && account.passwordDecryped == URL.password)[0]

        await updateStreamData({
            "username": account.username,
            "password": account.password,
            "userId": account.userId
        }, URL.extractedUrl, data.user_info.exp_date)
        var date = new Date(data.user_info.exp_date * 1000).toLocaleDateString(undefined, { weekday: 'long', year: 'numeric', month: 'long', day: 'numeric' })
        console.log(`${userAccount.username} -  - ${URL.extractedUrl} - Expires ${date}.`)
    } catch (error) {
    }
}


async function addNewAccount(userAccount, data, url) {
    try {
        let URL = await splitURL(url)

        await storeAccountToDB({
            "username": userAccount.username,
            "password": userAccount.password,
            "userId": userAccount.userId,
            "streamName": userAccount.stream,
            "streamURL": URL.extractedUrl,
            "expiryDate": data.user_info.exp_date,
            "maxConnections": data.user_info.max_connections
        }, URL.extractedUrl, data.user_info.exp_date)
        var date = new Date(data.user_info.exp_date * 1000).toLocaleDateString(undefined, { weekday: 'long', year: 'numeric', month: 'long', day: 'numeric' })
        console.log(`${userAccount.username} -  ${URL.extractedUrl} - Expires ${date}.`)
    } catch (error) {
    }
}

async function urlChecker(userAccounts, urlList) {
    let ip = await inst.get('http://api.ipify.org')
    console.log(ip.data);
    await Promise.all(urlList.map(async (url) => {
        try {
            let response
            url
            response = await inst.get(url, axiosOptions)
            if (response.status == 200 && response.data !== "") {
                try {
                    let data = response.data
                    if (data.user_info.auth) {
                        console.log('.')
                        updateAccounts(userAccounts, data, url)
                        return true
                    }
                } catch {
                }
            }
        } catch {
        }
    })).then((values) => {
        endresponse = values
    });
    return endresponse
}


// async function allUserCheck() {
//     let start = Date.now()
//     console.log(start)
//     streamURLS = await getStreamsNew()
//     let userAccounts = await getAllUserAccounts()

//     userAccounts = userAccounts.map(user => {
//         // user.userId = accountData.userId
//         user.passwordDecryped = decryptPassword(user.password)
//         return user
//     })
//     urlList = []

//     for (let index = 0; index < userAccounts.length; index++) {
//         let userAccount = userAccounts[index];
//         userAccount.urls = []
//         for (let index = 0; index < streamURLS.length; index++) {
//             const streamURL = streamURLS[index];
//             userAccount.urls.push(await buildURL(streamURL, userAccount.username, userAccount.passwordDecryped))
//             urlList.push(await buildURL(streamURL, userAccount.username, userAccount.passwordDecryped))
//         }
//     }


//     values = await urlCheckerNew(userAccounts[3], urlList)
//     if (values.includes(true)) {
//         let updatedCount = values.filter(function (value) {
//             return value === true;
//         }).length
//         console.log('true ' + updatedCount)
//         console.log((Date.now() - start) / 1000)
//         return endresponse = {
//             "update": true,
//             "count": updatedCount
//         }
//     } else {
//         return endresponse = false
//     }

// }

// async function allUserCheck() {
//     let start = Date.now()
//     console.log(start)
//     streamURLS = await getStreamsNew()
//     let userAccounts = await getAllUserAccounts()

//     userAccounts = userAccounts.map(user => {
//         // user.userId = accountData.userId
//         user.passwordDecryped = decryptPassword(user.password)
//         return user
//     })
//     urlList = []

//     for (let index = 0; index < userAccounts.length; index++) {
//         let userAccount = userAccounts[index];
//         userAccount.urls = []
//         for (let index = 0; index < streamURLS.length; index++) {
//             const streamURL = streamURLS[index];
//             userAccount.urls.push(await buildURL(streamURL, userAccount.username, userAccount.passwordDecryped))
//             urlList.push(await buildURL(streamURL, userAccount.username, userAccount.passwordDecryped))
//         }
//     }


//     values = await urlChecker(userAccounts, urlList)
//     if (values.includes(true)) {
//         let updatedCount = values.filter(function (value) {
//             return value === true;
//         }).length
//         console.log('true ' + updatedCount)
//         console.log((Date.now() - start) / 1000)
//         return endresponse = {
//             "update": true,
//             "count": updatedCount
//         }
//     } else {
//         return endresponse = false
//     }

// }


async function userCheck(accountData) {
    let start = Date.now()
    console.log(start)
    streamURLS = await getStreamsNew()
    let userAccounts = await getUserAccountsCheck(accountData.userId)

    userAccounts = userAccounts.map(user => {
        user.userId = accountData.userId
        user.passwordDecryped = decryptPassword(user.password)
        return user
    })
    urlList = []

    for (let index = 0; index < userAccounts.length; index++) {
        let userAccount = userAccounts[index];
        userAccount.urls = []
        for (let index = 0; index < streamURLS.length; index++) {
            const streamURL = streamURLS[index];
            userAccount.urls.push(await buildURL(streamURL, userAccount.username, userAccount.passwordDecryped))
            urlList.push(await buildURL(streamURL, userAccount.username, userAccount.passwordDecryped))
        }
    }


    values = await urlChecker(userAccounts, urlList)
    if (values.includes(true)) {
        let updatedCount = values.filter(function (value) {
            return value === true;
        }).length
        console.log('true ' + updatedCount)
        console.log((Date.now() - start) / 1000)
        return endresponse = {
            "update": true,
            "count": updatedCount
        }
    } else {
        return endresponse = false
    }

}

async function accountChecker(accountData, urlList) {
    let ip = await inst.get('http://api.ipify.org')
    console.log(ip.data);

    for (let index = 0; index < urlList.length; index++) {
        const url = urlList[index];
        console.log(index + 1 + ' of ' + urlList.length + ' urls checked')
        try {
            let response = await inst.get(url, axiosOptions)
            if (response.data.user_info.auth) {
                addNewAccount(accountData, data, url)
                break
            }
        } catch (error) {
            try {
                if (error.response.status == 403) {
                    let response2 = await axios.get(url, axiosOptions)
                    if (response2.data.user_info.auth) {
                        try {
                            await addNewAccount(accountData, response2.data, url)
                            console.log('New Account Added')
                            syncApache()
                            return true
                        } catch (error) {
                            continue
                        }
                    }
                }
            } catch (error) {
                continue
            }
        }
    }
    return false
}


async function singleAccountCheck(accountData) {
    streamURLS = await getStreamsNew()

    urlList = []

    for (let index = 0; index < streamURLS.length; index++) {
        const streamURL = streamURLS[index];
        urlList.push(await buildURL(streamURL, accountData.username, accountData.password))
    }
    urlList
    return await accountChecker(accountData, urlList)
}




module.exports = {
    userCheck,
    singleAccountCheck,
    // allUserCheck
}

// singleAccountCheck({ "username": "Karl0ss01", "password": "YqQjYH9Nzw", "userId": 1, "stream": "Badger" })