Dinamik Dil Desteği, Gerçek Zamanlı İnteraksiyon paylaşma

Co-Authored-By: Erdem <[email protected]>

Author: TheArmagan

config.js

@@ -13,6 +13,8 @@ module.exports = new (require("./types/Config"))({
     // Okumanızı tavsiye ederim: https://discordjs.guide/popular-topics/intents.html
     intents: ["GUILDS", "GUILD_MESSAGES", "GUILD_MEMBERS", "GUILD_WEBHOOKS"]
   },
+  // Botunuzun varsayılan dili.
+  defaultLanguage: "tr",
   // Diğer ayarlar. Bunun içine ne isterseniz koyabilirsiniz.
   // Ulaşmak için "Underline.config.other" objesini kullanabilirsiniz.
   other: {
@@ -30,60 +32,37 @@ module.exports = new (require("./types/Config"))({
   userErrors: {
     // Arka arkaya interaksiyon kullanma limiti aşıldığında.
     coolDown(interaction, uInteraction, coolDown, type, other) {
-      switch (type) {
-        case "user": {
-          interaction.reply({ ephemeral: true, content: `Bu interaksiyonu sen tekrardan ${(coolDown / 1000).toFixed(2)} saniye içerisinde kullanabilirsin.` })
-          break;
-        }
-        case "member": {
-          interaction.reply({ ephemeral: true, content: `Bu interaksiyonu bu sunucuda tekrardan senin kullanabilmen için  ${(coolDown / 1000).toFixed(2)} saniye beklemen lazım.` })
-          break;
-        }
-        case "guild": {
-          interaction.reply({ ephemeral: true, content: `Bu interaksiyonu bu sunucuda tekrardan ${(coolDown / 1000).toFixed(2)} saniye içerisinde kullanabilirsin.` })
-          break;
-        }
-        case "channel": {
-          interaction.reply({ ephemeral: true, content: `Bu interaksiyonu bu kanalda tekrardan ${(coolDown / 1000).toFixed(2)} saniye içerisinde kullanabilirsin.` })
-          break;
-        }
-        case "message": {
-          interaction.reply({ ephemeral: true, content: `Bu interaksiyonu bu mesajda tekrardan ${(coolDown / 1000).toFixed(2)} saniye içerisinde kullanabilirsin.` })
-          break;
-        }
-        case "any": {
-          interaction.reply({ ephemeral: true, content: `Bu interaksiyonu tekrardan ${(coolDown / 1000).toFixed(2)} saniye içerisinde kullanabilirsin.` })
-          break;
-        }
-      }
-      
+      interaction.reply({
+        ephemeral: true,
+        content: other.locale.userErrors.coolDown[type]((coolDown / 1000).toFixed(2))
+      });
     },
     // interaksiyon kapalı olduğunda
     disabled(interaction, uInteraction, other) {
-      interaction.reply({ ephemeral: true, content: "Bu interaksiyon kapalı." });
+      interaction.reply({ ephemeral: true, content: other.locale.userErrors.disabled() });
     },
     // Kullanıcı bottan yasaklı olduğunda.
     blocked(interaction, uInteraction, other) {
-      interaction.reply({ ephemeral: true, content: "Bottan yasaklanmışsınız." });
+      interaction.reply({ ephemeral: true, content: other.locale.userErrors.blocked() });
     },
     // interaksiyon sadece geliştiricilere özel olduğunda.
     developerOnly(interaction, uInteraction, other) {
-      interaction.reply({ ephemeral: true, content: `Bu interaksiyonu sadece bot geliştiricileri kullanabilir.` })
+      interaction.reply({ ephemeral: true, content: other.locale.userErrors.developerOnly() });
     },
     // interaksiyon sadece sunucu sahiplerine özel olduğunda.
     guildOwnerOnly(interaction, uInteraction, other) {
-      interaction.reply({ ephemeral: true, content: `Bu interaksiyonu sadece sunucu sahipleri kullanabilir.` })
+      interaction.reply({ ephemeral: true, content: other.locale.userErrors.guildOwnerOnly() });
     },
     guildOnly(interaction, uInteraction, other) {
-      interaction.reply({ ephemeral: true, content: `Bu interaksiyonu sadece sunucularda kullanılabilir.` })
+      interaction.reply({ ephemeral: true, content: other.locale.userErrors.guildOnly() });
     },
     // Botun çalışmak için x yertkilerine ihtiyacı olduğunda.
     botPermsRequired(interaction, uInteraction, perms, other) {
-      interaction.reply({ ephemeral: true, content: `Bu interaksiyonun çalışması için ${perms.join(", ")} yetkilerine ihtiyacım var.` })
+      interaction.reply({ ephemeral: true, content: other.locale.userErrors.botPermsRequired(perms.join(", ")) });
     },
     // Kullanıcının interaksiyonu kullanabilmek için x yetkilerine ihtiyacı olduğunda.
     userPermsRequired(interaction, uInteraction, perms, other) {
-      interaction.reply({ ephemeral: true, content: `Bu interaksiyonu kullanabilmek için ${perms.join(", ")} yetkilerine ihtiyacın var.` })
+      interaction.reply({ ephemeral: true, content: other.locale.userErrors.userPermsRequired(perms.join(", ")) });
     },
   },
   // Her interaksiyonun varsayılan ayarları her anahtarın ne
@@ -135,6 +114,8 @@ module.exports = new (require("./types/Config"))({
   async onInteraction(uInteraction, interaction, other) {
     return true;
   },
+  // İnteraksiyon hatasız bir şekilde çalıştıktan sonra tetikleniyor. (Armağan: peki.)
+  async onAfterInteraction(uInteraction, interaction, other) { },
   // eventteki bütün kontrolleri geçtikten sonra, event
   // hemen çalıştırılmadan önce çalışır.
   // Sadece cevap true ise işleme devam eder.

globals.d.ts

@@ -3,6 +3,7 @@
 interface Underline {
   interactions: import("discord.js").Collection<string, import("./types/Interaction") >
   events: import("discord.js").Collection<string, import("./types/Event") >
+  locales: import("discord.js").Collection<string, import("./types/Locale") >
   config: import("./types/Config");
   client: import("discord.js").Client;
   Interaction: typeof import("./types/Interaction"),
@@ -12,6 +13,7 @@ interface Underline {
   Event: typeof import("./types/Event"),
   Button: typeof import("./types/Button"),
   SelectMenu: typeof import("./types/SelectMenu"),
+  Locale: typeof import("./types/Locale"),
 
   reload(): Promise<any>;
 

index.js

@@ -10,21 +10,25 @@ const { makeSureFolderExists } = require("stuffs");
 const client = new Discord.Client(config.clientOptions);
 const interactions = new Discord.Collection();
 const events = new Discord.Collection();
+const locales = new Discord.Collection();
 let interactionFiles;
 let eventFiles;
+let localeFiles;
 globalThis.Underline = {
   ...config.globalObjects,
   config,
   client,
   interactions,
   events,
+  locales,
   Interaction: require('./types/Interaction'),
   Event: require('./types/Event'),
   SlashCommand: require("./types/SlashCommand"),
   MessageAction: require("./types/MessageAction"),
   UserAction: require("./types/UserAction"),
   SelectMenu: require("./types/SelectMenu"),
   Button: require("./types/Button"),
+  Locale: require("./types/Locale"),
 }
 
 async function getEventFilePaths() {
@@ -49,13 +53,43 @@ async function getInteractionFilePaths() {
   return VInteractionFiles;
 }
 
+async function getLocaleFilePaths() {
+  let localesPath = path.resolve("./locales");
+  await makeSureFolderExists(localesPath);
+  let VLocaleFiles = await readdirRecursive(localesPath);
+  VLocaleFiles = VLocaleFiles.filter(i => {
+    let state = path.basename(i).startsWith("-");
+    return !state;
+  });
+  return VLocaleFiles;
+}
+
 /** @type {{name:string,listener:()=>any,base:any}[]} */
 let eventListeners = [];
 
 async function load() {
   let loadStart = Date.now();
   console.debug(`[HATA AYIKLAMA] Yüklemeye başlandı!`);
 
+  localeFiles = await getLocaleFilePaths();
+  await chillout.forEach(localeFiles, (localeFile) => {
+    let start = Date.now();
+    let rltPath = path.relative(__dirname, localeFile);
+    console.info(`[BİLGİ] "${rltPath}" konumundaki dil yükleniyor..`)
+    /** @type {import("./types/Locale")} */
+    let locale = require(localeFile);
+
+    if (locale._type != "locale")
+      return console.warn(`[UYARI] "${rltPath}" dil dosyası boş. Atlanıyor..`);
+
+    if (locales.has(locale.locale))
+      return console.warn(`[UYARI] ${locale.locale} dili zaten yüklenmiş. Atlanıyor..`);
+    
+    locales.set(locale.locale, locale);
+    console.info(`[BİLGİ] "${locale.locale}" dili yüklendi. (${Date.now() - start}ms sürdü.)`);
+  })
+
+
   interactionFiles = await getInteractionFilePaths();
   await chillout.forEach(interactionFiles, (interactionFile) => {
     let start = Date.now();
@@ -248,7 +282,10 @@ async function unload() {
     el.base.off(el.name, el.listener);
   })
 
-  let pathsToUnload = [...interactionFiles, ...eventFiles];
+  console.info(`[BILGI] Dil listesi temizleniyor..`);
+  Underline.locales.clear();
+
+  let pathsToUnload = [...interactionFiles, ...eventFiles, ...localeFiles];
 
   await chillout.forEach(pathsToUnload, async (pathToUnload) => {
     console.info(`[BILGI] Modül "${path.relative(__dirname, pathToUnload)}" önbellekten kaldırılıyor!`);
@@ -259,7 +296,7 @@ async function unload() {
 
   unloadStart = 0;
   pathsToUnload = 0;
-
+  
 }
 
 async function reload() {
@@ -302,9 +339,15 @@ client.on("interactionCreate", async (interaction) => {
 
   let other = {};
 
-  let shouldRun1 = await config.onInteractionBeforeChecks(uInter, interaction, other);
+  {
+    let locale_id = (interaction.user.locale || interaction.locale)?.split("-")[0];
+    other.locale = (Underline.locales.get(locale_id) || Underline.locales.get(Underline.config.defaultLanguage)).data;
+  }
 
-  if (!shouldRun1) return;
+  {
+    let shouldRun1 = await config.onInteractionBeforeChecks(uInter, interaction, other);
+    if (!shouldRun1) return;
+  }
 
   if (uInter.disabled) {
     config.userErrors.disabled(interaction, uInter, other);
@@ -389,10 +432,18 @@ client.on("interactionCreate", async (interaction) => {
   }
 
   (async () => {
-    let shouldRun2 = await config.onInteraction(uInter, interaction, other);
-    if (!shouldRun2) return;
+
+    {
+      let shouldRun2 = await config.onInteraction(uInter, interaction, other);
+      if (!shouldRun2) return;
+    }
+
     try {
+
       await uInter.onInteraction(interaction, other);
+
+      await config.onAfterInteraction(uInter, interaction, other);
+
     } catch (err) {
       console.error(`[HATA] "${uInter.actionType == "CHAT_INPUT" ? `/${uInter.name.join(" ")}` : `${uInter.name[0]}`}" adlı interaksiyon çalıştırılırken bir hata ile karşılaşıldı!`)
       if (err.message) console.error(`[HATA] ${err.message}`);

interactions/profil.js

@@ -15,7 +15,7 @@ module.exports = new Underline.SlashCommand({
         thumbnail: {
           url: member.user.displayAvatarURL({ dynamic: true })
         },
-        description: `**Açıldığı Tarih:** <t:${Math.floor(member.user.createdTimestamp / 1000)}:F>\n**Katıldığı Tarih:** <t:${Math.floor(member.joinedTimestamp / 1000)}:F>\n**ID:** \`${member.user.id}\``,
+        description: `**Açıldığı Tarih:** <t:${Math.floor(member.user.createdTimestamp / 1000)}:F>\n**Katıldığı Tarih:** <t:${Math.floor(member.joinedTimestamp / 1000)}:F>\n**ID:** \`${member.user.id}\`**Dil:** ${member.user.locale}`,
         createdAt: Date.now(),
         footer: {
           icon_url: interaction.user.displayAvatarURL({ dynamic: true }),

interactions/publish-interactions/clear.js

@@ -0,0 +1,50 @@
+const { Util } = require("discord.js");
+const util = require("util");
+const stuffs = require("stuffs")
+module.exports = new Underline.SlashCommand({
+  name: ["interactions", "guild", "clear"],
+  description: "Bot yetkilileri için publish komutu.",
+  async onInteraction(inter, other) {
+    await inter.deferReply();
+    
+    let guildID = inter.options.getString("guild");
+
+    let guild = inter.client.guilds.cache.get(guildID);
+
+    if (!guild) return inter.editReply("Malesef aradığınız sunucu bulunamadı...")
+
+    let logged = await stuffs.execAsync(`node publishInteractions guild ${guildID} clear`);
+    if(logged.stdout.includes("İnteraksiyonlar paylaşıldı!")) {
+      await inter.editReply(other.locale.example.success());
+    } else {
+
+      inter.editReply(other.locale.example.error(guild.name))
+      console.log("İnteraksyion paylaşma hatası")
+      // console.log(logged.stdout);
+      console.error(logged.stderr);
+
+    }
+
+  },
+  coolDown: {
+    type: "any",
+    amount: 180000
+  },
+  perms: {
+    user: ["DEVELOPER"]
+  },
+  options: [
+    {
+      name: "guild",
+      type: "STRING",
+      description: "Paylaşılacak sunucu sec",
+      required: true,
+      autocomplete: true,
+      async onComplete(inter, value) {
+        let guilds = await Underline.client.guilds.cache.map(g => ({name: g.name, value: g.id})).filter(x => !value || x.name.includes(value) || x.id === value);
+        return guilds.slice(0, 24)
+      }
+    }
+  ],
+  publishType: "guildOnly"
+})

interactions/publish-interactions/publish.js

@@ -0,0 +1,59 @@
+const { Util } = require("discord.js");
+const util = require("util");
+const stuffs = require("stuffs")
+module.exports = new Underline.SlashCommand({
+  name: ["interactions", "guild", "publish"],
+  description: "Bot yetkilileri için publish komutu.",
+  async onInteraction(inter, other) {
+    await inter.deferReply();
+    
+    let guildID = inter.options.getString("guild");
+
+    let guild = inter.client.guilds.cache.get(guildID);
+
+    let type = inter.options.getString("publish_type") || "guildOnly"
+
+    if (!guild) return inter.editReply("Malesef aradığınız sunucu bulunamadı...")
+
+    let logged = await stuffs.execAsync(`node publishInteractions guild ${guildID} ${type}`);
+    if(logged.stdout.includes("İnteraksiyonlar paylaşıldı!")) {
+      await inter.editReply(other.locale.example.success());
+    } else {
+
+      inter.editReply(other.locale.example.error(guild.name))
+      console.log("İnteraksyion paylaşma hatası")
+      // console.log(logged.stdout);
+      console.error(logged.stderr);
+
+    }
+
+  },
+  coolDown: {
+    type: "any",
+    amount: 180000
+  },
+  perms: {
+    user: ["DEVELOPER"]
+  },
+  options: [
+    {
+      name: "guild",
+      type: "STRING",
+      description: "Paylaşılacak sunucu sec",
+      required: true,
+      autocomplete: true,
+      async onComplete(inter, value) {
+        let guilds = await Underline.client.guilds.cache.map(g => ({name: g.name, value: g.id})).filter(x => !value || x.name.includes(value) || x.id === value);
+        console.log(guilds)
+        return guilds.slice(0, 24)
+      }
+    },
+    {
+      name: "publish_type",
+      type: "STRING",
+      description: "Paylaşılma tipi",
+      required: false,
+    }
+  ],
+  publishType: "guildOnly"
+})

locales/Turkish.js

@@ -0,0 +1,25 @@
+module.exports = new Underline.Locale({
+  locale: "tr",
+  data: {
+    userErrors: {
+      coolDown: {
+        user: `Bu interaksiyonu sen tekrardan {0} saniye içerisinde kullanabilirsin.`,
+        member: `Bu interaksiyonu sen bu sunucuda tekrardan {0} saniye içerisinde kullanabilirsin.`,
+        guild: `Bu interaksiyonu bu sunucuda tekrardan {0} saniye içerisinde kullanabilirsin.`,
+        channel: `Bu interaksiyonu bu kanalda tekrardan {0} saniye içerisinde kullanabilirsin.`,
+        message: `Bu interaksiyonu bu mesajda tekrardan {0} saniye içerisinde kullanabilirsin.`,
+        any: `Bu interaksiyonu tekrardan {0} saniye içerisinde kullanabilirsin.`,
+      },
+      disabled: "Bu interkasiyon kapalı",
+      blocked: "Bottan yasaklısınız.",
+      developerOnly: "Bu interaksiyon sadece bot geliştiricilerine özel",
+      guildOwnerOnly: "Bu interaksiyon sadece sunucu sahipleri kullanabilir",
+      botPermsRequired: "Botun bu komutu kullanması için {0} yetkilerine ihtiyacı vardır.",
+      userPermsRequired: "Bu komutu kullanmak için {0} yetkilerine ihtiyacın var.",
+    },
+    example: {
+      success: "✔ Yeniden yükleme işlemi başarılı.",
+      error: "Malesef {0} sunucusunda paylaşılamadı..."
+    }
+  }
+});