518 lines
11 KiB
JavaScript
518 lines
11 KiB
JavaScript
const { graphql } = require("graphql");
|
|
const { schema } = require("tempus-api-graphql");
|
|
const fs = require('fs');
|
|
|
|
const sleep = (time) => {
|
|
return new Promise((resolve) => setTimeout(resolve, time))
|
|
}
|
|
|
|
/*var DumpMapByID = async function(id) {
|
|
const query = `
|
|
{
|
|
map(id: ${id}) {
|
|
authors {
|
|
name
|
|
player {
|
|
steamId
|
|
country
|
|
}
|
|
}
|
|
id
|
|
name
|
|
videos {
|
|
soldier
|
|
demoman
|
|
}
|
|
tiers {
|
|
soldier
|
|
demoman
|
|
}
|
|
zones {
|
|
bonus {
|
|
id
|
|
map {
|
|
tiers {
|
|
soldier
|
|
demoman
|
|
}
|
|
}
|
|
type
|
|
zoneindex
|
|
customName
|
|
}
|
|
bonusEnd {
|
|
id
|
|
map {
|
|
tiers {
|
|
soldier
|
|
demoman
|
|
}
|
|
}
|
|
type
|
|
zoneindex
|
|
customName
|
|
}
|
|
checkpoint {
|
|
id
|
|
map {
|
|
tiers {
|
|
soldier
|
|
demoman
|
|
}
|
|
}
|
|
type
|
|
zoneindex
|
|
customName
|
|
}
|
|
course {
|
|
id
|
|
map {
|
|
tiers {
|
|
soldier
|
|
demoman
|
|
}
|
|
}
|
|
type
|
|
zoneindex
|
|
customName
|
|
}
|
|
courseEnd {
|
|
id
|
|
map {
|
|
tiers {
|
|
soldier
|
|
demoman
|
|
}
|
|
}
|
|
type
|
|
zoneindex
|
|
customName
|
|
}
|
|
linear {
|
|
id
|
|
map {
|
|
tiers {
|
|
soldier
|
|
demoman
|
|
}
|
|
}
|
|
type
|
|
zoneindex
|
|
customName
|
|
}
|
|
map {
|
|
id
|
|
map {
|
|
tiers {
|
|
soldier
|
|
demoman
|
|
}
|
|
}
|
|
type
|
|
zoneindex
|
|
customName
|
|
}
|
|
mapEnd {
|
|
id
|
|
map {
|
|
tiers {
|
|
soldier
|
|
demoman
|
|
}
|
|
}
|
|
type
|
|
zoneindex
|
|
customName
|
|
}
|
|
misc {
|
|
id
|
|
map {
|
|
tiers {
|
|
soldier
|
|
demoman
|
|
}
|
|
}
|
|
type
|
|
zoneindex
|
|
customName
|
|
}
|
|
trick {
|
|
id
|
|
map {
|
|
tiers {
|
|
soldier
|
|
demoman
|
|
}
|
|
}
|
|
type
|
|
zoneindex
|
|
customName
|
|
}
|
|
}
|
|
}
|
|
}`;
|
|
|
|
|
|
|
|
console.log(`Querying for map id: ${id}`)
|
|
var result = await graphql(schema, query);
|
|
await sleep(1000)
|
|
if (result.errors && result.errors.length > 0) {
|
|
if (result.errors[0].message && result.errors[0].message.search("404")) {
|
|
var file_loc = `./data/404-result-${id}.json`;
|
|
var err = fs.writeFileSync(file_loc, "");
|
|
if (err)
|
|
throw err;
|
|
console.log(`Recieved graceful 404 on id: ${id}`);
|
|
return
|
|
}
|
|
console.log(`Errormap: ${JSON.stringify(result)}`)
|
|
return
|
|
}
|
|
|
|
var name = `UnknownIDPleaseFix${id}`;
|
|
if (result.data.map)
|
|
name = result.data.map.name;
|
|
|
|
console.log(`Found map: ${name}`)
|
|
var file_loc = `./data/${name}.json`;
|
|
var err = fs.writeFileSync(file_loc, JSON.stringify(result.data.map, null, "\t"));
|
|
if (err) {
|
|
console.log(err)
|
|
throw err;
|
|
}
|
|
console.log(`Saved map \"${name}\" into \"${file_loc}\"`)
|
|
}*/
|
|
|
|
const DumpAllMapIds = async function() {
|
|
const query = `
|
|
{
|
|
maps {
|
|
id
|
|
}
|
|
}`;
|
|
|
|
console.log("Querying for list of maps")
|
|
var result = await graphql(schema, query);
|
|
await sleep(1000)
|
|
|
|
var sorted_maplist = [];
|
|
for (var mapobj in result.data.maps)
|
|
sorted_maplist.push(mapobj)
|
|
sorted_maplist.sort();
|
|
return sorted_maplist;
|
|
}
|
|
|
|
const GetRecordByPlayerMapID = async function(mapid, playerid, splits, soldier = true) {
|
|
var tfclass = soldier ? "SOLDIER" : "DEMOMAN";
|
|
var splitreq = !splits ? "" : `splits {
|
|
customName
|
|
duration
|
|
comparedDuration
|
|
}`;
|
|
|
|
const query = `{
|
|
player(id: ${playerid}) {
|
|
record (mapId: ${mapid}, class: ${tfclass}){
|
|
id
|
|
duration
|
|
rank
|
|
date
|
|
demo {
|
|
filename
|
|
url
|
|
recording
|
|
requested
|
|
uploader {
|
|
id
|
|
}
|
|
}
|
|
class
|
|
demoStartTick
|
|
demoEndTick
|
|
server {
|
|
id
|
|
shortname
|
|
name
|
|
hostName
|
|
}
|
|
${splitreq}
|
|
}
|
|
}
|
|
map(id: ${mapid}) {
|
|
name
|
|
}
|
|
}`;
|
|
|
|
console.log(`Querying for map records id: ${mapid}`)
|
|
var result = await graphql(schema, query);
|
|
await sleep(1000)
|
|
if (result.errors && result.errors.length > 0) {
|
|
var after_fourohfour = null;
|
|
for (var i = 0; i < result.errors.length; i++) {
|
|
var err = result.errors[i];
|
|
if (err.message && err.message === "Request failed with status code 404") {
|
|
var file_loc = `./data-records/404-result-${mapid}.json`;
|
|
var fserr = fs.writeFileSync(file_loc, "");
|
|
if (fserr)
|
|
throw fserr;
|
|
console.log(`Recieved graceful 404 on id: ${mapid}`);
|
|
throw err.message;
|
|
} else
|
|
after_fourohfour = err;
|
|
//console.log(`Errormap: ${JSON.stringify(result)}`)
|
|
}
|
|
if (after_fourohfour)
|
|
throw after_fourohfour;
|
|
return
|
|
}
|
|
|
|
return result;
|
|
/*var file_loc = `./data-records/${name}.json`;
|
|
var err = fs.writeFileSync(file_loc, JSON.stringify(result.data.map, null, "\t"));
|
|
if (err) {
|
|
console.log(err)
|
|
throw err;
|
|
}
|
|
console.log(`Saved map \"${name}\" into \"${file_loc}\"`)*/
|
|
}
|
|
|
|
const FindPlayerIdFromSteamId = async function(mapids, steamid) {
|
|
for (var map_id in mapids) {
|
|
try {
|
|
var last_length = 25;
|
|
for (var i = 1; last_length >= 25; i += 25) {
|
|
last_length = 0;
|
|
const query = `{
|
|
map(id: ${map_id}) {
|
|
records(start: ${i}, class: SOLDIER) {
|
|
player{
|
|
id
|
|
steamId
|
|
name
|
|
}
|
|
}
|
|
}
|
|
}`;
|
|
console.log(`Querying for map records: ${map_id} at ${i}`)
|
|
var result = await graphql(schema, query);
|
|
await sleep(1000)
|
|
if (result.errors && result.errors.length > 0)
|
|
throw result.errors[0];
|
|
|
|
if (result.data.map.records) {
|
|
last_length = result.data.map.records.length;
|
|
for (var ii = 0; ii < result.data.map.records.length; ii++) {
|
|
var record = result.data.map.records[ii];
|
|
if (record && record.player && record.player.steamId && record.player.steamId === steamid) {
|
|
console.log(`Found ID! ${record.player.id}`);
|
|
return record.player.id;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} catch (err) {
|
|
console.log(`Maprecords by id failed: ${map_id} with ${err}`);
|
|
}
|
|
}
|
|
}
|
|
|
|
const DumpAllRecordsFor = async function(mapids, playerid, soldier = true) {
|
|
for (var map_id in mapids) {
|
|
var result = {};
|
|
try {
|
|
result = await GetRecordByPlayerMapID(map_id, playerid, true, soldier);
|
|
} catch (err) {
|
|
if (err.message && err.message === "Request failed with status code 404")
|
|
continue;
|
|
if (err.message == "this.attrs.map_info is undefined" || err.message == "Cannot read properties of undefined (reading 'name')") {
|
|
console.log(`Requerying without splits`);
|
|
try {
|
|
result = await GetRecordByPlayerMapID(map_id, playerid, false, soldier)
|
|
} catch (err) {
|
|
console.log(`Error getting query ${map_id}: ${err}`);
|
|
continue;
|
|
}
|
|
} else
|
|
continue;
|
|
}
|
|
|
|
var name = `UnknownNamePleaseFixId${map_id}`;
|
|
if (result.data.map) {
|
|
name = result.data.map.name;
|
|
console.log(`Found map name: ${name}`)
|
|
} else
|
|
console.log(`Falling back to mapid for name: ${id}`)
|
|
|
|
if (result.data.player.record === null) {
|
|
console.log(`No record found for map: ${name}`);
|
|
var file_loc = `./data-non-records/${name}.json`;
|
|
var fserr = fs.writeFileSync(file_loc, "");
|
|
if (fserr)
|
|
throw fserr;
|
|
continue;
|
|
}
|
|
|
|
if (!result.data.player.record.name)
|
|
result.data.player.record.name = name;
|
|
|
|
/*var file_loc = `./data-records/${name}.json`;
|
|
var err = fs.writeFileSync(file_loc, JSON.stringify(result.data.player.record, null, "\t"));
|
|
if (err) {
|
|
console.log(err)
|
|
throw err;
|
|
}
|
|
console.log(`Saved map record\"${name}\" into \"${file_loc}\"`)*/
|
|
}
|
|
}
|
|
|
|
var verboze = false;
|
|
const DumpWorldRecord = async function(mapid, splits, soldier = true) {
|
|
var tfclass = soldier ? "SOLDIER" : "DEMOMAN";
|
|
var splitreq = !splits ? "" : `splits {
|
|
customName
|
|
duration
|
|
comparedDuration
|
|
}`;
|
|
|
|
const query = `{
|
|
map(id: ${mapid}) {
|
|
name
|
|
wr(class: ${tfclass}){
|
|
player {
|
|
name
|
|
steamId
|
|
}
|
|
duration
|
|
date
|
|
demo {
|
|
filename
|
|
date
|
|
url
|
|
recording
|
|
requested
|
|
expired
|
|
deleted
|
|
uploader {
|
|
steamId
|
|
name
|
|
}
|
|
server {
|
|
id
|
|
hostName
|
|
name
|
|
}
|
|
}
|
|
demoStartTick
|
|
demoEndTick
|
|
server {
|
|
id
|
|
hostName
|
|
name
|
|
}
|
|
${splitreq}
|
|
}
|
|
}
|
|
}`;
|
|
if (verboze) {
|
|
console.log("Dumping before query")
|
|
console.log(query) }
|
|
console.log(`Querying for map wrs: ${mapid}`)
|
|
var result = await graphql(schema, query);
|
|
await sleep(1000)
|
|
if (result.errors && result.errors.length > 0) {
|
|
var after_fourohfour = null;
|
|
for (var i = 0; i < result.errors.length; i++) {
|
|
var err = result.errors[i];
|
|
if (verboze) {
|
|
console.log("Dumping errors")
|
|
console.log(err) }
|
|
if (err.message && err.message === "Request failed with status code 404") {
|
|
var file_loc = `./data-wr/404-result-${mapid}.json`;
|
|
var fserr = fs.writeFileSync(file_loc, "");
|
|
if (fserr)
|
|
throw fserr;
|
|
console.log(`Recieved graceful 404 on id: ${mapid}`);
|
|
throw err.message;
|
|
} else
|
|
after_fourohfour = err;
|
|
//console.log(`Errormap: ${JSON.stringify(result)}`)
|
|
}
|
|
if (after_fourohfour)
|
|
throw after_fourohfour;
|
|
return
|
|
}
|
|
|
|
return result;
|
|
/*var file_loc = `./data-records/${name}.json`;
|
|
var err = fs.writeFileSync(file_loc, JSON.stringify(result.data.map, null, "\t"));
|
|
if (err) {
|
|
console.log(err)
|
|
throw err;
|
|
}
|
|
console.log(`Saved map \"${name}\" into \"${file_loc}\"`)*/
|
|
}
|
|
|
|
const DumpAllWrs = async function(mapids, soldier = true) {
|
|
for (var map_id in mapids) {
|
|
var result = {};
|
|
try {
|
|
result = await DumpWorldRecord(map_id, true, soldier);
|
|
} catch (err) {
|
|
if (verboze) {
|
|
console.log("Dumping before retry")
|
|
console.log(err) }
|
|
if (err.message && err.message === "Request failed with status code 404")
|
|
continue;
|
|
if (err.message == "this.attrs.map_info is undefined" || err.message == "Cannot read properties of undefined (reading 'name')") {
|
|
console.log(`Requerying without splits`);
|
|
try {
|
|
result = await DumpWorldRecord(map_id, false, soldier)
|
|
} catch (err) {
|
|
console.log(`Error getting query ${map_id}: ${err}`);
|
|
continue;
|
|
}
|
|
} else
|
|
continue;
|
|
}
|
|
|
|
var name = `UnknownNamePleaseFixId${map_id}`;
|
|
if (result.data.map) {
|
|
name = result.data.map.name;
|
|
console.log(`Found map name: ${name}`)
|
|
} else
|
|
console.log(`Falling back to mapid for name: ${id}`)
|
|
|
|
if (result.data.map.wr === null) {
|
|
console.log(`No record found for map: ${name}`);
|
|
var file_loc = `./data-non-wr/${name}.json`;
|
|
var fserr = fs.writeFileSync(file_loc, "");
|
|
if (fserr)
|
|
throw fserr;
|
|
continue;
|
|
}
|
|
|
|
var file_loc = `./data-wr/${name}.json`;
|
|
var err = fs.writeFileSync(file_loc, JSON.stringify(result.data.map.wr, null, "\t"));
|
|
if (err) {
|
|
console.log(err)
|
|
throw err;
|
|
}
|
|
console.log(`Saved map record\"${name}\" into \"${file_loc}\"`)
|
|
}
|
|
}
|
|
|
|
async function main() {
|
|
var mapids = await DumpAllMapIds()
|
|
const playerid = 112000; // await FindPlayerIdFromSteamId(mapids, "STEAM_0:0:43167835");
|
|
console.log(`Player Id: \"${playerid}\"`);
|
|
await DumpAllWrs(mapids, false)
|
|
//DumpAllRecordsFor(mapids, playerid)
|
|
/* for (var map_id in mapids) {
|
|
console.log(map_id)
|
|
await DumpMapByID(map_id)
|
|
}*/
|
|
//DumpMapByID(97)
|
|
}
|
|
main();
|