316 lines
10 KiB
TypeScript
316 lines
10 KiB
TypeScript
import { CClient, HelpServer, Komand, KomandNaExport, Modul, SRecord } from "../utils/types";
|
|
import { join } from "path";
|
|
import { existsSync, readFileSync, writeFileSync } from "fs";
|
|
import { oddiakritikovat, send, strankovani } from "../utils/utils";
|
|
import { APIEmbed, Message } from "discord.js";
|
|
|
|
let client: CClient;
|
|
const cesta = `${join(__dirname, "../../res/")}custom`;
|
|
const helpServer: HelpServer = require("../utils/helpServer");
|
|
let zakladniKomandy: SRecord<Komand>;
|
|
let zakladniAliasy: SRecord<string>;
|
|
let customKomandy: SRecord<{ text: string; owner: string; }>;
|
|
let customAliasy: SRecord<{ cmd: string; owner: string; }>;
|
|
|
|
function spojit() {
|
|
const cKomandyAsKomand: SRecord<Komand> = {};
|
|
const cKomandyForExport: KomandNaExport[] = [];
|
|
|
|
for (const komand in customKomandy) {
|
|
cKomandyAsKomand[komand] = { run: customKomandy[komand].text };
|
|
cKomandyForExport.push({ name: komand, custom: true });
|
|
}
|
|
|
|
client.komandy = { ...cKomandyAsKomand, ...zakladniKomandy };
|
|
|
|
helpServer.customKomandy = cKomandyForExport;
|
|
|
|
const cAliasyForExport: SRecord<string> = {};
|
|
|
|
for (const alias in customAliasy) {
|
|
cAliasyForExport[alias] = customAliasy[alias].cmd;
|
|
}
|
|
|
|
client.aliasy = { ...zakladniAliasy, ...cAliasyForExport };
|
|
helpServer.customAliasy = cAliasyForExport;
|
|
}
|
|
|
|
function save() {
|
|
writeFileSync(`${cesta}Komandy.json`, JSON.stringify(customKomandy));
|
|
writeFileSync(`${cesta}Aliasy.json`, JSON.stringify(customAliasy));
|
|
spojit();
|
|
}
|
|
|
|
function komandNeboAlias(nazev: string) {
|
|
if (customKomandy[nazev]) return { jeKomand: true, cmd: customKomandy[nazev] };
|
|
if (customAliasy[nazev]) return { jeKomand: false, cmd: customAliasy[nazev] };
|
|
return { jeKomand: false };
|
|
}
|
|
|
|
function zmrdovoAliasy(zacatek: string, owner: string, mes: Message) {
|
|
const arr = [`${zacatek}:\n`];
|
|
|
|
for (const key in customKomandy) {
|
|
if (customKomandy[key].owner == owner) arr.push(key);
|
|
}
|
|
|
|
arr.push("\najilasy:\n");
|
|
|
|
for (const key in customAliasy) {
|
|
if (customAliasy[key].owner == owner) arr.push(key);
|
|
}
|
|
|
|
let text = "";
|
|
arr.forEach(element => {
|
|
if (text.length + element.length > 2000) {
|
|
send(mes, { content: text, allowedMentions: { users: [] } });
|
|
text = "";
|
|
}
|
|
text += `${element}\n`;
|
|
});
|
|
|
|
send(mes, { content: text, allowedMentions: { users: [] } });
|
|
}
|
|
|
|
const exp: Modul = {
|
|
more_komandy: {
|
|
naucse: {
|
|
arg: "<název nového komandu> <text nového komandu>",
|
|
run: (mes, arg) => {
|
|
const args = arg.split(/\s/).filter(v => v != "");
|
|
if (args.length == 0) return "a co se mam jako naucit";
|
|
if (args.length == 1) return "a co bich nato mnel rict????";
|
|
|
|
const name = oddiakritikovat(args[0].toLowerCase());
|
|
if (zakladniKomandy[name] || customKomandy[name]) return "tuten komand uz ale egzistuje";
|
|
if (zakladniAliasy[name] || customAliasy[name]) return "tuto uz je ale alijas";
|
|
|
|
customKomandy[name] = { text: args.splice(1).join(" "), owner: mes.author.id };
|
|
save();
|
|
return "jo";
|
|
}
|
|
},
|
|
|
|
naucsealias: {
|
|
arg: "<název nového aliasu> <název existujícího komandu nebo aliasu>",
|
|
als: ["naucsea"],
|
|
run: (mes, arg) => {
|
|
const args = arg.split(/\s/).filter(v => v != "").map(e => oddiakritikovat(e).toLowerCase());
|
|
|
|
if (args.length == 0) return "a co se mam jako naucit";
|
|
if (args.length == 1) return "a co to ma znamenat????";
|
|
|
|
if (zakladniKomandy[args[0]] || customKomandy[args[0]]) return "tuto uz je ale komand";
|
|
if (zakladniAliasy[args[0]] || customAliasy[args[0]]) return "tuto uz ale egzistuje";
|
|
|
|
let jmeno: string;
|
|
if (!zakladniKomandy[args[1]] && !zakladniAliasy[args[1]]) {
|
|
if (!customKomandy[args[1]] && !customAliasy[args[1]]) return `nejze "${args[1]}" neni realnej ani vlastni komand ani alias`;
|
|
jmeno = customKomandy[args[1]] ? args[1] : customAliasy[args[1]].cmd;
|
|
} else jmeno = zakladniKomandy[args[1]] ? args[1] : zakladniAliasy[args[1]];
|
|
|
|
if (args.length > 2) jmeno += " " + args.slice(2).join(" ");
|
|
|
|
customAliasy[args[0]] = { cmd: jmeno, owner: mes.author.id };
|
|
save();
|
|
return "jo";
|
|
}
|
|
},
|
|
|
|
zapomen: {
|
|
arg: "název komandu nebo aliasu",
|
|
run: (mes, arg) => {
|
|
const name = oddiakritikovat(arg.toLowerCase());
|
|
|
|
if (name == "") return "a co mam jako zapomenout";
|
|
|
|
if (zakladniKomandy[name]) return "tuten komand se neda smazat ti smazko";
|
|
if (zakladniAliasy[name]) return "tuten alijaas se neda smazat ti smazko";
|
|
|
|
const { jeKomand, cmd } = komandNeboAlias(name);
|
|
if (!cmd) return `"${name}" nen komnad an alias`;
|
|
|
|
if (cmd.owner != mes.author.id) return "tuto ael neni tvoje toxikale zkurvenej";
|
|
|
|
jeKomand ? delete customKomandy[name] : delete customAliasy[name];
|
|
save();
|
|
return "jo";
|
|
}
|
|
},
|
|
|
|
kohoje: {
|
|
arg: "název komandu nebo aliasu",
|
|
run: (_, arg) => {
|
|
const cmdName = oddiakritikovat(arg.toLowerCase());
|
|
const cmd = customKomandy[cmdName] ?? customAliasy[cmdName];
|
|
|
|
if (!cmd) return `"${cmdName}" nen vlastny komand an alijas`;
|
|
|
|
return `vlastnitel je <@${cmd.owner}>`;
|
|
}
|
|
},
|
|
|
|
mojekomandy: mes => {
|
|
zmrdovoAliasy("tovje koamdy", mes.author.id, mes);
|
|
},
|
|
|
|
jehokomandy: {
|
|
DMUnsafe: true,
|
|
run: mes => {
|
|
const kdo = mes.mentions.members?.first();
|
|
|
|
if (!kdo) return "ael koho";
|
|
|
|
zmrdovoAliasy(`koamdy kkta ${kdo.nickname}`, kdo.id, mes);
|
|
}
|
|
},
|
|
|
|
uprav: {
|
|
arg: "název komandu",
|
|
run: (mes, arg) => {
|
|
const args = arg.split(/\s/).filter(v => v != "");
|
|
|
|
if (args.length == 0) return "a co mam jako vopravit";
|
|
if (args.length == 1) return "a co bich nato mnel rict????";
|
|
|
|
const name = oddiakritikovat(args[0].toLowerCase());
|
|
|
|
if (zakladniKomandy[name]) return "tuten komand se neda vopravit";
|
|
if (zakladniAliasy[name]) return "tuten alijaas se neda vopravit";
|
|
|
|
const { jeKomand, cmd } = komandNeboAlias(name);
|
|
if (!cmd) return `"${name}" nen komnad an alias`;
|
|
|
|
if (cmd.owner != mes.author.id) return "tuto ael neni tvoe toxikale zkurvenej";
|
|
|
|
jeKomand ? delete customKomandy[name] : delete customAliasy[name];
|
|
|
|
customKomandy[name] = { text: args.splice(1).join(" "), owner: mes.author.id };
|
|
save();
|
|
return "jo";
|
|
}
|
|
},
|
|
|
|
uprava: {
|
|
arg: "název aliasu",
|
|
run: (mes, arg) => {
|
|
const args = arg.split(/\s/).filter(v => v != "").map(v => oddiakritikovat(v));
|
|
const name = args[0];
|
|
|
|
if (args.length == 0) return "a co mam jako vopravit";
|
|
if (args.length == 1) return "a co to ma znamenat????";
|
|
|
|
if (zakladniKomandy[name]) return "tuten komand se neda vopravit";
|
|
if (zakladniAliasy[name]) return "tuten alijaas se neda vopravit";
|
|
|
|
const { jeKomand, cmd } = komandNeboAlias(name);
|
|
if (!cmd) return `"${name}" nen komnad an alias`;
|
|
|
|
if (cmd.owner != mes.author.id) return "tuto ael neni tvoe toxikale zkurvenej";
|
|
|
|
let jmeno: string;
|
|
if (!zakladniKomandy[args[1]] && !zakladniAliasy[args[1]]) {
|
|
if (!customKomandy[args[1]] && !customAliasy[args[1]]) return `nejze "${args[1]}" neni realnej ani vlastni komand ani alias`;
|
|
jmeno = customKomandy[args[1]] ? args[1] : customAliasy[args[1]].cmd;
|
|
} else jmeno = zakladniKomandy[args[1]] ? args[1] : zakladniAliasy[args[1]];
|
|
|
|
jeKomand ? delete customKomandy[name] : delete customAliasy[name];
|
|
|
|
customAliasy[args[0]] = { cmd: jmeno, owner: mes.author.id };
|
|
save();
|
|
return "jo";
|
|
}
|
|
},
|
|
|
|
aliasy: {
|
|
arg: "název komandu nebo jedno z aliasů",
|
|
run: (mes, arg) => {
|
|
const name = arg.toLowerCase();
|
|
const cmdName = client.aliasy[name] ?? name;
|
|
|
|
let celkovadylka = 0;
|
|
const stranky: string[][] = [[]];
|
|
let aktualniStranka = 0;
|
|
for (const key in client.aliasy) {
|
|
const val = client.aliasy[key];
|
|
if (val != cmdName) continue;
|
|
|
|
const dylka = key.length + 3;
|
|
celkovadylka += dylka;
|
|
if (celkovadylka > 1024 || stranky[aktualniStranka].length == 20) {
|
|
aktualniStranka++;
|
|
celkovadylka = dylka;
|
|
}
|
|
|
|
const stranka = stranky[aktualniStranka] ??= [];
|
|
stranka.push(key);
|
|
}
|
|
|
|
if (!celkovadylka) return `"${name}" bud nen9 komand ani ajilas nebo nema ajilasi vubec`;
|
|
|
|
const zacatekNazvu = `alijasy pro **${cmdName}**:`;
|
|
const embed: APIEmbed = {
|
|
color: 13697024,
|
|
fields: [{ name: zacatekNazvu, value: `• ${stranky[0].join("\n• ")}` }]
|
|
};
|
|
|
|
if (stranky.length == 1) return { embeds: [embed] };
|
|
|
|
embed.fields![0].name += ` (1/${stranky.length})`;
|
|
|
|
strankovani(mes.channel, embed, zacatekNazvu, stranky);
|
|
}
|
|
},
|
|
|
|
coje: {
|
|
arg: "název komandu nebo aliasu",
|
|
run: (_, arg) => {
|
|
const nazev = oddiakritikovat(arg.toLowerCase());
|
|
|
|
// Vestavěnej komand
|
|
const vZakladni = zakladniKomandy[nazev]?.run;
|
|
if (typeof vZakladni == "function")
|
|
return "tuto je slozitej kmenovej koamnd";
|
|
|
|
if (typeof vZakladni == "string")
|
|
return `tuto je kmenovej koamnd a povida "${vZakladni}"`;
|
|
|
|
// Vestavěnej alias
|
|
const vZakladniAlias = zakladniAliasy[nazev];
|
|
if (vZakladniAlias)
|
|
return `tuto je kmenovej alijaas na "${vZakladniAlias}"`;
|
|
|
|
// Vlastní komand
|
|
const vlastniKomand = customKomandy[nazev];
|
|
if (vlastniKomand) {
|
|
const jekod = vlastniKomand.text.startsWith("dj:");
|
|
const textZatim = `tuto je valstni koamnd <@${vlastniKomand.owner}> a ${jekod ? "tahle fukue" : "povida"}:\`\`\``;
|
|
return `${textZatim}${vlastniKomand.text.slice(0, 1997 - textZatim.length)}\`\`\``;
|
|
}
|
|
|
|
// Vlastní alias
|
|
const vlastniAlias = customAliasy[nazev];
|
|
if (vlastniAlias)
|
|
return `tuto je vlastni alijaas <@${vlastniAlias.owner}> na "${vlastniAlias.cmd}"`;
|
|
|
|
return `${nazev} nic neeni`;
|
|
}
|
|
}
|
|
},
|
|
|
|
on_ready: () => {
|
|
client = module.exports.client;
|
|
zakladniKomandy = client.komandy;
|
|
zakladniAliasy = client.aliasy;
|
|
|
|
if (!existsSync(`${cesta}Komandy.json`)) customKomandy = {};
|
|
else customKomandy = JSON.parse(readFileSync(`${cesta}Komandy.json`).toString());
|
|
if (!existsSync(`${cesta}Aliasy.json`)) customAliasy = {};
|
|
else customAliasy = JSON.parse(readFileSync(`${cesta}Aliasy.json`).toString());
|
|
|
|
spojit();
|
|
}
|
|
};
|
|
|
|
module.exports = exp;
|