299 lines
10 KiB
JavaScript
299 lines
10 KiB
JavaScript
const { getStreamsNew } = require('../routes/getStreams')
|
|
|
|
const { updateStreamData } = require('./updateStreams')
|
|
|
|
const { gotRequest } = require('./gotRequest')
|
|
|
|
const { decryptPassword } = require('./password')
|
|
|
|
const { getAllUserAccounts, getUserAccountsCheck } = require('./getUser')
|
|
|
|
const { setExpired } = require('./setExpired')
|
|
|
|
const { removeAccountFromDB, storeAccountToDB } = require('../lib/Accounts')
|
|
|
|
const axios = require('axios')
|
|
axios.defaults.timeout = 10000;
|
|
|
|
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
|
|
}, 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 userCheck(accountData) {
|
|
console.log(Date.now())
|
|
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))
|
|
}
|
|
}
|
|
userAccounts
|
|
urlList
|
|
|
|
await Promise.all(urlList.map(async (url) => {
|
|
try {
|
|
const response = await axios.get(url)
|
|
// console.log(url)
|
|
if (response.status == 200 && response.data !== "") {
|
|
try {
|
|
let data = response.data
|
|
if (data.user_info.auth) {
|
|
updateAccounts(userAccounts, data, url)
|
|
return true
|
|
} else {
|
|
return true
|
|
}
|
|
} catch (error) {
|
|
// return true
|
|
}
|
|
} else {
|
|
return true
|
|
}
|
|
} catch {
|
|
// return true
|
|
}
|
|
}))
|
|
return true
|
|
}
|
|
|
|
async function newCheck() {
|
|
streamURLS = await getStreamsNew()
|
|
let userAccounts = await getAllUserAccounts()
|
|
userAccounts = userAccounts.map(async user => {
|
|
user.passwordDecryped = decryptPassword(user.password)
|
|
return user
|
|
})
|
|
for (let userAccount of userAccounts) {
|
|
if (userAccount.expiaryDate != 123 && Math.round(Date.now() / 1000) > userAccount.expiaryDate) {
|
|
setExpired(userAccount)
|
|
} else {
|
|
for (let streamURL of streamURLS) {
|
|
process.stdout.write('.')
|
|
let url = await buildURL(streamURL, userAccount.username, userAccount.passwordDecryped)
|
|
let t = await gotRequest(url)
|
|
let body = t.body
|
|
if (t.statusCode == 200 && body !== "") {
|
|
try {
|
|
body = JSON.parse(body)
|
|
if (body.user_info.auth) {
|
|
var date = new Date(body.user_info.exp_date * 1000).toLocaleDateString(undefined, { weekday: 'long', year: 'numeric', month: 'long', day: 'numeric' })
|
|
// process.stdout.write('\n')
|
|
console.log(`${userAccount.username} - ${userAccount.stream} - ${streamURL} - Expires ${date}.`)
|
|
await updateStreamData(userAccount, streamURL, body.user_info.exp_date)
|
|
break
|
|
}
|
|
} catch (error) {
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
// async function updateAccountDNS(userAccount, streamURLS) {
|
|
// // return new Promise(async (resolve, reject) => {
|
|
// await Promise.all(streamURLS.map(async (streamURL) => {
|
|
// process.stdout.write('.')
|
|
// let url = await buildURL(streamURL, userAccount.username, userAccount.passwordDecryped)
|
|
// // console.log('tested url ' + url)
|
|
// let t = await gotRequest(url)
|
|
// let body = t.body
|
|
// if (t.statusCode == 200 && body !== "") {
|
|
// try {
|
|
// body = JSON.parse(body)
|
|
// if (body.user_info.auth) {
|
|
// var date = new Date(body.user_info.exp_date * 1000).toLocaleDateString(undefined, { weekday: 'long', year: 'numeric', month: 'long', day: 'numeric' })
|
|
// // process.stdout.write('\n')
|
|
// console.log(`${userAccount.username} - ${userAccount.stream} - ${streamURL} - Expires ${date}.`)
|
|
// await updateStreamData(userAccount, streamURL, body.user_info.exp_date)
|
|
// resolve(true)
|
|
// }
|
|
// } catch (error) {
|
|
// }
|
|
// } else {
|
|
// }
|
|
// }));
|
|
// }
|
|
|
|
async function updateAccounts(userAccount, streamURLS) {
|
|
return new Promise(async (resolve, reject) => {
|
|
await streamURLS.forEach(async streamURL => {
|
|
process.stdout.write('.')
|
|
let url = await buildURL(streamURL, userAccount.username, userAccount.passwordDecryped)
|
|
console.log('tested url ' + url)
|
|
let t = await gotRequest(url)
|
|
let body = t.body
|
|
if (t.statusCode == 200 && body !== "") {
|
|
try {
|
|
body = JSON.parse(body)
|
|
if (body.user_info.auth) {
|
|
var date = new Date(body.user_info.exp_date * 1000).toLocaleDateString(undefined, { weekday: 'long', year: 'numeric', month: 'long', day: 'numeric' })
|
|
// process.stdout.write('\n')
|
|
console.log(`${userAccount.username} - ${userAccount.stream} - ${streamURL} - Expires ${date}.`)
|
|
await updateStreamData(userAccount, streamURL, body.user_info.exp_date)
|
|
resolve(true)
|
|
}
|
|
} catch (error) {
|
|
}
|
|
} else {
|
|
}
|
|
})
|
|
reject(userAccount)
|
|
})
|
|
}
|
|
|
|
|
|
|
|
async function singleCheck(accountData) {
|
|
streamURLS = await getStreamsNew()
|
|
let userAccounts = await getUserAccountsCheck(accountData.userId)
|
|
userAccounts = userAccounts.map(user => {
|
|
user.userId = accountData.userId
|
|
user.passwordDecryped = decryptPassword(user.password)
|
|
return user
|
|
})
|
|
userAccounts = userAccounts.filter(obj => {
|
|
return obj.username === accountData.username && obj.passwordDecryped === accountData.password && obj.stream === accountData.stream
|
|
})
|
|
|
|
try {
|
|
for (let i = 0; i < userAccounts.length; ++i) {
|
|
const userAccount = userAccounts[i];
|
|
if (userAccount.expiaryDate != 123 && Math.round(Date.now() / 1000) > userAccount.expiaryDate) {
|
|
setExpired(userAccount)
|
|
} else {
|
|
await updateAccounts(userAccount, streamURLS)
|
|
}
|
|
}
|
|
console.log(Date.now())
|
|
return true
|
|
} catch (userAccount) {
|
|
console.log('notfoundincatch')
|
|
// console.error(error);
|
|
removeAccountFromDB({
|
|
"user": userAccount.username,
|
|
"stream": userAccount.stream,
|
|
"userId": accountData.userId
|
|
})
|
|
}
|
|
}
|
|
|
|
|
|
async function singleAccountCheck(accountData) {
|
|
let endresponse
|
|
console.log(Date.now())
|
|
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
|
|
|
|
await Promise.all(urlList.map(async (url) => {
|
|
try {
|
|
// console.log(url)
|
|
const response = await axios.get(url)
|
|
// console.log(response)
|
|
if (response.status == 200 && response.data !== "") {
|
|
try {
|
|
let data = response.data
|
|
if (data.user_info.auth) {
|
|
addNewAccount(accountData, data, url)
|
|
return true
|
|
}
|
|
} catch (error) {
|
|
}
|
|
}
|
|
} catch {
|
|
}
|
|
})).then((values) => {
|
|
console.log(values)
|
|
if (values.includes(true)) {
|
|
endresponse = true
|
|
} else {
|
|
endresponse = false
|
|
}
|
|
});
|
|
return endresponse
|
|
}
|
|
|
|
|
|
module.exports = {
|
|
newCheck,
|
|
singleCheck,
|
|
userCheck,
|
|
singleAccountCheck
|
|
} |