djs-builder 0.7.0 → 0.7.1-8.1

package/function/level.js

@@ -1,5 +1,6 @@
 const { Schema, model } = require("mongoose");
 
+////////////////////////////////! � User Level Schema
 const levelSchema = new Schema({
   userId: String,
   guildId: String,
@@ -7,15 +8,188 @@ const levelSchema = new Schema({
   voice: { type: Number, default: 0 },
   totalXP: { type: Number, default: 0 },
   level: { type: Number, default: 0 },
+  lastMessageTimestamp: { type: Date, default: null },
+});
+
+////////////////////////////////! ⚙️ Leveling Sub-Schema
+const levelingSchema = new Schema({
+  type: { type: String, default: "line" },
+  amount: { type: Number, default: 100 },
+  a: { type: Number, default: 5 },
+  b: { type: Number, default: 50 },
+  c: { type: Number, default: 100 },
+  customLevels: { type: Object, default: {} },
+}, { _id: false });
+
+////////////////////////////////! ⚙️ Guild Config Schema
+const guildSchema = new Schema({
+  guildId: { type: String, required: true, unique: true },
+  initialized: { type: Boolean, default: false },
+
+  minXP: { type: Number, default: 3 },
+  maxXP: { type: Number, default: 8 },
+  xpMultiplier: { type: Number, default: 1 },
+  maxLevel: { type: Number, default: null },
+  cooldown: { type: Number, default: 0 }, 
+  roleReward: { type: Object, default: {} },
+  blacklistedChannels: { type: Array, default: [] },
+  disabled: { type: Boolean, default: false },
+  leveling: { type: levelingSchema, default: () => ({ type: "line", amount: 100, a: 5, b: 50, c: 100, customLevels: {} }) },
+
 });
 
 const Level = model("Level", levelSchema);
+const levelGuild = model("levelGuild", guildSchema);
+
+////////////////////////////////! 🗃️ Cache System
+const configCache = new Map();
+
+function clearConfigCache(guildId) {
+  if (guildId) {
+    configCache.delete(guildId);
+  } else {
+    configCache.clear();
+  }
+}
+
+async function getCachedConfig(guildId) {
+  if (configCache.has(guildId)) {
+    return configCache.get(guildId);
+  }
+  const config = await levelGuild.findOne({ guildId });
+  if (config) configCache.set(guildId, config);
+  return config;
+}
+
+////////////////////////////////! 🧮 Calculate XP needed for level
+function xpNeeded(level, config = {}) {
+  const leveling = config.leveling || { type: "line", amount: 100 };
+  const type = leveling.type || "line";
+
+  if (leveling.customLevels && leveling.customLevels[level]) {
+    return leveling.customLevels[level];
+  }
+
+  switch (type) {
+    case "exponential":
+      return Math.floor(leveling.amount * Math.pow(2, level));
+    case "balanced":
+      const a = leveling.a || 5;
+      const b = leveling.b || 50;
+      const c = leveling.c || 100;
+      return Math.floor(a * Math.pow(level, 2) + b * level + c);
+    case "custom":
+      return leveling.customLevels?.[level] || level * 1000;
+    case "line":
+    default:
+      return (level + 1) * (leveling.amount || 100);
+  }
+}
+
+function calculateLevel(totalXP, config = {}) {
+  let level = 0;
+  const maxLevel = config.maxLevel || null;
+  
+  while (totalXP >= xpNeeded(level, config)) {
+    level++;
+    if (maxLevel && level >= maxLevel) {
+      return maxLevel;
+    }
+  }
+  return level;
+}
 
 function randomXP(min, max) {
   return Math.floor(Math.random() * (max - min + 1)) + min;
 }
 
+////////////////////////////////* 🎮 Main setLevel Function
+
+async function setLevel(client, guilds, callbacks = {}) {
+  client.levelGuilds = new Set(guilds.map(g => g.id));
+  client.levelDashboardGuilds = new Set(guilds.filter(g => g.Dashboard === true).map(g => g.id));
+
+  for (const guild of guilds) {
+    const trueGuild = client.guilds.cache.get(guild.id);
+    if (!trueGuild) continue;
+  
+    const existingConfig = await levelGuild.findOne({ guildId: guild.id });
+    
+    const { id, Dashboard, ...guildConfig } = guild;
+    
+    if (!existingConfig) {
+      const newConfig = new levelGuild({ guildId: id, initialized: true, ...guildConfig });
+      await newConfig.save();
+      configCache.set(id, newConfig);
+    } else {
+      if (guild.Dashboard) {
+        await levelGuild.findOneAndUpdate(
+          { guildId: id }, 
+          { initialized: true }, 
+          { new: true }
+        );
+      } else {
+        await levelGuild.findOneAndDelete({ guildId: id });
+        const newConfig = new levelGuild({ guildId: id, initialized: true, ...guildConfig });
+        await newConfig.save();
+      }
+      clearConfigCache(id);
+    }
+  }
+
+  client.on("messageCreate", async (msg) => {
+    if (msg.author.bot || !msg.guild) return;
+    
+
+    if (!client.levelGuilds || !client.levelGuilds.has(msg.guild.id)) return;
+    
+    const guildConfig = await getCachedConfig(msg.guild.id);
+    if (!guildConfig) return;
+
+    const guildOptions = guilds.find(g => g.id === msg.guild.id) || {};
+
+    const result = await addXP(msg.author.id, msg.guild.id, {
+      ...guildOptions,
+      channelId: msg.channel.id,
+      member: msg.member,
+      xpType: "text",
+    });
+
+    if (result.disabled || result.blacklisted || result.onCooldown) return;
+
+    if (callbacks.onXP) {
+      try { await callbacks.onXP(msg, result); } catch (e) { console.error("setLevel onXP error:", e); }
+    }
+
+    if (result.leveledUp && callbacks.onLevelUp) {
+      try { await callbacks.onLevelUp(msg, result); } catch (e) { console.error("setLevel onLevelUp error:", e); }
+    }
+
+    if (result.newRole?.length > 0 && callbacks.onRoleReward) {
+      for (const role of result.newRole) {
+        try { await callbacks.onRoleReward(msg, result, role); } catch (e) { console.error("setLevel onRoleReward error:", e); }
+      }
+    }
+  });
+
+
+}
+
+////////////////////////////////! 🎮 Main addXP Function
+
+
 async function addXP(userId, guildId, options = {}) {
+  ////////////////////////////////! 🗃️ Get config from Dashboard or options
+  let config = options.Dashboard 
+    ? await getCachedConfig(guildId) || {}
+    : options;
+
+
+  ////////////////////////////////! ❌ Check if disabled
+  if (config.disabled) {
+    return { disabled: true, newLevel: 0, oldLevel: 0, totalXP: 0, leveledUp: false };
+  }
+
   let data = await Level.findOne({ userId, guildId });
   if (!data) {
     data = new Level({ userId, guildId });
@@ -23,12 +197,50 @@ async function addXP(userId, guildId, options = {}) {
 
   const oldLevel = data.level || 0;
   let leveledUp = false;
+  let roleRewardAdded = false;
+  let newRole = [];
+
+  ////////////////////////////////! 🚫 Blacklist check
+  if (options.channelId && config.blacklistedChannels?.includes(options.channelId)) {
+    return {
+      newLevel: data.level,
+      oldLevel,
+      totalXP: data.totalXP,
+      leveledUp: false,
+      blacklisted: true,
+    };
+  }
+
+
+  ////////////////////////////////! ⏱️ Cooldown check
+  const cooldownDuration = config.cooldown ?? options.cooldown ?? 0;
+  
+  if (cooldownDuration > 0) {
+    const now = new Date();
+    if (data.lastMessageTimestamp) {
+      const timeDiff = (now - data.lastMessageTimestamp) / 1000;
+      if (timeDiff < cooldownDuration) {
+        return {
+          newLevel: data.level,
+          oldLevel,
+          totalXP: data.totalXP,
+          leveledUp: false,
+          onCooldown: true,
+          remainingCooldown: Math.ceil(cooldownDuration - timeDiff),
+        };
+      }
+    }
+    data.lastMessageTimestamp = now;
+  }
 
   ////////////////////////////////! 🎲 XP
-  const xpToAdd =
-    options.amount_add ?? randomXP(options.minXP || 5, options.maxXP || 12);
+  let xpToAdd =
+    options.amount_add ??
+    randomXP(config.minXP || 5, config.maxXP || 12);
+  
+  xpToAdd = Math.floor(xpToAdd * (config.xpMultiplier || 1));
 
-  data[options.type || "text"] += xpToAdd;
+  data[options.xpType || "text"] += xpToAdd;
   data.totalXP += xpToAdd;
 
   ////////////////////////////////! 🎯 Level boost
@@ -37,24 +249,70 @@ async function addXP(userId, guildId, options = {}) {
     leveledUp = true;
   }
 
-  ////////////////////////////////! check level ✅
-  const needed = (data.level + 1) * 100;
-  if (data.totalXP >= needed) {
-    data.level++;
+  ////////////////////////////////! 🔋 xp boost
+  if (options.totalXP_add) {
+    data.totalXP += options.totalXP_add;
+  }
+
+  if (options.text_add) {
+    data.text += options.text_add;
+  }
+
+  if (options.voice_add) {
+    data.voice += options.voice_add;
+  }
+
+  ////////////////////////////////! ✅ Calculate correct level
+  const newCalculatedLevel = calculateLevel(data.totalXP, config);
+  
+  if (newCalculatedLevel > data.level) {
+    if (config.roleReward) {
+      const rewardLevels = Object.keys(config.roleReward)
+        .map(Number)
+        .filter(lvl => lvl === newCalculatedLevel)
+        .sort((a, b) => b - a); 
+      
+      if (rewardLevels.length > 0) {
+        const highestRewardLevel = rewardLevels[0];
+        newRole.push({
+          level: highestRewardLevel,
+          roleId: config.roleReward[highestRewardLevel]
+        });
+      }
+    }
+    data.level = newCalculatedLevel;
     leveledUp = true;
   }
 
   await data.save();
 
+  ////////////////////////////////! 🎖️ Auto add roles
+  if (options.member && newRole.length > 0) {
+    for (const role of newRole) {
+      try {
+        await options.member.roles.add(role.roleId);
+        roleRewardAdded = true;
+      } catch (err) {
+        roleRewardAdded = "Failed to add role: " + err.message;
+      }
+    }
+  }
+
   return {
     newLevel: data.level,
     oldLevel,
     totalXP: data.totalXP,
     leveledUp,
+    xpAdded: xpToAdd,
+    xpForNextLevel: xpNeeded(data.level, config),
+    remainingXP: xpNeeded(data.level, config) - data.totalXP,
+    roleRewardAdded,
+    newRole,
+    multiplierUsed: config.xpMultiplier || 1,
   };
 }
 
-////////////////////////////////! user data 🧑‍🤝‍🧑
+////////////////////////////////! 🧑‍🤝‍🧑 User data
 async function UserLevel(userId, guildId) {
   return (
     (await Level.findOne({ userId, guildId })) || {
@@ -66,11 +324,80 @@ async function UserLevel(userId, guildId) {
   );
 }
 
-////////////////////////////////! 🏆 top
+////////////////////////////////! 🏆 Leaderboard
 async function leaderboard(guildId, type = "totalXP", limit = 10) {
   return await Level.find({ guildId })
     .sort({ [type]: -1 })
     .limit(limit);
 }
 
-module.exports = { Level,addXP, UserLevel, leaderboard };
+////////////////////////////////! 🏅 Get user rank
+async function getUserRank(userId, guildId, type = "totalXP") {
+  const allUsers = await Level.find({ guildId }).sort({ [type]: -1 });
+  const rank = allUsers.findIndex(u => u.userId === userId) + 1;
+  return rank || null;
+}
+
+
+////////////////////////////////! 🗑️ Delete user data
+async function resetUser(userId, guildId) {
+  return await Level.findOneAndDelete({ userId, guildId });
+}
+
+////////////////////////////////! 🔥 Reset all users in a guild
+async function resetGuild(guildId) {
+  return await Level.deleteMany({ guildId });
+}
+
+////////////////////////////////! 📋 Get level info
+function getLevelInfo(level, config = {}) {
+  return {
+    level,
+    xpNeeded: xpNeeded(level, config),
+    xpForNext: xpNeeded(level + 1, config),
+    xpDifference: xpNeeded(level + 1, config) - xpNeeded(level, config),
+  };
+}
+
+////////////////////////////////! ⚙️ Get Guild Config
+async function getGuildConfig(guildId) {
+  return await getCachedConfig(guildId);
+}
+
+////////////////////////////////! ✏️ Update Guild Config
+async function updateGuildConfig(guildId, updates) {
+  const result = await levelGuild.findOneAndUpdate(
+    { guildId },
+    { guildId, ...updates },
+    { upsert: true, new: true }
+  );
+  
+  clearConfigCache(guildId);
+  return result;
+}
+
+////////////////////////////////! 🗑️ Delete Guild Config
+async function deleteGuildConfig(guildId) {
+  const result = await levelGuild.findOneAndDelete({ guildId });
+  clearConfigCache(guildId);
+  return result;
+}
+
+module.exports = { 
+  Level, 
+  levelGuild, 
+  addXP, 
+  UserLevel, 
+  leaderboard,
+  getUserRank,
+  resetUser,
+  resetGuild,
+  xpNeeded,
+  calculateLevel,
+  getLevelInfo,
+  getGuildConfig,
+  updateGuildConfig,
+  deleteGuildConfig,
+  clearConfigCache,
+  setLevel
+};