go-bds/Maneger
Archived
1
0
Fork 0
Code Issues Pull Requests Actions Releases 71 Wiki Activity

Docker image #205

Merged
Sirherobrine23 merged 4 commits from DockerImage into main 2021-09-28 16:21:09 +00:00
Conversation 0 Commits 4 Files Changed 6 +506 -506
6 changed files with 506 additions and 506 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
.gitattributes vendored
View File

@ -1,2 +1,2 @@
* text=LF eol=LF * text=lf eol=lf
*.sh text=lf eol=lf *.sh text=lf eol=lf

200
.github/workflows/main.yml vendored
View File

@ -1,101 +1,101 @@
name: Publish dev npm package and Docker Image name: Publish dev npm package and Docker Image
on: on:
push: push:
branches: branches:
- main - main
env: env:
DOCKER_ARCH: linux/amd64,linux/arm64,linux/arm/v7 DOCKER_ARCH: linux/amd64,linux/arm64,linux/arm/v7
jobs: jobs:
CodeQL: CodeQL:
name: Analyze name: Analyze
runs-on: ubuntu-latest runs-on: ubuntu-latest
steps: steps:
- name: Checkout repository - name: Checkout repository
uses: actions/checkout@v2 uses: actions/checkout@v2
- name: Initialize CodeQL - name: Initialize CodeQL
uses: github/codeql-action/init@v1 uses: github/codeql-action/init@v1
with: with:
languages: "javascript" languages: "javascript"
- name: Autobuild - name: Autobuild
uses: github/codeql-action/autobuild@v1 uses: github/codeql-action/autobuild@v1
- name: Perform CodeQL Analysis - name: Perform CodeQL Analysis
uses: github/codeql-action/analyze@v1 uses: github/codeql-action/analyze@v1
npm: npm:
runs-on: ubuntu-latest runs-on: ubuntu-latest
steps: steps:
- name: Checkout - name: Checkout
uses: actions/checkout@master uses: actions/checkout@master
- name: Npm and Node Setup - name: Npm and Node Setup
uses: actions/setup-node@v2.4.1 uses: actions/setup-node@v2.4.1
with: with:
node-version: 16.x node-version: 16.x
registry-url: https://registry.npmjs.org/ registry-url: https://registry.npmjs.org/
- name: Edit Version - name: Edit Version
env: env:
RunID: ${{ github.run_id }} RunID: ${{ github.run_id }}
run: node .github/ChangeVersion.js run: node .github/ChangeVersion.js
- name: Install Packages - name: Install Packages
run: npm install run: npm install
- name: NPM Publish - name: NPM Publish
run: npm publish --tag dev run: npm publish --tag dev
env: env:
NODE_AUTH_TOKEN: '${{ secrets.NPM_ORG_TOKEN }}' NODE_AUTH_TOKEN: '${{ secrets.NPM_ORG_TOKEN }}'
DockerImage: DockerImage:
needs: needs:
- npm - npm
runs-on: ubuntu-latest runs-on: ubuntu-latest
name: Build Docker Image to Bds Core and Bds Base name: Build Docker Image to Bds Core and Bds Base
steps: steps:
- name: Set up QEMU - name: Set up QEMU
uses: docker/setup-qemu-action@v1 uses: docker/setup-qemu-action@v1
- name: Set up Docker Buildx - name: Set up Docker Buildx
uses: docker/setup-buildx-action@v1 uses: docker/setup-buildx-action@v1
- name: Login to DockerHub - name: Login to DockerHub
uses: docker/login-action@v1 uses: docker/login-action@v1
with: with:
registry: ghcr.io registry: ghcr.io
username: ${{ github.actor }} username: ${{ github.actor }}
password: ${{ secrets.GITHUB_TOKEN }} password: ${{ secrets.GITHUB_TOKEN }}
- name: checkout - name: checkout
uses: actions/checkout@master uses: actions/checkout@master
- name: Install Node Depedencies - name: Install Node Depedencies
run: npm install --no-save -d run: npm install --no-save -d
- name: Get And Export Release Version - name: Get And Export Release Version
shell: node shell: node -p '{0}'
run: | run: |
const version = require("./package.json").version; const version = require("./package.json").version;
const ActionsCore = require("@actions/core"); const ActionsCore = require("@actions/core");
console.log(version); console.log(version);
ActionsCore.exportVariable("BdsCoreVersion", version); ActionsCore.exportVariable("BdsCoreVersion", version);
- name: Build Docker image (Bds Maneger Base) - name: Build Docker image (Bds Maneger Base)
uses: docker/build-push-action@v2 uses: docker/build-push-action@v2
with: with:
push: true push: true
target: bdsbase target: bdsbase
tags: ghcr.io/the-bds-maneger/base:main tags: ghcr.io/the-bds-maneger/base:main
platforms: ${{ env.DOCKER_ARCH }} platforms: ${{ env.DOCKER_ARCH }}
- name: Build Docker image (Bds Maneger core) - name: Build Docker image (Bds Maneger core)
uses: docker/build-push-action@v2 uses: docker/build-push-action@v2
with: with:
push: true push: true
target: bdscore target: bdscore
cache-from: ghcr.io/the-bds-maneger/base:main cache-from: ghcr.io/the-bds-maneger/base:main
tags: ghcr.io/the-bds-maneger/core:main tags: ghcr.io/the-bds-maneger/core:main
platforms: ${{ env.DOCKER_ARCH }} platforms: ${{ env.DOCKER_ARCH }}

88
Dockerfile
View File

@ -1,44 +1,44 @@
# Setup Bds Manerger Project Docker Base # Setup Bds Manerger Project Docker Base
FROM debian:testing AS bdsbase FROM debian:testing AS bdsbase
USER root USER root
ENV DEBIAN_FRONTEND="noninteractive" DOCKER_IMAGE="true" ENV DEBIAN_FRONTEND="noninteractive" DOCKER_IMAGE="true"
# Copy Docker Files # Copy Docker Files
COPY .Build/Docker/* /tmp COPY .Build/Docker/* /tmp
# Configure BASE # Configure BASE
RUN bash /tmp/Configure.sh RUN bash /tmp/Configure.sh
# Setup bdsmaneger/core # Setup bdsmaneger/core
FROM bdsbase AS bdscore FROM bdsbase AS bdscore
# Create Volume to Storage Server And Config # Create Volume to Storage Server And Config
VOLUME [ "/root/bds_core" ] VOLUME [ "/root/bds_core" ]
# Set default ENVs to Bds Core # Set default ENVs to Bds Core
ENV PLAYERS="5" \ ENV PLAYERS="5" \
WORLD_NAME="The Ultimate Server" \ WORLD_NAME="The Ultimate Server" \
DESCRIPTION="running Minecraft Server on Bds Maneger by Bds Manager Project" \ DESCRIPTION="running Minecraft Server on Bds Maneger by Bds Manager Project" \
GAMEMODE="survival" \ GAMEMODE="survival" \
DIFFICULTY="normal" \ DIFFICULTY="normal" \
ENABLE_COMMANDS="false" \ ENABLE_COMMANDS="false" \
ACCOUNT="false" \ ACCOUNT="false" \
SERVER="bedrock" \ SERVER="bedrock" \
UPDATE_SERVER="true" UPDATE_SERVER="true"
# Bds Maneger Core required ports # Bds Maneger Core required ports
EXPOSE 19132/udp 19133/udp 1932/tcp EXPOSE 19132/udp 19133/udp 1932/tcp
# Copy Bds Maneger Core # Copy Bds Maneger Core
WORKDIR /opt/backend_core_scripts/ WORKDIR /opt/backend_core_scripts/
# Install Core dependencies # Install Core dependencies
COPY package*.json ./ COPY package*.json ./
RUN npm install RUN npm install
# Copy BdsManger Core # Copy BdsManger Core
COPY ./ ./ COPY ./ ./
RUN chmod a+x -v bin/* RUN chmod a+x -v bin/*
# Set Entrypint # Set Entrypint
ENTRYPOINT [ "node", "./bin/Docker.js" ] ENTRYPOINT [ "node", "./bin/Docker.js" ]

168
bin/bds_maneger/menus.js
View File

@ -1,85 +1,85 @@
// Import Node Modules // Import Node Modules
const fs = require("fs"); const fs = require("fs");
// Import external modules // Import external modules
const inquirer = require("inquirer"); const inquirer = require("inquirer");
// Bds Core // Bds Core
const { getBdsConfig } = require("../../index"); const { getBdsConfig } = require("../../index");
const { GetPaths } = require("../../lib/BdsSettings"); const { GetPaths } = require("../../lib/BdsSettings");
const GetPlayers = (Platform = getBdsConfig().server.platform) => [...JSON.parse(fs.readFileSync(GetPaths("player"), "utf8"))[Platform]]; const GetPlayers = (Platform = getBdsConfig().server.platform) => [...JSON.parse(fs.readFileSync(GetPaths("player"), "utf8"))[Platform]];
async function TpMenu() { async function TpMenu() {
const { BdsRun } = require("../../src/BdsManegerServer"); const { BdsRun } = require("../../src/BdsManegerServer");
const playerList = GetPlayers().map(player => player.Player && player.Action === "connect" ? player.Player : null).filter(a => a); const playerList = GetPlayers().map(player => player.Player && player.Action === "connect" ? player.Player : null).filter(a => a);
// Check if there are players online // Check if there are players online
if (playerList.length > 0) { if (playerList.length > 0) {
const Player = await inquirer.prompt([ const Player = await inquirer.prompt([
{ {
type: "list", type: "list",
name: "player", name: "player",
message: "Select a player", message: "Select a player",
choices: playerList choices: playerList
} }
]); ]);
// Ask X, Y and Z Cordinates // Ask X, Y and Z Cordinates
const cords = await inquirer.prompt([ const cords = await inquirer.prompt([
{ {
type: "input", type: "input",
name: "x", name: "x",
message: "X Cordinate", message: "X Cordinate",
validate: function (value) { validate: function (value) {
if (isNaN(value) === false) { if (isNaN(value) === false) {
return true; return true;
} }
return "Please enter a number"; return "Please enter a number";
} }
}, },
{ {
type: "input", type: "input",
name: "y", name: "y",
message: "Y Cordinate", message: "Y Cordinate",
validate: function (value) { validate: function (value) {
if (isNaN(value) === false) { if (isNaN(value) === false) {
return true; return true;
} }
return "Please enter a number"; return "Please enter a number";
} }
}, },
{ {
type: "input", type: "input",
name: "z", name: "z",
message: "Z Cordinate", message: "Z Cordinate",
validate: function (value) { validate: function (value) {
if (isNaN(value) === false) { if (isNaN(value) === false) {
return true; return true;
} }
return "Please enter a number"; return "Please enter a number";
} }
} }
]); ]);
return BdsRun.tp(Player.player, { return BdsRun.tp(Player.player, {
x: parseInt(cords.x), x: parseInt(cords.x),
y: parseInt(cords.y), y: parseInt(cords.y),
z: parseInt(cords.z) z: parseInt(cords.z)
}); });
} else throw new Error("No players online"); } else throw new Error("No players online");
} }
async function Command() { async function Command() {
const { BdsRun } = require("../../src/BdsManegerServer"); const { BdsRun } = require("../../src/BdsManegerServer");
const Command = await inquirer.prompt([ const Command = await inquirer.prompt([
{ {
type: "input", type: "input",
name: "command", name: "command",
message: "Enter a command" message: "Enter a command"
} }
]); ]);
return BdsRun.command(Command.command); return BdsRun.command(Command.command);
} }
module.exports.Command = Command; module.exports.Command = Command;
module.exports.TpMenu = TpMenu; module.exports.TpMenu = TpMenu;

232
bin/bds_maneger_v2.js
View File

@ -1,116 +1,116 @@
#!/usr/bin/env node #!/usr/bin/env node
if (process.platform === "win32") process.title = "Bds Maneger CLI"; else process.title = "Bds-Manger-CLI"; if (process.platform === "win32") process.title = "Bds Maneger CLI"; else process.title = "Bds-Manger-CLI";
process.env.IS_BDS_CLI = process.env.IS_BIN_BDS = true; process.env.IS_BDS_CLI = process.env.IS_BIN_BDS = true;
// External Modules // External Modules
const cli_color = require("cli-color"); const cli_color = require("cli-color");
const serverline = require("serverline"); const serverline = require("serverline");
const inquirer = require("inquirer"); const inquirer = require("inquirer");
// Bin Args // Bin Args
const ProcessArgs = require("minimist")(process.argv.slice(2)); const ProcessArgs = require("minimist")(process.argv.slice(2));
// Import Bds Core // Import Bds Core
const BdsCore = require("../index"); const BdsCore = require("../index");
const BdsReq = require("../lib/Requests"); const BdsReq = require("../lib/Requests");
const BdsExtraInfo = require("../BdsManegerInfo.json"); const BdsExtraInfo = require("../BdsManegerInfo.json");
const commandExits = require("../lib/commandExist"); const commandExits = require("../lib/commandExist");
const BdsMenus = require("./bds_maneger/menus"); const BdsMenus = require("./bds_maneger/menus");
// Async functiona // Async functiona
async function Runner() { async function Runner() {
// ESM Modules // ESM Modules
const ora = (await import("ora")).default; const ora = (await import("ora")).default;
// Update Bds Core Platform // Update Bds Core Platform
if (ProcessArgs.platform || ProcessArgs.p) { if (ProcessArgs.platform || ProcessArgs.p) {
const UpdatePla = ora("Updating Bds Platform").start(); const UpdatePla = ora("Updating Bds Platform").start();
try { try {
BdsCore.platform_update(ProcessArgs.platform || ProcessArgs.p); BdsCore.platform_update(ProcessArgs.platform || ProcessArgs.p);
UpdatePla.succeed(`Now the platform is the ${ProcessArgs.platform || ProcessArgs.p}`); UpdatePla.succeed(`Now the platform is the ${ProcessArgs.platform || ProcessArgs.p}`);
} catch (error) { } catch (error) {
UpdatePla.fail(`Unable to update platform to ${ProcessArgs.platform || ProcessArgs.p}`); UpdatePla.fail(`Unable to update platform to ${ProcessArgs.platform || ProcessArgs.p}`);
process.exit(1); process.exit(1);
} }
} }
// Print Info about Bds Core and Platforms // Print Info about Bds Core and Platforms
if (ProcessArgs.info || ProcessArgs.i) { if (ProcessArgs.info || ProcessArgs.i) {
const { valid_platform } = await (require("../lib/BdsSystemInfo"))(); const { valid_platform } = await (require("../lib/BdsSystemInfo"))();
var checkothearch = ""; var checkothearch = "";
if (process.platform === "linux" && BdsCore.arch !== "x64"){checkothearch = `qemu-x86_64-static is installed to emulate an x64 system: ${commandExits("qemu-x86_64-static")}\n`} if (process.platform === "linux" && BdsCore.arch !== "x64"){checkothearch = `qemu-x86_64-static is installed to emulate an x64 system: ${commandExits("qemu-x86_64-static")}\n`}
if (process.platform === "android" && BdsCore.arch !== "x64"){checkothearch = `qemu-x86_64 is installed to emulate an x64 system: ${commandExits("qemu-x86_64")}\n`} if (process.platform === "android" && BdsCore.arch !== "x64"){checkothearch = `qemu-x86_64 is installed to emulate an x64 system: ${commandExits("qemu-x86_64")}\n`}
const help = [ const help = [
`Bds Maneger Core And Bds Maneger CLI version: ${cli_color.magentaBright(BdsCore.package_json.version)}`, `Bds Maneger Core And Bds Maneger CLI version: ${cli_color.magentaBright(BdsCore.package_json.version)}`,
`System: ${cli_color.yellow(process.platform)}, architecture: ${cli_color.blue(BdsCore.arch)}`, `System: ${cli_color.yellow(process.platform)}, architecture: ${cli_color.blue(BdsCore.arch)}`,
checkothearch, checkothearch,
"**************************************************************", "**************************************************************",
"* Servers currently available:", "* Servers currently available:",
`* - Bedrock: ${valid_platform.bedrock}`, `* - Bedrock: ${valid_platform.bedrock}`,
`* - Pocketmine-MP: ${valid_platform.pocketmine}`, `* - Pocketmine-MP: ${valid_platform.pocketmine}`,
`* - Dragonfly: ${valid_platform.dragonfly}`, `* - Dragonfly: ${valid_platform.dragonfly}`,
`* - Java: ${valid_platform.java}`, `* - Java: ${valid_platform.java}`,
`* - Spigot: ${valid_platform.java}`, `* - Spigot: ${valid_platform.java}`,
"*", "*",
"**************************************************************" "**************************************************************"
]; ];
console.log(cli_color.whiteBright(help.join("\n").replace(/true/gi, cli_color.greenBright("true")).replace(/false/gi, cli_color.redBright("false")).replace(/undefined/gi, cli_color.red("undefined")))); console.log(cli_color.whiteBright(help.join("\n").replace(/true/gi, cli_color.greenBright("true")).replace(/false/gi, cli_color.redBright("false")).replace(/undefined/gi, cli_color.red("undefined"))));
// End // End
return; return;
} }
// Download // Download
if (ProcessArgs.download || ProcessArgs.d) { if (ProcessArgs.download || ProcessArgs.d) {
const VersionList = Object.getOwnPropertyNames((await BdsReq.json(BdsExtraInfo.Fetchs.servers))[BdsCore.BdsSettigs.GetPlatform()]).map(version => ({ const VersionList = Object.getOwnPropertyNames((await BdsReq.json(BdsExtraInfo.Fetchs.servers))[BdsCore.BdsSettigs.GetPlatform()]).map(version => ({
name: `${BdsCore.BdsSettigs.GetPlatform()}: v${version}`, name: `${BdsCore.BdsSettigs.GetPlatform()}: v${version}`,
value: version, value: version,
})) }))
if ((ProcessArgs.download || ProcessArgs.d) === true || (ProcessArgs.download || ProcessArgs.d) === "latest") ProcessArgs.d = ProcessArgs.download = (await inquirer.prompt([ if ((ProcessArgs.download || ProcessArgs.d) === true || (ProcessArgs.download || ProcessArgs.d) === "latest") ProcessArgs.d = ProcessArgs.download = (await inquirer.prompt([
{ {
type: "list", type: "list",
name: "download", name: "download",
message: "Select the platform to download", message: "Select the platform to download",
choices: VersionList choices: VersionList
} }
])).download; ])).download;
const oraDownload = ora(`Downloading ${BdsCore.BdsSettigs.GetPlatform()} on version ${ProcessArgs.d || ProcessArgs.download}`).start(); const oraDownload = ora(`Downloading ${BdsCore.BdsSettigs.GetPlatform()} on version ${ProcessArgs.d || ProcessArgs.download}`).start();
try { try {
const DownloadInfo = await BdsCore.download.v2(ProcessArgs.d || ProcessArgs.download, true); const DownloadInfo = await BdsCore.download.v2(ProcessArgs.d || ProcessArgs.download, true);
const DownloadSucess = ["Downloaded Successfully"]; const DownloadSucess = ["Downloaded Successfully"];
if (DownloadInfo.version) DownloadSucess.push(`Version: ${DownloadInfo.version}`); if (DownloadInfo.version) DownloadSucess.push(`Version: ${DownloadInfo.version}`);
if (DownloadInfo.data) DownloadSucess.push(`Data: ${DownloadInfo.data}`); if (DownloadInfo.data) DownloadSucess.push(`Data: ${DownloadInfo.data}`);
if (DownloadInfo.platform) DownloadSucess.push(`Bds Core Platform: ${DownloadInfo.platform}`); if (DownloadInfo.platform) DownloadSucess.push(`Bds Core Platform: ${DownloadInfo.platform}`);
oraDownload.succeed(DownloadSucess.join(", ")) oraDownload.succeed(DownloadSucess.join(", "))
} catch (error) { } catch (error) {
oraDownload.fail(error.message); oraDownload.fail(error.message);
process.exit(1); process.exit(1);
} }
} }
if (!(ProcessArgs.start || ProcessArgs.s)) return; if (!(ProcessArgs.start || ProcessArgs.s)) return;
// Start // Start
const BdsCoreStart = BdsCore.start(); const BdsCoreStart = BdsCore.start();
BdsCoreStart.log(data => console.log(cli_color.blueBright(data.replace(/\n$/gi, "")))); BdsCoreStart.log(data => console.log(cli_color.blueBright(data.replace(/\n$/gi, ""))));
BdsCoreStart.exit(code => { BdsCoreStart.exit(code => {
console.log(cli_color.redBright(`Bds Core Exit with code ${code}, Uptimed: ${BdsCoreStart.uptime}`)); console.log(cli_color.redBright(`Bds Core Exit with code ${code}, Uptimed: ${BdsCoreStart.uptime}`));
process.exit(code); process.exit(code);
}); });
serverline.init(); serverline.init();
serverline.setCompletion(["tp"]); serverline.setCompletion(["tp"]);
serverline.setPrompt("Command > "); serverline.setPrompt("Command > ");
serverline.on("line", async function(line) { serverline.on("line", async function(line) {
if (/^@/.test(line)) { if (/^@/.test(line)) {
serverline.close(); serverline.close();
if (/^@stop/.test(line)) { if (/^@stop/.test(line)) {
BdsCoreStart.stop(); BdsCoreStart.stop();
return; return;
} else if (/^@tp/.test(line)) { } else if (/^@tp/.test(line)) {
await BdsMenus.TpMenu(); await BdsMenus.TpMenu();
} }
return serverline.init(); return serverline.init();
} else BdsCoreStart.command(line); } else BdsCoreStart.command(line);
}); });
if (!(ProcessArgs["no-api"])) BdsCore.api() if (!(ProcessArgs["no-api"])) BdsCore.api()
} }
Runner(); Runner();

322
src/api/v2/routes/player.js
View File

@ -1,162 +1,162 @@
// Node Internal modules // Node Internal modules
const fs = require("fs"); const fs = require("fs");
// Bds Manager Core modules // Bds Manager Core modules
const BdsCore = require("../../../../index"); const BdsCore = require("../../../../index");
const BdsChecks = require("../../../UsersAndtokenChecks"); const BdsChecks = require("../../../UsersAndtokenChecks");
const BdsSettings = require("../../../../lib/BdsSettings"); const BdsSettings = require("../../../../lib/BdsSettings");
// Express // Express
const express = require("express"); const express = require("express");
const app = express.Router(); const app = express.Router();
// Find Player // Find Player
const GetPlayerJson = (Platform = BdsCore.getBdsConfig().server.platform) => ([...{...JSON.parse(fs.readFileSync(BdsCore.BdsSettigs.GetPaths("player"), "utf8"))}[Platform]]); const GetPlayerJson = (Platform = BdsCore.getBdsConfig().server.platform) => ([...{...JSON.parse(fs.readFileSync(BdsCore.BdsSettigs.GetPaths("player"), "utf8"))}[Platform]]);
// Routes // Routes
app.get("/", (req, res) => { app.get("/", (req, res) => {
const { Platform = BdsSettings.GetPlatform(), Player = null, Action = null } = req.query; const { Platform = BdsSettings.GetPlatform(), Player = null, Action = null } = req.query;
let PlayerList = GetPlayerJson(Platform); let PlayerList = GetPlayerJson(Platform);
if (Player) PlayerList = PlayerList.filter(PLS => PLS.Player === Player); if (Player) PlayerList = PlayerList.filter(PLS => PLS.Player === Player);
if (Action) PlayerList = PlayerList.filter(PLS => PLS.Action === Action); if (Action) PlayerList = PlayerList.filter(PLS => PLS.Action === Action);
if (Player || Action) { if (Player || Action) {
if (PlayerList.length > 0) res.json(PlayerList); if (PlayerList.length > 0) res.json(PlayerList);
else res.status(404).json({ else res.status(404).json({
Error: "Player not found", Error: "Player not found",
querys: req.query querys: req.query
}); });
return; return;
} }
res.json(PlayerList); res.json(PlayerList);
return; return;
}); });
// Players Actions in Backside Manager // Players Actions in Backside Manager
// kick player // kick player
app.get("/kick", (req, res) => { app.get("/kick", (req, res) => {
const { Token = null, Player = "Sirherobrine", Text = "You have been removed from the Server" } = req.query; const { Token = null, Player = "Sirherobrine", Text = "You have been removed from the Server" } = req.query;
if (!Token) return res.status(400).json({ error: "Token is required" }); if (!Token) return res.status(400).json({ error: "Token is required" });
if (!BdsChecks.token_verify(Token)) return res.status(400).json({ error: "Token is invalid" }); if (!BdsChecks.token_verify(Token)) return res.status(400).json({ error: "Token is invalid" });
// Kick player // Kick player
const RunnerServer = require("../../../BdsManegerServer").BdsRun; const RunnerServer = require("../../../BdsManegerServer").BdsRun;
try { try {
RunnerServer.kick(Player, Text); RunnerServer.kick(Player, Text);
res.json({ success: true }); res.json({ success: true });
} catch (error) { } catch (error) {
res.status(400).json({ res.status(400).json({
error: "Server nots Run", error: "Server nots Run",
text: `${error}` text: `${error}`
}); });
} }
}); });
// Ban player // Ban player
app.get("/ban", (req, res) => { app.get("/ban", (req, res) => {
const { Token = null, Player = "Sirherobrine" } = req.query; const { Token = null, Player = "Sirherobrine" } = req.query;
if (!Token) return res.status(400).json({ error: "Token is required" }); if (!Token) return res.status(400).json({ error: "Token is required" });
if (!BdsChecks.token_verify(Token)) return res.status(400).json({ error: "Token is invalid" }); if (!BdsChecks.token_verify(Token)) return res.status(400).json({ error: "Token is invalid" });
// Ban player // Ban player
const RunnerServer = require("../../../BdsManegerServer").BdsRun; const RunnerServer = require("../../../BdsManegerServer").BdsRun;
try { try {
RunnerServer.ban(Player); RunnerServer.ban(Player);
res.json({ success: true }); res.json({ success: true });
} catch (error) { } catch (error) {
res.status(400).json({ res.status(400).json({
error: "Server nots Run", error: "Server nots Run",
text: `${error}` text: `${error}`
}); });
} }
}); });
// Op player // Op player
app.get("/op", (req, res) => { app.get("/op", (req, res) => {
const { Token = null, Player = "Sirherobrine" } = req.query; const { Token = null, Player = "Sirherobrine" } = req.query;
if (!Token) return res.status(400).json({ error: "Token is required" }); if (!Token) return res.status(400).json({ error: "Token is required" });
if (!BdsChecks.token_verify(Token)) return res.status(400).json({ error: "Token is invalid" }); if (!BdsChecks.token_verify(Token)) return res.status(400).json({ error: "Token is invalid" });
// Op player // Op player
const RunnerServer = require("../../../BdsManegerServer").BdsRun; const RunnerServer = require("../../../BdsManegerServer").BdsRun;
try { try {
RunnerServer.op(Player); RunnerServer.op(Player);
res.json({ success: true }); res.json({ success: true });
} catch (error) { } catch (error) {
res.status(400).json({ res.status(400).json({
error: "Server nots Run", error: "Server nots Run",
text: `${error}` text: `${error}`
}); });
} }
}); });
// Deop player // Deop player
app.get("/deop", (req, res) => { app.get("/deop", (req, res) => {
const { Token = null, Player = "Sirherobrine" } = req.query; const { Token = null, Player = "Sirherobrine" } = req.query;
if (!Token) return res.status(400).json({ error: "Token is required" }); if (!Token) return res.status(400).json({ error: "Token is required" });
if (!BdsChecks.token_verify(Token)) return res.status(400).json({ error: "Token is invalid" }); if (!BdsChecks.token_verify(Token)) return res.status(400).json({ error: "Token is invalid" });
// Deop player // Deop player
const RunnerServer = require("../../../BdsManegerServer").BdsRun; const RunnerServer = require("../../../BdsManegerServer").BdsRun;
try { try {
RunnerServer.deop(Player); RunnerServer.deop(Player);
res.json({ success: true }); res.json({ success: true });
} catch (error) { } catch (error) {
res.status(400).json({ res.status(400).json({
error: "Server nots Run", error: "Server nots Run",
text: `${error}` text: `${error}`
}); });
} }
}); });
// Say to Server // Say to Server
app.get("/say", (req, res) => { app.get("/say", (req, res) => {
const { Token = null, Text = "Hello Server" } = req.query; const { Token = null, Text = "Hello Server" } = req.query;
if (!Token) return res.status(400).json({ error: "Token is required" }); if (!Token) return res.status(400).json({ error: "Token is required" });
if (!BdsChecks.token_verify(Token)) return res.status(400).json({ error: "Token is invalid" }); if (!BdsChecks.token_verify(Token)) return res.status(400).json({ error: "Token is invalid" });
// Say to Server // Say to Server
const RunnerServer = require("../../../BdsManegerServer").BdsRun; const RunnerServer = require("../../../BdsManegerServer").BdsRun;
try { try {
RunnerServer.say(Text); RunnerServer.say(Text);
res.json({ success: true }); res.json({ success: true });
} catch (error) { } catch (error) {
res.status(400).json({ res.status(400).json({
error: "Server nots Run", error: "Server nots Run",
text: `${error}` text: `${error}`
}); });
} }
}); });
// Tp player // Tp player
app.get("/tp", (req, res) => { app.get("/tp", (req, res) => {
const { Token = null, Player = "Sirherobrine", X = 0, Y = 0, Z = 0 } = req.query; const { Token = null, Player = "Sirherobrine", X = 0, Y = 0, Z = 0 } = req.query;
if (!Token) return res.status(400).json({ error: "Token is required" }); if (!Token) return res.status(400).json({ error: "Token is required" });
if (!BdsChecks.token_verify(Token)) return res.status(400).json({ error: "Token is invalid" }); if (!BdsChecks.token_verify(Token)) return res.status(400).json({ error: "Token is invalid" });
// Tp player // Tp player
const RunnerServer = require("../../../BdsManegerServer").BdsRun; const RunnerServer = require("../../../BdsManegerServer").BdsRun;
try { try {
RunnerServer.tp(Player, { RunnerServer.tp(Player, {
x: X, x: X,
y: Y, y: Y,
z: Z z: Z
}); });
res.json({ success: true }); res.json({ success: true });
} catch (error) { } catch (error) {
res.status(400).json({ res.status(400).json({
error: "Server nots Run", error: "Server nots Run",
text: `${error}` text: `${error}`
}); });
} }
}); });
// Export Routes // Export Routes
module.exports = app; module.exports = app;
module.exports.APIPaths = [...app.stack.map(d => { module.exports.APIPaths = [...app.stack.map(d => {
if (d.route) { if (d.route) {
if (d.route.path) return d.route.path; if (d.route.path) return d.route.path;
else return d.route.regexp.source; else return d.route.regexp.source;
} }
return null; return null;
}).filter(d => d)]; }).filter(d => d)];