.test/core.js

@@ -21,9 +21,9 @@ describe("Small functions", () => {
     BdsCore.BdsSettings.UpdatePlatform("dragonfly");
     done();
   });
-  it("Register And Delete API Token", function (done) {
+  it("Register And Delete Token", function (done) {
-    const Token = BdsCore.BdsManegerAPI.token_register();
+    const Token = BdsCore.BdsToken.CreateToken();
-    BdsCore.BdsManegerAPI.delete_token(Token);
+    BdsCore.BdsToken.DeleteToken(Token.Token);
     done();
   });
   it("Get Server Config", function (done) {

bin/Docker.js

@@ -9,12 +9,12 @@ const { PlatformVersionsV2 } = require("../src/BdsServersDownload");
 
 // Get Current Tokens and Show in the console
 function ShowToken() {
-  const TokenFilePath = BdsCore.BdsManegerAPI.TokensFilePath;
+  const TokenFilePath = BdsCore.BdsToken.TokenFile;
   let Tokens = 1
   if (fs.existsSync(TokenFilePath)) {
-    [...JSON.parse(fs.readFileSync(TokenFilePath, "utf8"))].slice(0, 5).forEach(token => {console.log(Tokens+":", "Bds API Token:", token.token); Tokens++});
+    [...JSON.parse(fs.readFileSync(TokenFilePath, "utf8"))].slice(0, 5).forEach(token => {console.log(Tokens+":", "Bds API Token:", token.Token); Tokens++});
   } else {
-    console.log(Tokens+":", "Bds API Token:", BdsCore.BdsManegerAPI.token_register());
+    console.log(Tokens+":", "Bds API Token:", (BdsCore.BdsToken.CreateToken()).Token);
   }
 }
 

bin/plugins/TelegramBot.js

@@ -1,11 +1,19 @@
+/**
+ * Bds Maneger Telegram Bot v13.1.1
+ */
+const { version, BdsSettings, BdsToken, BdsSystemInfo, BdsManegerServer } = require("../../index");
+const { Telegraf } = require("telegraf");
+const os = require("os");
 const fs = require("fs");
-const { Telegraf, Markup } = require("telegraf");
+const path = require("path");
-const bds = require("../../index");
+
-const { GetPlatform, GetPaths, GetTelegramToken, UpdateTelegramToken } = require("../../src/lib/BdsSettings");
+// Set Telegram Bot
-const { GetKernel, arch, system } = require("../../src/lib/BdsSystemInfo");
+if (process.env.BDS_DOCKER_IMAGE === "true") {
-const { Detect } = require("../../src/CheckKill");
+  if (process.env.TelegramToken) BdsSettings.UpdateTelegramToken(process.env.TelegramToken);
-const { CheckTelegramUser } = require("../../src/UsersAndtokenChecks");
+}
-const BdsInfo = require("../../BdsManegerInfo.json");
+const TelegramToken = BdsSettings.GetTelegramToken();
+if (!TelegramToken) throw new Error("Add Telegram Token");
+const bot = new Telegraf(TelegramToken);
 
 // Bot Start And Help messages
 const HelpAndStart = [
@@ -14,303 +22,111 @@ const HelpAndStart = [
   "We are changing some things but everything is working!!",
   "Options:",
   "   /start or /help: This message!",
-  "   /basic",
-  "     start, stop, backup",
-  "   /live_log",
-  "     enabler, disabler",
-  "   /live_log",
-  "   /download",
-  "     Version",
   "   ",
 ];
+bot.start((ctx) => ctx.reply(HelpAndStart.join("\n")));
+bot.help((ctx) => ctx.reply(HelpAndStart.join("\n")));
 
-// Set Telegram Bot
+// Info
-const TelegramToken = GetTelegramToken();
+bot.command("info", async (ctx) => {
-if (!TelegramToken) throw new Error("Add Telegram Token");
+  const info = await BdsSystemInfo.SystemInfo();
-const bot = new Telegraf(TelegramToken);
+  const reply = [
+    `Bds Maneger Core Version: ${version}`,
+    "Available Servers (Platfroms):",
+    "",
+    `Bedrock: ${info.valid_platform.bedrock ? "Avaible" : "Not Avaible"}`,
+    `Java: ${info.valid_platform.java ? "Avaible" : "Not Avaible"}`,
+    `Pocketmine-MP: ${info.valid_platform.pocketmine ? "Avaible" : "Not Avaible"}`,
+    `Spigot: ${info.valid_platform.java ? "Avaible" : "Not Avaible"}`,
+    `Dragonfly: ${info.valid_platform.dragonfly ? "Avaible" : "Not Avaible"}`,
+  ];
+  return ctx.reply(reply.join("\n"));
+});
 
-// Start and Help Command
+// Setup User Token
-bot.start((ctx)=>ctx.reply(HelpAndStart.join("\n")));
+bot.command("token", async (ctx) => {
-bot.help((ctx)=>ctx.reply(HelpAndStart.join("\n")));
+  const AllTokens = BdsToken.GetAllTokens();
+  const TextToken = ctx.message.text.replace(/\/token\s+/, "");
+  if (AllTokens.length > 0) {
+    if (!TextToken) return ctx.reply("Please, add your token");
+    if (!BdsToken.CheckToken(TextToken)) return ctx.reply("Invalid Token");
+    BdsToken.UpdateTelegramID(TextToken, ctx.message.from.id);
+    return ctx.reply(`Token Associed to your account (You id: ${ctx.message.from.id})`);
+  } else {
+    ctx.reply("Please wait, we are setting up your fist token");
+    const FistToken = BdsToken.CreateToken("admin", ctx.message.from.id);
+    return ctx.reply(`Your fist token is: ${FistToken.Token}`);
+  }
+});
+
+// Send Command to Servers
+bot.command("command", async (ctx) => {
+  const user_id = ctx.message.from.id;
+  if (ctx.message.from.is_bot) return ctx.reply("You can't send commands to servers");
+  const command = ctx.message.text.replace(/^\/command\s+/i, "");
+  if (!(BdsToken.CheckTelegramID(user_id))) return ctx.reply("You are not allowed to send commands to servers or is not setup you Token");
+  const __Current_Sessions__ = BdsManegerServer.GetSessions();
+  const SessionsArray = Object.keys(__Current_Sessions__)
+  if (SessionsArray.length > 0) SessionsArray.forEach((key) => {
+    __Current_Sessions__[key].SendCommand(command);
+  }); else return ctx.reply("No Servers Running");
+});
+
+// Enable or Disable Player on connect
+let ReplyList = [];
+const TmpReplyList = path.join(os.tmpdir(), "ReplyList.json");
+const WriteTmpReplyList = () => fs.writeFileSync(TmpReplyList, JSON.stringify(ReplyList));
+if (fs.existsSync(TmpReplyList)) ReplyList = JSON.parse(fs.readFileSync(TmpReplyList));
+BdsManegerServer.RegisterPlayerGlobalyCallbacks((Actions) => {
+  const MountText = [];
+  Actions.forEach((action) => {
+    MountText.push(`${action.Player} ${action.Action}`);
+  });
+  ReplyList.forEach((reply) => {
+    return bot.telegram.sendMessage(reply.id, MountText.join("\n"));
+  });
+});
 
-// User
 bot.command("player", ctx => {
-  // Check admin Username
+  const ChatID = ctx.chat.id;
-  if (!(CheckTelegramUser(ctx.from.username))) return ctx.reply("you are not an administrator");
+  if (ReplyList.find(User => User.id === ChatID)) {
-  
+    ReplyList = ReplyList.filter(User => User.id !== ChatID);
-  const Server = global.ServerExec;
+    ctx.reply("Player on connect disabled");
-  const CtxOption = ctx.message.text.replace("/player", "").trim();
-  const CtxContext = CtxOption.replace(/^kick|^deop|^ban|^op/, "").trim();
-  if (CtxOption) {
-    const Players = CtxContext.split(/, |,/gi).filter(a => a.trim());
-    console.log(Players);
-    if (/kick/.test(CtxOption)){
-      if (Players.length >= 1) {
-        Players.forEach(Player => {
-          Server.kick(Player);
-          ctx.reply(`${Player} was kicked`);
-        });
-      } else ctx.reply("and the Players?")
-    }
-    else if (/deop/.test(CtxOption)){
-      if (Players.length >= 1) {
-        Players.forEach(Player => {
-          Server.deop(Player);
-          ctx.reply(`${Player} was deopped`);
-        });
-      } else ctx.reply("and the Players?")
-    }
-    else if (/ban/.test(CtxOption)){
-      if (Players.length >= 1) {
-        Players.forEach(Player => {
-          Server.ban(Player);
-          ctx.reply(`${Player} was banned`);
-        });
-      } else ctx.reply("and the Players?")
-    }
-    else if (/op/.test(CtxOption)){
-      if (Players.length >= 1) {
-        Players.forEach(Player => {
-          Server.op(Player);
-          ctx.reply(`${Player} was opped`);
-        });
-      } else ctx.reply("and the Players?")
-    }
-    else if (/list/.test(CtxOption)){
-      const Player_Json_path = GetPaths("player");
-      let Players_Json = JSON.parse(fs.readFileSync(Player_Json_path, "utf8"))[GetPlatform()];
-      const new_players = {};
-      Players_Json.forEach(Player => {
-        console.log(Player);
-        if (new_players[Player.Player]) {
-          new_players[Player.Player].push([`Action: ${Player.Action}`, `Date: ${Player.Date}`].join("\n"));
-        } else {
-          new_players[Player.Player] = [
-            [`Player: ${Player.Player}`, `Action: ${Player.Action}`, `Date: ${Player.Date}`].join("\n")
-          ]
-        }
-      });
-      console.log(new_players);
-      Object.getOwnPropertyNames(new_players).forEach(Player_Array => {
-        let Length = Math.abs(new_players[Player_Array].length - 5);
-        let Player = new_players[Player_Array].slice(0, Length).join("\n")
-        ctx.reply(Player);
-      });
-    }
-    else ctx.reply("Invalid option")
   } else {
-    const ReplyOption = Markup.keyboard([
+    ReplyList.push({ id: ChatID });
-      "/player kick",
+    ctx.reply("Player on connect enabled");
-      "/player deop",
-      "/player ban",
-      "/player op",
-      "/player list",
-    ]).oneTime().resize();
-    ctx.reply("Player Options:", ReplyOption);
   }
+  WriteTmpReplyList();
 });
 
-// Basic server
+// Get Catch
-bot.command("basic", async ctx => {
-  // Check admin Username
-  if (!(CheckTelegramUser(ctx.from.username))) return ctx.reply("you are not an administrator");
-
-  const text = ctx.message.text.replace("/basic", "").trim();
-  if (text) {
-    // Start Server
-    if (/start/.test(text)) {
-      if (Detect()) ctx.reply("Stop Server");
-      else {
-        try {
-          const Server = bds.start();
-          Server.log(function (data){
-            for (let stx of global.LiveLog) stx.reply(data);
-          });
-          global.ServerExec = Server;
-          return ctx.reply("Server Started")
-        } catch (err) {
-          console.log(err)
-          ctx.reply("We couldn't start the server")
-          ctx.reply(err.toString());
-        }
-      }
-    }
-    // Stop Server
-    else if (/stop/.test(text)) {
-      if (Detect()) {
-        try {
-          bds.stop()
-          ctx.reply("Stopping your server")
-        } catch (err) {
-          ctx.reply("We had an error for your server");
-          ctx.reply(err.toString());
-        }
-      } else ctx.reply("Your server is stopped")
-    }
-    // Backup
-    else if (/backup/.test(text)) {
-      const Backup = bds.backup();
-      ctx.replyWithDocument({
-        source: Backup.Buffer,
-        filename: Backup.file_name,
-      })
-    }
-    // Invalid option
-    else return ctx.reply("Invalid option, they are just: start, stop")
-  } else {
-    await ctx.deleteMessage();
-    const Options = Markup.keyboard([
-      "/basic start",
-      "/basic stop",
-      "/basic backup",
-    ]).oneTime().resize();
-    ctx.reply("Basic Options", Options);
-  }
-});
-
-// Select Platform
-bot.command("platform", async ctx => {
-  // Check admin Username
-  if (!(CheckTelegramUser(ctx.from.username))) return ctx.reply("you are not an administrator");
-
-  const text = ctx.message.text.replace("/platform", "").trim();
-  if (text) {
-    try {
-      bds.BdsSettigs.UpdatePlatform(text);
-      return ctx.reply(`Platform update to ${text}`)
-    } catch (err) {
-      ctx.reply("We were unable to change the platform")
-      return ctx.reply(err.toString())
-    }
-  } else {
-    await ctx.deleteMessage();
-    const Keyboard = Markup.keyboard([
-      "/platform bedrock",
-      "/platform java",
-      "/platform pocketmine",
-      "/platform jsprismarine"
-    ]).oneTime().resize();
-    ctx.reply("Select Platform", Keyboard)
-  }
-});
-
-// Download Server
-bot.command("download", async ctx => {
-  // Check admin Username
-  if (!(CheckTelegramUser(ctx.from.username))) return ctx.reply("you are not an administrator");
-
-  const version = ctx.message.text.replace(/\/download|[a-zA-Z]/gi, "").trim();
-  if (version) {
-    await bds.download(version, true);
-    ctx.reply(`Sucess install ${GetPlatform()} with version ${version}`);
-  } else {
-    await ctx.deleteMessage();
-    const KeyboardVersion = Markup.keyboard(Object.getOwnPropertyNames((await (await fetch(BdsInfo.Fetchs.servers)).json())[GetPlatform()]).map(version => {
-      return {
-        text: `/download ${version}`
-      }
-    })).oneTime().resize();
-    ctx.reply("Select Version to Install", KeyboardVersion);
-  }
-});
-
-// Command
-bot.command("command", async ctx => {
-  // Check admin Username
-  if (!(CheckTelegramUser(ctx.from.username))) return ctx.reply("you are not an administrator");
-
-  const text = ctx.message.text.replace("/command", "").trim();
-  if (!(Detect())) return ctx.reply("Your server is stopped");
-  if (text) {
-    try {
-      global.ServerExec.command(text);
-    } catch (err) {
-      ctx.reply("We couldn't execute the command");
-      ctx.reply(`${err}`);
-    }
-  } else {
-    await ctx.deleteMessage();
-    return ctx.reply("/command <command>");
-  }
-});
-
-// Send Info
-bot.command("info", ctx => {
-  const config = bds.get_config();
-  const InfoRes = [
-    `Bds Maneger core version: ${bds.package_json.version}`,
-    `Kernel: ${GetKernel()}`,
-    `Arch: ${arch}`,
-    `System:  ${system}`,
-    `Platform: ${GetPlatform()}`,
-    `World_name: ${config.world}`,
-    `Running: ${bds.detect()}`,
-    `Port_V4: ${config.portv4}`,
-    `Port_V6: ${config.portv6}`,
-    `Max_players: ${config.players}`,
-    `Whitelist: ${config.whitelist}`,
-  ]
-  ctx.reply(InfoRes.join("\n\n"));
-});
-
-// Live Log User
-global.LiveLog = [];
-bot.command("live_log", async ctx => {
-  // Check admin Username
-  if (!(CheckTelegramUser(ctx.from.username))) return ctx.reply("you are not an administrator");
-
-  const option = ctx.message.text.replace("/live_log", "").trim();
-  if (option) {
-    if (/enable/.test(option)) {
-      global.LiveLog.push(ctx);
-      return ctx.reply("Sucess");
-    } else if (/disable/.test(option)) {
-      // ctx.from.id
-      for (let ctx_Logs in global.LiveLog) {
-        if (global.LiveLog[ctx_Logs].from.id === ctx.from.id) {
-          delete global.LiveLog[ctx_Logs];
-          global.LiveLog = global.LiveLog.filter(a=>a);
-          return ctx.reply("Ok");
-        }
-      }
-      return ctx.reply("You are not in the list");
-    }
-  }
-  await ctx.deleteMessage();
-  const ReplyOption = Markup.keyboard([
-    "/live_log enable",
-    "/live_log disable",
-  ]).oneTime().resize();
-  ctx.reply("Enable/Disabled?", ReplyOption);
-});
-
-// text
-bot.on("text", ctx => {
-  console.log(ctx.message.text);
-  if (!(/\/.*/gi.test(ctx.message.text))) global.ServerExec.command(`say ${ctx.message.text}`)
-});
-
-// catch
 bot.catch(console.log);
 
 module.exports.description = "Start Bot of Telegram";
 module.exports.Args = [
   {
     arg: "t",
-    main: async () => bot.launch()
+    main: async () => {
+      console.log("Start Telegram Bot");
+      return bot.launch()
+    }
   },
   {
     arg: "telegram",
-    main: async () => bot.launch()
+    main: async () => {
-  },
+      console.log("Start Telegram Bot");
-  {
+      return bot.launch()
-    arg: "register_telegram_token",
-    main: async (Token = "") => {
-      if (!(Token && typeof Token === "string")) throw new Error("Token is not a string");
-      return UpdateTelegramToken(Token);
     }
   }
 ];
 module.exports.help = [
   "   -t, --telegram             Start Telegram Bot"
 ];
+module.exports.DockerImage = {
+  postStart: async () => {
+    if (BdsSettings.GetTelegramToken()) {
+      console.log("Start Telegram Bot");
+      return bot.launch();
+    }
+  }
+};

index.js

@@ -14,6 +14,10 @@ if (process.env.ShowLoadTime) console.time("Bds Maneger Core: Settings");
 module.exports.BdsSettings = require("./src/lib/BdsSettings");
 if (process.env.ShowLoadTime) console.timeEnd("Bds Maneger Core: Settings");
 
+if (process.env.ShowLoadTime) console.time("Bds Maneger Core: Token");
+module.exports.BdsToken = require("./src/lib/Token");
+if (process.env.ShowLoadTime) console.timeEnd("Bds Maneger Core: Token");
+
 if (process.env.ShowLoadTime) console.time("Bds Maneger Core: System Info");
 module.exports.BdsSystemInfo = require("./src/lib/BdsSystemInfo");
 if (process.env.ShowLoadTime) console.timeEnd("Bds Maneger Core: System Info");

src/BdsBackup.js

@@ -51,7 +51,7 @@ function CreateBackup() {
   }
 
   // The Bds Maneger Core Backup
-  for (let index of ["BdsConfig.yaml", "bds_tokens.json"]) if (fs.existsSync(join(bds_dir, index))) zip.addLocalFile(join(bds_dir, index));
+  for (let index of ["BdsConfig.yaml", "BdsToken.json"]) if (fs.existsSync(join(bds_dir, index))) zip.addLocalFile(join(bds_dir, index));
   
   for (let index of Object.getOwnPropertyNames(GetPaths("all")).filter(path => !/servers|backups/.test(path)).map(name => GetPaths(name))) {
     if (fs.existsSync(index)) {

src/BdsManegerServer.js

@@ -12,6 +12,11 @@ const BasicCommands = require("./ManegerServer/BasicCommands");
 const ServerSessions = {};
 module.exports.GetSessions = () => ServerSessions;
 
+const PlayersCallbacks = [];
+module.exports.RegisterPlayerGlobalyCallbacks = function RegisterPlayerGlobalyCallbacks(callback){
+  PlayersCallbacks.push(callback);
+}
+
 module.exports.StartServer = function start() {
   const commandExists = require("../src/lib/commandExist");
   const io = require("./api").SocketIO;
@@ -218,10 +223,13 @@ module.exports.StartServer = function start() {
       UUID: returnFuntion.uuid,
       data: data
     });
-    PlayerJson.CreatePlayerJson(data, Actions => {
+    PlayerJson.CreatePlayerJson(data, async Actions => {
       if (Actions.length === 0) return;
       PlayerJson.UpdateUserJSON(Actions);
       io.emit("PlayerAction", Actions);
+      PlayersCallbacks.forEach(async callback => {
+        if (typeof callback === "function") return callback(Actions);
+      });
     });
   });
 
@@ -231,22 +239,6 @@ module.exports.StartServer = function start() {
   return returnFuntion;
 }
 
-// Search player in JSON
-module.exports.Player_Search = function Player_Search(player = "dontSteve") {
-  const Player_Json_path = BdsSettings.GetPaths("player"), Current_platorm = BdsSettings.GetPlatform();
-  const Players_Json = JSON.parse(fs.readFileSync(Player_Json_path, "utf8"))[Current_platorm]
-  for (let Player of Players_Json) {
-    if (Player.Player === player.trim()) return Player;
-  }
-  return {};
-}
-
-module.exports.GetFistSession = function GetFistSession(){
-  const ArraySessions = Object.getOwnPropertyNames(ServerSessions)
-  if (ArraySessions.length === 0) throw "Start Server";
-  return ServerSessions[0]
-}
-
 module.exports.CronBackups = BdsSettings.GetCronBackup().map(Crron => {
   const Cloud_Backup = {
     Azure: require("./clouds/Azure").Uploadbackups,

src/ManegerServer/Players_json.js

@@ -9,13 +9,12 @@ function CreatePlayerJson(data = "", callback = (d = [{Player: "", Action: "conn
     // "[INFO] Player disconnected: Sirherobrine, xuid: 2535413418839840",
     const BedrockMap = data.split(/\n|\r/gi).map(line => {
       if (line.includes("connected")) {
-        let SplitLine = line.replace(/\[.+\]\s+Player/gi, "").trim().split(/\s+/gi);
         let Actions = "";
-        if (/^disconnected/.test(SplitLine[0].trim())) Actions = "disconnect"; else Actions = "connect";
+        if (/^disconnected/.test(line)) Actions = "disconnect"; else Actions = "connect";
 
         // Object Map
         const ObjectReturn = {
-          Player: line.replace(/^.*connected:/gi, "").replace(/, xuid:.*$/gi, "").trim(),
+          Player: line.replace(/^.*connected:|,.*xuid:.*$/gi, "").trim(),
           Action: Actions,
           Platform: Current_platorm,
           xuid: line.replace(/^.*,.*xuid:/gi, "").trim(),

src/UsersAndtokenChecks.js

@@ -1,43 +0,0 @@
-const { bds_dir, GetServerBan, GetTelegramAdmins, GetPlatform, GetPaths } = require("../src/lib/BdsSettings");
-const { existsSync, readFileSync } = require("fs")
-const { join } = require("path")
-
-function CheckTelegramUser(admin_name){
-  for(let admin_check of GetTelegramAdmins()){
-    if (admin_name === admin_check || admin_check === "all_users") return true;
-  }
-  return false
-}
-
-function CheckPlayer(player = "null"){
-  const json = require(GetPaths("player"))[GetPlatform()];
-  if (json[player]) return true; else return false
-}
-
-function token_verify(token){
-  const path_tokens = join(bds_dir, "bds_tokens.json");
-  if (existsSync(path_tokens)) var tokens = JSON.parse(readFileSync(path_tokens, "utf8")); else return false
-  for (let token_verify of tokens) {
-    const element = token_verify.token
-    if (element === token) return true
-  }
-  return false
-}
-
-function CheckBan(player){
-  var players = GetServerBan();
-  for(let check_ in players){
-    const admin_check = players[check_]
-    if (player === admin_check.username) {
-      if (admin_check[GetPlatform()]) return true
-    }
-  }
-  return false
-}
-
-module.exports = {
-  CheckTelegramUser,
-  CheckPlayer,
-  CheckBan,
-  token_verify
-}

src/api.js

@@ -1,13 +1,11 @@
 // Node Modules
 const os = require("os");
 const fs = require("fs");
-const path = require("path");
-const { randomUUID } = require("crypto");
 // Bds Maneger Core
 const BdsManegerCore = require("../index");
 const BdsSystemInfo = require("../src/lib/BdsSystemInfo");
-const BdsChecks = require("./UsersAndtokenChecks");
 const BdsSettings = require("../src/lib/BdsSettings");
+const TokenManeger = require("./lib/Token");
 
 // Init Express
 const express = require("express");
@@ -38,7 +36,7 @@ io.use(function (socket, next) {
   const { headers, query } = socket.handshake;
   const Token = headers["AuthorizationToken"] || query["token"] || query["Token"];
   if (Token) {
-    if (BdsChecks.token_verify(Token)) {
+    if (TokenManeger.CheckToken(Token, "all")) {
       socket.token = Token;
       return next();
     }
@@ -57,46 +55,51 @@ app.all(["/v2", "/v2/*"], ({res}) => res.status(401).json({
 
 // Check Token
 function CheckToken (req, res, next) {
-  if (req.method === "GET") {
+  if (req.headers["AuthorizationToken"]) {
+    if (TokenManeger.CheckToken(req.headers["AuthorizationToken"], "all")) {
+      req.token = req.headers["AuthorizationToken"];
+      return next();
+    }
+  } else if (req.method === "GET") {
     if (req.query.token) {
-      if (BdsChecks.token_verify(req.query.token)) {
+      if (TokenManeger.CheckToken(req.query.token, "all")) {
         req.token = req.query.token;
         return next();
       }
     } else if (req.headers.token) {
-      if (BdsChecks.token_verify(req.headers.token)) {
+      if (TokenManeger.CheckToken(req.headers.token, "all")) {
         req.token = req.headers.token;
         return next();
       }
     } else if (req.query.Token) {
-      if (BdsChecks.token_verify(req.query.Token)) {
+      if (TokenManeger.CheckToken(req.query.Token, "all")) {
         req.token = req.query.Token;
         return next();
       }
     } else if (req.headers.Token) {
-      if (BdsChecks.token_verify(req.headers.Token)) {
+      if (TokenManeger.CheckToken(req.headers.Token, "all")) {
         req.token = req.headers.token;
         return next();
       }
     }
   } else {
     if (req.body.token) {
-      if (BdsChecks.token_verify(req.body.token)) {
+      if (TokenManeger.CheckToken(req.body.token, "all")) {
         req.token = req.body.token;
         return next();
       }
     } else if (req.headers.token) {
-      if (BdsChecks.token_verify(req.headers.token)) {
+      if (TokenManeger.CheckToken(req.headers.token, "all")) {
         req.token = req.headers.token;
         return next();
       }
     } else if (req.body.Token) {
-      if (BdsChecks.token_verify(req.body.Token)) {
+      if (TokenManeger.CheckToken(req.body.Token, "all")) {
         req.token = req.body.Token;
         return next();
       }
     } else if (req.headers.Token) {
-      if (BdsChecks.token_verify(req.headers.Token)) {
+      if (TokenManeger.CheckToken(req.headers.Token, "all")) {
         req.token = req.headers.Token;
         return next();
       }
@@ -432,58 +435,7 @@ function API(port_api = 1932, callback = port => {console.log("Bds Maneger Core
   return port;
 }
 
-// Bds Maneger Core API token Register
-const path_tokens = path.join(BdsSettings.bds_dir, "bds_tokens.json");
-/**
- * 
- * Register new Token to API and more features in the Bds Maneger Core.
- * 
- * @param {Array} Admin_Scoper - Array of Admin Scoper (Soon will be implemented)
- * @returns {String} Token - Token of the API
- */
-function token_register(Admin_Scoper = ["web_admin", "admin"]) {
-  Admin_Scoper = Array.from(Admin_Scoper).filter(scoper => /admin/.test(scoper));
-  let tokens = [];
-  if (fs.existsSync(path_tokens)) tokens = JSON.parse(fs.readFileSync(path_tokens, "utf8"));
-  // Get UUID
-  const getBdsUUId = randomUUID().split("-");
-  const bdsuid = "bds_" + (getBdsUUId[0]+getBdsUUId[2].slice(0, 15));
-  // Save BdsUUID
-  tokens.push({
-    token: bdsuid,
-    date: new Date(),
-    scopers: Admin_Scoper
-  });
-  fs.writeFileSync(path_tokens, JSON.stringify(tokens, null, 4), "utf8");
-  return bdsuid;
-}
-
-// Bds Maneger Core API Delete token
-/**
- * 
- * Delete Token of the API
- * 
- * @param {String} Token - Token of the API to delete
- * @returns {Boolean} - True if the token is deleted
- */
-function delete_token(Token = "") {
-  if (!Token) return false;
-  if (typeof Token !== "string") return false;
-  let tokens = [];
-  if (fs.existsSync(path_tokens)) tokens = JSON.parse(fs.readFileSync(path_tokens, "utf8"));
-  if (tokens.filter(token => token.token === Token).length > 0) {
-    fs.writeFileSync(path_tokens, JSON.stringify(tokens, null, 4), "utf8");
-    return true;
-  } else return false;
-}
-
-// Check Exists Tokens Files
-if (!(fs.existsSync(path_tokens))) token_register();
-
 module.exports.api = API;
-module.exports.token_register = token_register;
-module.exports.delete_token = delete_token;
-module.exports.TokensFilePath = path_tokens;
 module.exports.BdsRoutes = {
   App: app,
   Server: Server

src/lib/BdsSettings.js

@@ -96,7 +96,7 @@ var Config = {
   telegram: {
     admins: ["all_users"],
     ban: ["Steve_mine_mine"],
-    token: null
+    token: ""
   }
 }
 

src/lib/Token.js

@@ -0,0 +1,103 @@
+const crypto = require("crypto");
+const fs = require("fs");
+const path = require("path");
+
+let Tokens = [
+  {
+    Token: "",
+    TelegramID: 0,
+    Scoped: "admin"
+  },
+  {
+    Token: "",
+    TelegramID: null,
+    Scoped: "user"
+  }
+];
+
+const BdsSettings = require("./BdsSettings");
+const TokenFile = path.join(BdsSettings.bds_dir, "BdsToken.json");
+const Save = () => fs.writeFileSync(TokenFile, JSON.stringify(Tokens, null, 2));
+if (fs.existsSync(TokenFile)) Tokens = JSON.parse(fs.readFileSync(TokenFile, "utf8"));
+else {
+  Tokens = [];
+  Save();
+}
+
+/**
+ * Register new Token to Bds Maneger Core
+ *
+ */
+function CreateToken(AdminScoped = "admin", TelegramID = null) {
+  if (!(AdminScoped === "admin" || AdminScoped === "user")) throw new Error("Invalid Admin Scoped, valid use admin and user");
+  const GetRandomUUID = crypto.randomUUID().split("-");
+  const TokenObject = {
+    Token: `BdsTks_${GetRandomUUID[0]}${GetRandomUUID[GetRandomUUID.length - 1]}`,
+    TelegramID: TelegramID,
+    Scoped: AdminScoped
+  }
+  Tokens.push(TokenObject);
+  Save();
+  return TokenObject;
+}
+
+/**
+ * Delete Token
+ */
+function DeleteToken(Token = "") {
+  if (!Token) throw new Error("Inform valid Token");
+  if (!(Tokens.find(token => token.Token === Token))) throw new Error("this token not exists.");
+  Tokens = Tokens.filter(token => token.Token !== Token);
+  Save();
+  return true;
+}
+
+/**
+ * Check for is valid Token
+ */
+function CheckToken(Token = "", Scope = "admin") {
+  if (!Token) throw new Error("Inform valid Token");
+  if (!(Scope === "admin" || Scope === "user" || Scope === "all")) throw new Error("Invalid Scope, valid use admin and user");
+  // Tmp Tokens
+  let TmpTokens = Tokens;
+  if (Scope !== "all") {
+    if (Scope === "user") TmpTokens = TmpTokens.filter(token => token.Scoped === "user");
+    else if (Scope === "admin") TmpTokens = TmpTokens.filter(token => token.Scoped === "admin");
+  }
+  // Check if Token exists
+  if (TmpTokens.find(token => token.Token === Token)) return true;
+  else return false;
+}
+
+/**
+ * Update TelegramID for Token
+ */
+function UpdateTelegramID(Token = "", TelegramID = null) {
+  if (!Token) throw new Error("Inform valid Token");
+  if (!TelegramID) throw new Error("Inform valid TelegramID");
+  if (!(CheckToken(Token, "all"))) throw new Error("this token not exists.");
+  Tokens = Tokens.map(token => {
+    if (token.Token === Token) token.TelegramID = TelegramID;
+    return token;
+  });
+  Save();
+  return;
+}
+
+/** */
+function CheckTelegramID(TelegramID = null) {
+  if (!TelegramID) throw new Error("Inform valid TelegramID");
+  if (Tokens.find(token => token.TelegramID === TelegramID)) return true;
+  else return false;
+}
+
+// Export module
+module.exports = {
+  CreateToken,
+  DeleteToken,
+  CheckToken,
+  UpdateTelegramID,
+  CheckTelegramID,
+  TokenFile,
+  GetAllTokens: () => Tokens
+}