djs-builder 0.7.0 → 0.7.1-8.1

package/function/dash.js

@@ -1,68 +1,59 @@
-/**
- * DJS-Builder Dashboard
- * لوحة تحكم عصرية وخفيفة متوافقة مع حزمة djs-builder
- * @version 2.0.0
- * @author DJS-Builder Team
- */
+
 
 const express = require("express");
 const session = require("express-session");
 const passport = require("passport");
 const DiscordStrategy = require("passport-discord").Strategy;
 const path = require("path");
+const Table = require("cli-table3");
+const chalk = require("chalk");
+const mongoose = require("mongoose");
+
+const { 
+  Level, 
+  levelGuild,
+  resetUser, 
+  xpNeeded, 
+  calculateLevel, 
+  getUserRank,
+  getGuildConfig,
+  updateGuildConfig,
+  deleteGuildConfig,
+  clearConfigCache,
+} = require("./level");
+const {
+  Blacklist,
+  addToBlacklist,
+  removeFromBlacklist,
+} = require("./blacklist");
+const {
+  giveaway,
+  Gcheck,
+  Greroll,
+  Gpause,
+  Gresume,
+  Gdelete,
+} = require("./giveaway");
+const { Log, getLogConfigData } = require("./log");
 
-// استيراد موديلات djs-builder
-let Level, giveaway, Blacklist, leaderboard, addXP, UserLevel;
-let Gstart, Gcheck, Greroll, Glist, Gpause, Gresume, Gdelete, Gdata;
-let isBlacklisted, addToBlacklist, removeFromBlacklist, getBlacklist;
-
-try {
-  const djsBuilder = require("djs-builder");
-  Level = djsBuilder.Level;
-  giveaway = djsBuilder.giveaway;
-  Blacklist = djsBuilder.Blacklist;
-  leaderboard = djsBuilder.leaderboard;
-  addXP = djsBuilder.addXP;
-  UserLevel = djsBuilder.UserLevel;
-  Gstart = djsBuilder.Gstart;
-  Gcheck = djsBuilder.Gcheck;
-  Greroll = djsBuilder.Greroll;
-  Glist = djsBuilder.Glist;
-  Gpause = djsBuilder.Gpause;
-  Gresume = djsBuilder.Gresume;
-  Gdelete = djsBuilder.Gdelete;
-  Gdata = djsBuilder.Gdata;
-  isBlacklisted = djsBuilder.isBlacklisted;
-  addToBlacklist = djsBuilder.addToBlacklist;
-  removeFromBlacklist = djsBuilder.removeFromBlacklist;
-  getBlacklist = djsBuilder.getBlacklist;
-} catch (e) {
-  console.log("⚠️ djs-builder models not fully loaded:", e.message);
-}
 
-/**
- * دالة لإنشاء وتشغيل لوحة التحكم
- * @param {Client} client - كائن البوت
- * @param {Object} options - خيارات اللوحة
- */
 function dashboard(client, options) {
   const app = express();
   const {
-    clientID,
     clientSecret,
-    callbackURL,
+    callbackURL = "http://localhost:3000/auth/discord/callback",
     sessionSecret,
     port = 3000,
   } = options;
 
-  // إعداد المسارات
+  clientID = client.user.id;
+
   app.set("view engine", "ejs");
-app.set("views", path.join(__dirname, "views"));
-  app.use(express.static(path.join(__dirname, "public")));
+  app.set("views", path.join(__dirname, "..", "views"));
   app.use(express.json());
   app.use(express.urlencoded({ extended: true }));
 
-  // إعداد الجلسات
+
   app.use(
     session({
       secret: sessionSecret,
@@ -74,7 +65,7 @@ app.set("views", path.join(__dirname, "views"));
     })
   );
 
-  // إعداد Passport
+
   app.use(passport.initialize());
   app.use(passport.session());
 
@@ -95,21 +86,22 @@ app.set("views", path.join(__dirname, "views"));
     )
   );
 
-  // Middleware للتحقق من تسجيل الدخول
+
   function isAuthenticated(req, res, next) {
     if (req.isAuthenticated()) return next();
     res.redirect("/login");
   }
 
-  // تمرير بيانات المستخدم والبوت لكل الصفحات
+ 
   app.use((req, res, next) => {
     res.locals.user = req.user || null;
     res.locals.client = client;
     res.locals.path = req.path;
+    res.locals.dashboardEnabled = options.Dashboard !== false; 
     next();
   });
 
-  // ==================== دالة مساعدة للإحصائيات ====================
+
   function getBotStats() {
     const uniquePrefixCommands = new Set();
     if (client.prefixCommands) {
@@ -118,12 +110,13 @@ app.set("views", path.join(__dirname, "views"));
       });
     }
 
-    // محاولة الحصول على البادئة من client
-    const prefix = client.prefix || options.prefix || '-';
+  
+    const prefix = client.prefix || options.prefix || "-";
 
     return {
       guilds: client.guilds?.cache?.size || 0,
-      users: client.guilds?.cache?.reduce((acc, g) => acc + g.memberCount, 0) || 0,
+      users:
+        client.guilds?.cache?.reduce((acc, g) => acc + g.memberCount, 0) || 0,
       channels: client.channels?.cache?.size || 0,
       slashCommands: client.slashCommands?.size || 0,
       prefixCommands: uniquePrefixCommands.size,
@@ -139,22 +132,20 @@ app.set("views", path.join(__dirname, "views"));
     };
   }
 
-  // ==================== المسارات الرئيسية ====================
 
-  // الصفحة الرئيسية
   app.get("/", (req, res) => {
     res.render("index", {
       botStats: getBotStats(),
     });
   });
 
-  // صفحة تسجيل الدخول
+
   app.get("/login", (req, res) => {
     if (req.isAuthenticated()) return res.redirect("/dashboard");
     res.render("login", { botStats: getBotStats() });
   });
 
-  // OAuth2 مع Discord
+  
   app.get("/auth/discord", passport.authenticate("discord"));
 
   app.get(
@@ -167,28 +158,25 @@ app.set("views", path.join(__dirname, "views"));
     }
   );
 
-  // تسجيل الخروج
+  
   app.get("/logout", (req, res) => {
     req.logout(() => {
       res.redirect("/");
     });
   });
 
-  // ==================== لوحة التحكم ====================
 
-  // لوحة التحكم الرئيسية
   app.get("/dashboard", isAuthenticated, (req, res) => {
     const userGuilds = req.user.guilds.filter(
-      (g) =>
-        (g.permissions & 0x20) === 0x20 && client.guilds.cache.has(g.id)
+      (g) => (g.permissions & 0x20) === 0x20 && client.guilds.cache.has(g.id)
     );
-    res.render("dashboard", { 
+    res.render("dashboard", {
       guilds: userGuilds,
-      botStats: getBotStats()
+      botStats: getBotStats(),
     });
   });
 
-  // إدارة سيرفر معين - نظرة عامة
+
   app.get("/dashboard/:guildId", isAuthenticated, async (req, res) => {
     const guild = client.guilds.cache.get(req.params.guildId);
     if (!guild) return res.redirect("/dashboard");
@@ -198,15 +186,20 @@ app.set("views", path.join(__dirname, "views"));
       return res.redirect("/dashboard");
     }
 
-    // جمع إحصائيات السيرفر
+
     let levelCount = 0;
     let giveawayCount = 0;
     let blacklistCount = 0;
 
     try {
       if (Level) levelCount = await Level.countDocuments({ guildId: guild.id });
-      if (giveaway) giveawayCount = await giveaway.countDocuments({ guildId: guild.id, ended: false });
-      if (Blacklist) blacklistCount = await Blacklist.countDocuments({ guild: guild.id });
+      if (giveaway)
+        giveawayCount = await giveaway.countDocuments({
+          guildId: guild.id,
+          ended: false,
+        });
+      if (Blacklist)
+        blacklistCount = await Blacklist.countDocuments({ guild: guild.id });
     } catch (e) {
       console.error("Stats error:", e);
     }
@@ -223,11 +216,11 @@ app.set("views", path.join(__dirname, "views"));
         activeGiveaways: giveawayCount,
         blacklisted: blacklistCount,
       },
-      botStats: getBotStats()
+      botStats: getBotStats(),
     });
   });
 
-  // ==================== صفحة الأوامر ====================
+
   app.get("/dashboard/:guildId/commands", isAuthenticated, async (req, res) => {
     const guild = client.guilds.cache.get(req.params.guildId);
     if (!guild) return res.redirect("/dashboard");
@@ -235,8 +228,8 @@ app.set("views", path.join(__dirname, "views"));
     const slashCommands = client.slashCommands
       ? Array.from(client.slashCommands.values())
       : [];
-    
-    // إزالة التكرارات من prefix commands
+
+  
     const uniquePrefixCommands = [];
     const seen = new Set();
     if (client.prefixCommands) {
@@ -253,35 +246,99 @@ app.set("views", path.join(__dirname, "views"));
       slashCommands,
       prefixCommands: uniquePrefixCommands,
       page: "commands",
-      botStats: getBotStats()
+      botStats: getBotStats(),
     });
   });
 
-  // ==================== نظام اللفل ====================
   app.get("/dashboard/:guildId/levels", isAuthenticated, async (req, res) => {
     const guild = client.guilds.cache.get(req.params.guildId);
     if (!guild) return res.redirect("/dashboard");
 
+    const mongoConnected = mongoose.connection.readyState === 1;
+    let levelConfigDb = null;
+    let configSource = null;
+    let databaseEnabled = false; 
+
+    const canModify = options.Dashboard !== false;
+
+
+    const usesDashboardMode = client.levelDashboardGuilds && client.levelDashboardGuilds.has(guild.id);
+
+
+    if (mongoConnected) {
+      try {
+        levelConfigDb = await getGuildConfig(guild.id);
+        if (levelConfigDb && usesDashboardMode) {
+          configSource = "database";
+          databaseEnabled = true;
+        }
+      } catch (e) {
+        console.error("Error fetching level config:", e);
+      }
+    }
+
     let leaderboardData = [];
     if (Level) {
       try {
-        leaderboardData = await Level.find({ guildId: guild.id })
+        const rawLeaderboard = await Level.find({ guildId: guild.id })
           .sort({ totalXP: -1 })
           .limit(100);
+          
+       
+        const memberIds = rawLeaderboard.map(u => u.userId);
+        const fetchedMembers = await guild.members.fetch({ user: memberIds }).catch(() => new Map());
+          
+        leaderboardData = rawLeaderboard.map(u => {
+          const member = fetchedMembers.get(u.userId) || guild.members.cache.get(u.userId);
+          return {
+            userId: u.userId,
+            totalXP: u.totalXP,
+            level: u.level,
+            username: member ? member.user.username : `User ${u.userId.substring(0, 5)}`,
+            avatar: member ? member.user.displayAvatarURL({ size: 64, forceStatic: true }) : `https://cdn.discordapp.com/embed/avatars/${Math.floor(Math.random() * 6)}.png`,
+          };
+        });
       } catch (e) {
         console.error("Error fetching levels:", e);
       }
     }
 
+    
+    const roles = guild.roles.cache
+      .filter((r) => r.id !== guild.id && !r.managed)
+      .map((r) => ({ id: r.id, name: r.name, color: r.hexColor }))
+      .sort((a, b) => a.name.localeCompare(b.name));
+
+    
+    const channels = guild.channels.cache
+      .filter((c) => c.type === 0)
+      .map((c) => ({ id: c.id, name: c.name }))
+      .sort((a, b) => a.name.localeCompare(b.name));
+
     res.render("levels", {
       guild,
       leaderboard: leaderboardData,
       page: "levels",
-      botStats: getBotStats()
+      botStats: getBotStats(),
+      databaseEnabled,
+      mongoConnected,
+      configSource,
+      levelConfigDb,
+      roles,
+      channels,
+      canModify,
     });
   });
 
-  // API للحصول على بيانات مستخدم
+
+  function canModifySettings(req, res, next) {
+    if (options.Dashboard === false) {
+      return res.status(403).json({ success: false, error: "تم تعطيل التعديل من الداش بورد في ملف الإعدادات الرئيسي للبوت." });
+    }
+    next();
+  }
+
+  
   app.get("/api/:guildId/user/:userId", isAuthenticated, async (req, res) => {
     if (!Level) return res.json({ error: "Level system not available" });
 
@@ -296,122 +353,380 @@ app.set("views", path.join(__dirname, "views"));
     }
   });
 
-  // ==================== نظام الجيف اوي ====================
-  app.get("/dashboard/:guildId/giveaways", isAuthenticated, async (req, res) => {
+ 
+  app.get(
+    "/dashboard/:guildId/giveaways",
+    isAuthenticated,
+    async (req, res) => {
+      const guild = client.guilds.cache.get(req.params.guildId);
+      if (!guild) return res.redirect("/dashboard");
+
+      let giveaways = [];
+      if (giveaway) {
+        try {
+          giveaways = await giveaway
+            .find({ guildId: guild.id })
+            .sort({ endTime: -1 });
+        } catch (e) {
+          console.error("Error fetching giveaways:", e);
+        }
+      }
+
+      res.render("giveaways", {
+        guild,
+        giveaways,
+        page: "giveaways",
+        botStats: getBotStats(),
+      });
+    }
+  );
+
+  
+  app.post(
+    "/api/:guildId/giveaway/:action",
+    isAuthenticated,
+    async (req, res) => {
+      const { guildId, action } = req.params;
+      const { messageId } = req.body;
+
+      try {
+        let result = { success: true };
+        switch (action) {
+          case "pause":
+            if (Gpause) await Gpause(client, messageId);
+            break;
+          case "resume":
+           
+            if (Gresume) await Gresume(client, messageId);
+            break;
+          case "end":
+           
+            if (giveaway) {
+              const g = await giveaway.findOne({ messageId });
+              if (g && !g.ended) {
+               
+                await giveaway.findOneAndUpdate(
+                  { messageId },
+                  { paused: false, endTime: Date.now().toString() }
+                );
+             
+                setTimeout(() => Gcheck && Gcheck(client), 1000);
+              }
+            }
+            break;
+          case "reroll":
+            if (Greroll) await Greroll(client, messageId);
+            break;
+          case "delete":
+            if (Gdelete) await Gdelete(messageId);
+            break;
+          default:
+            return res.json({ success: false, error: "Invalid action" });
+        }
+        res.json({ success: true, message: `تم تنفيذ ${action} بنجاح` });
+      } catch (e) {
+        console.error("Giveaway action error:", e);
+        res.json({ success: false, error: e.message });
+      }
+    }
+  );
+
+
+  const LOG_EVENT_TYPES = [
+    { name: "حذف رسالة", value: "messageDelete", icon: "ri-delete-bin-line" },
+    { name: "تعديل رسالة", value: "messageUpdate", icon: "ri-edit-line" },
+    { name: "إنشاء قناة", value: "channelCreate", icon: "ri-add-circle-line" },
+    { name: "حذف قناة", value: "channelDelete", icon: "ri-close-circle-line" },
+    { name: "تعديل قناة", value: "channelUpdate", icon: "ri-settings-3-line" },
+    { name: "انضمام عضو", value: "guildMemberAdd", icon: "ri-user-add-line" },
+    {
+      name: "مغادرة عضو",
+      value: "guildMemberRemove",
+      icon: "ri-user-unfollow-line",
+    },
+    { name: "حظر عضو", value: "guildBanAdd", icon: "ri-forbid-line" },
+    {
+      name: "رفع الحظر",
+      value: "guildBanRemove",
+      icon: "ri-checkbox-circle-line",
+    },
+    { name: "إنشاء رتبة", value: "roleCreate", icon: "ri-shield-star-line" },
+    { name: "حذف رتبة", value: "roleDelete", icon: "ri-shield-cross-line" },
+    { name: "تعديل رتبة", value: "roleUpdate", icon: "ri-shield-line" },
+    {
+      name: "تغيير رتب العضو",
+      value: "guildMemberUpdate",
+      icon: "ri-user-settings-line",
+    },
+    { name: "نشاط صوتي", value: "voiceStateUpdate", icon: "ri-mic-line" },
+    { name: "إنشاء دعوة", value: "inviteCreate", icon: "ri-links-line" },
+    {
+      name: "إضافة إيموجي",
+      value: "emojiCreate",
+      icon: "ri-emotion-happy-line",
+    },
+    {
+      name: "حذف إيموجي",
+      value: "emojiDelete",
+      icon: "ri-emotion-unhappy-line",
+    },
+    { name: "تعديل إيموجي", value: "emojiUpdate", icon: "ri-emotion-line" },
+    {
+      name: "إضافة ستيكر",
+      value: "stickerCreate",
+      icon: "ri-sticky-note-line",
+    },
+    {
+      name: "حذف ستيكر",
+      value: "stickerDelete",
+      icon: "ri-sticky-note-2-line",
+    },
+    { name: "تعديل ستيكر", value: "stickerUpdate", icon: "ri-file-edit-line" },
+  ];
+
+
+  app.get("/dashboard/:guildId/logs", isAuthenticated, async (req, res) => {
     const guild = client.guilds.cache.get(req.params.guildId);
     if (!guild) return res.redirect("/dashboard");
 
-    let giveaways = [];
-    if (giveaway) {
+    const userGuild = req.user.guilds.find((g) => g.id === req.params.guildId);
+    if (!userGuild || (userGuild.permissions & 0x20) !== 0x20) {
+      return res.redirect("/dashboard");
+    }
+
+
+    const logData = getLogConfigData();
+    const databaseEnabled = logData.databaseEnabled;
+    let logConfig = null;
+    let configSource = null; 
+
+    if (databaseEnabled) {
+    
       try {
-        giveaways = await giveaway.find({ guildId: guild.id }).sort({ endTime: -1 });
+        logConfig = await Log.findOne({ guildId: guild.id });
+        if (logConfig) configSource = "database";
       } catch (e) {
-        console.error("Error fetching giveaways:", e);
+        console.error("Error fetching log config:", e);
+      }
+    } else {
+    
+      const codeConfig = logData.configs.find((c) => c.guildId === guild.id);
+      if (codeConfig) {
+        logConfig = codeConfig;
+        configSource = "code";
       }
     }
 
-    res.render("giveaways", {
+
+    const channels = guild.channels.cache
+      .filter((c) => c.type === 0) 
+      .map((c) => ({ id: c.id, name: c.name }))
+      .sort((a, b) => a.name.localeCompare(b.name));
+
+
+    const disabledEvents = logConfig?.disable?.length || 0;
+    const enabledEvents = LOG_EVENT_TYPES.length - disabledEvents;
+    const customColors = logConfig?.colors
+      ? Object.keys(logConfig.colors).length
+      : 0;
+    const customChannels = logConfig?.channels
+      ? Object.keys(logConfig.channels).length
+      : 0;
+
+    res.render("logs", {
       guild,
-      giveaways,
-      page: "giveaways",
-      botStats: getBotStats()
+      page: "logs",
+      botStats: getBotStats(),
+      databaseEnabled,
+      configSource,
+      logConfig,
+      channels,
+      eventTypes: LOG_EVENT_TYPES,
+      enabledEvents,
+      disabledEvents,
+      customColors,
+      customChannels,
     });
   });
 
-  // API للجيف اوي
-  app.post("/api/:guildId/giveaway/:action", isAuthenticated, async (req, res) => {
-    const { guildId, action } = req.params;
-    const { messageId } = req.body;
+
+  app.post("/api/:guildId/logs/channel", isAuthenticated, canModifySettings, async (req, res) => {
+    const logData = getLogConfigData();
+    if (!logData.databaseEnabled)
+      return res.json({ error: "يجب تفعيل وضع Database لتعديل الإعدادات" });
+
+    const { channelId } = req.body;
+    const guildId = req.params.guildId;
 
     try {
-      let result = { success: true };
-      switch (action) {
-        case "pause":
-          if (Gpause) await Gpause(client, messageId);
-          break;
-        case "resume":
-          // تنفيذ يدوي للاستئناف لأن Gresume في djs-builder يحتوي على خطأ
-         if (Gresume) await Gresume(client, messageId);
-          break;
-        case "end":
-          // إنهاء الجيف اوي فوراً بتعديل وقت الانتهاء للوقت الحالي
-          if (giveaway) {
-            const g = await giveaway.findOne({ messageId });
-            if (g && !g.ended) {
-              // إذا كان متوقفاً مؤقتاً، نلغي الإيقاف أولاً
-              await giveaway.findOneAndUpdate(
-                { messageId },
-                { paused: false, endTime: Date.now().toString() }
-              );
-              // إعطاء Gcheck فرصة للتشغيل
-              setTimeout(() => Gcheck && Gcheck(client), 1000);
-            }
-          }
-          break;
-        case "reroll":
-          if (Greroll) await Greroll(client, messageId);
-          break;
-        case "delete":
-          if (Gdelete) await Gdelete(messageId);
-          break;
-        default:
-          return res.json({ success: false, error: "Invalid action" });
-      }
-      res.json({ success: true, message: `تم تنفيذ ${action} بنجاح` });
+      await Log.findOneAndUpdate(
+        { guildId },
+        { guildId, channelId },
+        { upsert: true, new: true }
+      );
+ 
+      if (logData.clearCache) logData.clearCache(guildId);
+      res.json({ success: true });
     } catch (e) {
-      console.error("Giveaway action error:", e);
       res.json({ success: false, error: e.message });
     }
   });
 
-  // ==================== نظام البلاك ليست ====================
-  // API لإضافة للبلاك ليست
-  app.post("/api/guild/:guildId/blacklist", isAuthenticated, async (req, res) => {
-    const { type, id } = req.body;
+
+  app.post("/api/:guildId/logs/toggle", isAuthenticated, canModifySettings, async (req, res) => {
+    const logData = getLogConfigData();
+    if (!logData.databaseEnabled)
+      return res.json({ error: "يجب تفعيل وضع Database لتعديل الإعدادات" });
+
+    const { eventType, enable } = req.body;
     const guildId = req.params.guildId;
 
     try {
-      if (addToBlacklist) {
-        const result = await addToBlacklist(guildId, type, id);
-        return res.json({ success: result });
-      } else if (Blacklist) {
-        const exists = await Blacklist.findOne({ guild: guildId, type, id });
-        if (!exists) {
-          await Blacklist.create({ guild: guildId, type, id });
-        }
-        return res.json({ success: true });
+      if (enable) {
+      
+        await Log.findOneAndUpdate(
+          { guildId },
+          { $pull: { disable: eventType } },
+          { upsert: true }
+        );
+      } else {
+        
+        await Log.findOneAndUpdate(
+          { guildId },
+          { $addToSet: { disable: eventType } },
+          { upsert: true }
+        );
       }
-      res.json({ error: "Blacklist system not available" });
+      
+      const logData = getLogConfigData();
+      if (logData.clearCache) logData.clearCache(guildId);
+      res.json({ success: true });
     } catch (e) {
       res.json({ success: false, error: e.message });
     }
   });
 
-  // API لحذف من البلاك ليست
-  app.delete("/api/guild/:guildId/blacklist", isAuthenticated, async (req, res) => {
-    const { type, id } = req.body;
+ 
+  app.post("/api/:guildId/logs/event", isAuthenticated, canModifySettings, async (req, res) => {
+    const logData = getLogConfigData();
+    if (!logData.databaseEnabled)
+      return res.json({ error: "يجب تفعيل وضع Database لتعديل الإعدادات" });
+
+    const { eventType, channel, color } = req.body;
     const guildId = req.params.guildId;
 
     try {
-      if (removeFromBlacklist) {
-        const result = await removeFromBlacklist(guildId, type, id);
-        return res.json({ success: result });
-      } else if (Blacklist) {
-        await Blacklist.deleteOne({ guild: guildId, type, id });
-        return res.json({ success: true });
+      const updateObj = {};
+
+      if (channel) {
+        updateObj[`channels.${eventType}`] = channel;
+      } else {
+       
+        await Log.findOneAndUpdate(
+          { guildId },
+          { $unset: { [`channels.${eventType}`]: "" } }
+        );
       }
-      res.json({ error: "Blacklist system not available" });
+
+      if (color) {
+        updateObj[`colors.${eventType}`] = color;
+      } else {
+      
+        await Log.findOneAndUpdate(
+          { guildId },
+          { $unset: { [`colors.${eventType}`]: "" } }
+        );
+      }
+
+      if (Object.keys(updateObj).length > 0) {
+        await Log.findOneAndUpdate(
+          { guildId },
+          { $set: updateObj },
+          { upsert: true }
+        );
+      }
+
+     
+      const logData2 = getLogConfigData();
+      if (logData2.clearCache) logData2.clearCache(guildId);
+      res.json({ success: true });
     } catch (e) {
       res.json({ success: false, error: e.message });
     }
   });
 
-  // ==================== API القائمة السوداء العامة ====================
+ 
+  app.post("/api/:guildId/logs/reset", isAuthenticated, canModifySettings, async (req, res) => {
+    const logData = getLogConfigData();
+    if (!logData.databaseEnabled)
+      return res.json({ error: "يجب تفعيل وضع Database لتعديل الإعدادات" });
+
+    const guildId = req.params.guildId;
+
+    try {
+      await Log.findOneAndDelete({ guildId });
+    
+      if (logData.clearCache) logData.clearCache(guildId);
+      res.json({ success: true });
+    } catch (e) {
+      res.json({ success: false, error: e.message });
+    }
+  });
+
+
+  app.post(
+    "/api/guild/:guildId/blacklist",
+    isAuthenticated,
+    async (req, res) => {
+      const { type, id } = req.body;
+      const guildId = req.params.guildId;
+
+      try {
+        if (addToBlacklist) {
+          const result = await addToBlacklist(guildId, type, id);
+          return res.json({ success: result });
+        } else if (Blacklist) {
+          const exists = await Blacklist.findOne({ guild: guildId, type, id });
+          if (!exists) {
+            await Blacklist.create({ guild: guildId, type, id });
+          }
+          return res.json({ success: true });
+        }
+        res.json({ error: "Blacklist system not available" });
+      } catch (e) {
+        res.json({ success: false, error: e.message });
+      }
+    }
+  );
+
+
+  app.delete(
+    "/api/guild/:guildId/blacklist",
+    isAuthenticated,
+    async (req, res) => {
+      const { type, id } = req.body;
+      const guildId = req.params.guildId;
+
+      try {
+        if (removeFromBlacklist) {
+          const result = await removeFromBlacklist(guildId, type, id);
+          return res.json({ success: result });
+        } else if (Blacklist) {
+          await Blacklist.deleteOne({ guild: guildId, type, id });
+          return res.json({ success: true });
+        }
+        res.json({ error: "Blacklist system not available" });
+      } catch (e) {
+        res.json({ success: false, error: e.message });
+      }
+    }
+  );
+
   app.get("/api/blacklist/:type", isAuthenticated, async (req, res) => {
     const { type } = req.params;
     try {
       if (Blacklist) {
-        const typeMap = { users: 'user', roles: 'role', channels: 'channel' };
+        const typeMap = { users: "user", roles: "role", channels: "channel" };
         const items = await Blacklist.find({ type: typeMap[type] || type });
         return res.json({ items });
       }
@@ -427,7 +742,7 @@ app.set("views", path.join(__dirname, "views"));
       if (Blacklist) {
         const exists = await Blacklist.findOne({ type, id });
         if (!exists) {
-          await Blacklist.create({ type, id, guild: 'global' });
+          await Blacklist.create({ type, id, guild: "global" });
         }
         return res.json({ success: true });
       }
@@ -450,17 +765,19 @@ app.set("views", path.join(__dirname, "views"));
     }
   });
 
-  // API لجلب بيانات مستخدم (عام)
+
   app.get("/api/user/:userId", isAuthenticated, async (req, res) => {
     try {
-      const user = await client.users.fetch(req.params.userId).catch(() => null);
+      const user = await client.users
+        .fetch(req.params.userId)
+        .catch(() => null);
       if (user) {
         return res.json({
           id: user.id,
           username: user.username,
           global_name: user.globalName,
           avatar: user.avatar,
-          discriminator: user.discriminator
+          discriminator: user.discriminator,
         });
       }
       res.json({ error: "User not found" });
@@ -469,14 +786,15 @@ app.set("views", path.join(__dirname, "views"));
     }
   });
 
-  // ==================== API للأعضاء ====================
-  // الحصول على معلومات عضو
+
   app.get("/api/:guildId/member/:userId", isAuthenticated, async (req, res) => {
     const guild = client.guilds.cache.get(req.params.guildId);
     if (!guild) return res.json({ error: "Guild not found" });
 
     try {
-      const member = await guild.members.fetch(req.params.userId).catch(() => null);
+      const member = await guild.members
+        .fetch(req.params.userId)
+        .catch(() => null);
       if (member) {
         return res.json({
           user: {
@@ -484,9 +802,9 @@ app.set("views", path.join(__dirname, "views"));
             username: member.user.username,
             global_name: member.user.globalName,
             avatar: member.user.avatar,
-            discriminator: member.user.discriminator
+            discriminator: member.user.discriminator,
           },
-          displayName: member.displayName
+          displayName: member.displayName,
         });
       }
       res.json({ error: "Member not found" });
@@ -495,103 +813,280 @@ app.set("views", path.join(__dirname, "views"));
     }
   });
 
-  // البحث عن أعضاء
+
   app.get("/api/:guildId/members/search", isAuthenticated, async (req, res) => {
     const guild = client.guilds.cache.get(req.params.guildId);
     if (!guild) return res.json({ members: [] });
 
-    const query = (req.query.q || '').toLowerCase();
+    const query = (req.query.q || "").toLowerCase();
     if (query.length < 2) return res.json({ members: [] });
 
     try {
-      // جلب الأعضاء من الكاش
+    
       const members = guild.members.cache
-        .filter(m => 
-          m.user.username.toLowerCase().includes(query) ||
-          m.displayName.toLowerCase().includes(query) ||
-          m.user.id.includes(query)
+        .filter(
+          (m) =>
+            m.user.username.toLowerCase().includes(query) ||
+            m.displayName.toLowerCase().includes(query) ||
+            m.user.id.includes(query)
         )
         .first(20)
-        .map(m => ({
+        .map((m) => ({
           id: m.user.id,
           username: m.user.username,
           displayName: m.displayName,
           avatar: m.user.avatar,
-          discriminator: m.user.discriminator
+          discriminator: m.user.discriminator,
         }));
-      
+
       res.json({ members });
     } catch (e) {
       res.json({ members: [], error: e.message });
     }
   });
 
-  // ==================== API للمستويات ====================
-  // تحديث مستوى مستخدم
-  app.post("/api/:guildId/level/update", isAuthenticated, async (req, res) => {
+
+  app.post("/api/:guildId/level/update", isAuthenticated, canModifySettings, async (req, res) => {
     const { userId, xp, level } = req.body;
     const guildId = req.params.guildId;
 
     try {
-      if (Level) {
+      if (!Level) return res.json({ error: "Level system not available" });
+      
+      if (level !== undefined) {
+   
+        const config = await getGuildConfig(guildId);
+        const totalXP = xpNeeded(level - 1, config || {});
         await Level.findOneAndUpdate(
-          { guildId, userId },
-          { totalXP: xp, level, $setOnInsert: { text: 0, voice: 0 } },
+          { userId, guildId },
+          { userId, guildId, level, totalXP },
+          { upsert: true, new: true }
+        );
+      } else if (xp !== undefined) {
+       
+        const config = await getGuildConfig(guildId);
+        const newLevel = calculateLevel(xp, config || {});
+        await Level.findOneAndUpdate(
+          { userId, guildId },
+          { userId, guildId, totalXP: xp, level: newLevel },
           { upsert: true, new: true }
         );
-        return res.json({ success: true });
       }
-      res.json({ error: "Level system not available" });
+      return res.json({ success: true });
     } catch (e) {
       res.json({ success: false, error: e.message });
     }
   });
 
-  // إضافة XP لمستخدم
-  app.post("/api/:guildId/level/add", isAuthenticated, async (req, res) => {
-    const { userId, xp, level } = req.body;
+  
+  app.post("/api/:guildId/level/set", isAuthenticated, canModifySettings, async (req, res) => {
+    const { userId, level } = req.body;
     const guildId = req.params.guildId;
 
     try {
-      if (Level) {
-        const existing = await Level.findOne({ guildId, userId });
-        if (existing) {
-          existing.totalXP += xp;
-          if (level > 0) existing.level = level;
-          await existing.save();
-        } else {
-          await Level.create({ guildId, userId, totalXP: xp, level: level || 0, text: 0, voice: 0 });
-        }
-        return res.json({ success: true });
+      if (!Level) return res.json({ error: "Level system not available" });
+      const config = await getGuildConfig(guildId);
+      const totalXP = xpNeeded(level - 1, config || {});
+      await Level.findOneAndUpdate(
+        { userId, guildId },
+        { userId, guildId, level, totalXP },
+        { upsert: true, new: true }
+      );
+      return res.json({ success: true });
+    } catch (e) {
+      res.json({ success: false, error: e.message });
+    }
+  });
+
+  
+  app.post("/api/:guildId/level/setxp", isAuthenticated, canModifySettings, async (req, res) => {
+    const { userId, xp } = req.body;
+    const guildId = req.params.guildId;
+
+    try {
+      if (!Level) return res.json({ error: "Level system not available" });
+      const config = await getGuildConfig(guildId);
+      const level = calculateLevel(xp, config || {});
+      await Level.findOneAndUpdate(
+        { userId, guildId },
+        { userId, guildId, totalXP: xp, level },
+        { upsert: true, new: true }
+      );
+      return res.json({ success: true });
+    } catch (e) {
+      res.json({ success: false, error: e.message });
+    }
+  });
+
+  
+  app.post("/api/:guildId/level/add", isAuthenticated, canModifySettings, async (req, res) => {
+    const { userId, xp } = req.body;
+    const guildId = req.params.guildId;
+
+    try {
+      if (!Level) return res.json({ error: "Level system not available" });
+      
+      const config = await getGuildConfig(guildId);
+      const existing = await Level.findOne({ guildId, userId });
+      if (existing) {
+        existing.totalXP += xp;
+        existing.level = calculateLevel(existing.totalXP, config || {});
+        await existing.save();
+      } else {
+        await Level.create({
+          guildId,
+          userId,
+          totalXP: xp,
+          level: calculateLevel(xp, config || {}),
+          text: xp,
+        });
       }
-      res.json({ error: "Level system not available" });
+      return res.json({ success: true });
     } catch (e) {
       res.json({ success: false, error: e.message });
     }
   });
 
-  // إعادة تعيين مستوى مستخدم
-  app.post("/api/:guildId/level/reset", isAuthenticated, async (req, res) => {
+
+  app.post("/api/:guildId/level/reset", isAuthenticated, canModifySettings, async (req, res) => {
     const { userId } = req.body;
     const guildId = req.params.guildId;
 
     try {
-      if (Level) {
-        await Level.deleteOne({ guildId, userId });
-        return res.json({ success: true });
+      if (!Level) return res.json({ error: "Level system not available" });
+      await resetUser(userId, guildId);
+      return res.json({ success: true });
+    } catch (e) {
+      res.json({ success: false, error: e.message });
+    }
+  });
+
+
+  app.get("/api/:guildId/level/rank/:userId", isAuthenticated, async (req, res) => {
+    const { guildId, userId } = req.params;
+
+    try {
+      if (!Level) return res.json({ error: "Level system not available" });
+      const rank = await getUserRank(userId, guildId);
+      const userData = await Level.findOne({ guildId, userId });
+      res.json({ 
+        rank, 
+        level: userData?.level || 0,
+        totalXP: userData?.totalXP || 0,
+        xpForNext: xpNeeded((userData?.level || 0) + 1)
+      });
+    } catch (e) {
+      res.json({ error: e.message });
+    }
+  });
+
+
+  app.get("/api/:guildId/level/config", isAuthenticated, async (req, res) => {
+    try {
+      const config = await getGuildConfig(req.params.guildId);
+      const usesDashboardMode = client.levelDashboardGuilds && client.levelDashboardGuilds.has(req.params.guildId);
+      res.json({ databaseEnabled: usesDashboardMode, config: config || null });
+    } catch (e) {
+      res.json({ error: e.message });
+    }
+  });
+
+
+  app.post("/api/:guildId/level/config/role", isAuthenticated, canModifySettings, async (req, res) => {
+    const { level, roleId } = req.body;
+    const guildId = req.params.guildId;
+
+    try {
+      const config = await getGuildConfig(guildId) || {};
+      const roleReward = config.roleReward || {};
+      
+      if (roleId) {
+        roleReward[level] = roleId;
+      } else {
+        delete roleReward[level];
       }
-      res.json({ error: "Level system not available" });
+      
+      await updateGuildConfig(guildId, { roleReward });
+      res.json({ success: true, roleReward });
+    } catch (e) {
+      res.json({ success: false, error: e.message });
+    }
+  });
+
+ 
+  app.post("/api/:guildId/level/config/xp", isAuthenticated, canModifySettings, async (req, res) => {
+    const { minXP, maxXP, xpMultiplier, maxLevel, cooldown, leveling } = req.body;
+    const guildId = req.params.guildId;
+
+    try {
+      const updates = {};
+      if (minXP !== undefined) updates.minXP = minXP;
+      if (maxXP !== undefined) updates.maxXP = maxXP;
+      if (xpMultiplier !== undefined) updates.xpMultiplier = xpMultiplier;
+      if (maxLevel !== undefined) updates.maxLevel = maxLevel;
+      if (cooldown !== undefined) updates.cooldown = cooldown;
+      if (leveling !== undefined) updates.leveling = leveling;
+      
+      await updateGuildConfig(guildId, updates);
+      res.json({ success: true });
     } catch (e) {
       res.json({ success: false, error: e.message });
     }
   });
 
-  // ==================== API للإحصائيات ====================
+ 
+  app.post("/api/:guildId/level/config/blacklist", isAuthenticated, canModifySettings, async (req, res) => {
+    const { channelId, action } = req.body;
+    const guildId = req.params.guildId;
+
+    try {
+      const config = await getGuildConfig(guildId) || {};
+      let blacklistedChannels = config.blacklistedChannels || [];
+      
+      if (action === "add" && !blacklistedChannels.includes(channelId)) {
+        blacklistedChannels.push(channelId);
+      } else if (action === "remove") {
+        blacklistedChannels = blacklistedChannels.filter(id => id !== channelId);
+      }
+      
+      await updateGuildConfig(guildId, { blacklistedChannels });
+      res.json({ success: true, blacklistedChannels });
+    } catch (e) {
+      res.json({ success: false, error: e.message });
+    }
+  });
+
+ 
+  app.post("/api/:guildId/level/config/toggle", isAuthenticated, canModifySettings, async (req, res) => {
+    const { disabled } = req.body;
+    const guildId = req.params.guildId;
+
+    try {
+      await updateGuildConfig(guildId, { disabled: !!disabled });
+      res.json({ success: true });
+    } catch (e) {
+      res.json({ success: false, error: e.message });
+    }
+  });
+
+  
+  app.post("/api/:guildId/level/config/reset", isAuthenticated, canModifySettings, async (req, res) => {
+    const guildId = req.params.guildId;
+
+    try {
+      await deleteGuildConfig(guildId);
+      res.json({ success: true });
+    } catch (e) {
+      res.json({ success: false, error: e.message });
+    }
+  });
+
+
   app.get("/api/stats", (req, res) => {
     res.json(getBotStats());
   });
 
-  // API لإحصائيات السيرفر
+
   app.get("/api/:guildId/stats", isAuthenticated, async (req, res) => {
     const guild = client.guilds.cache.get(req.params.guildId);
     if (!guild) return res.json({ error: "Guild not found" });
@@ -602,8 +1097,13 @@ app.set("views", path.join(__dirname, "views"));
 
     try {
       if (Level) levelCount = await Level.countDocuments({ guildId: guild.id });
-      if (giveaway) giveawayCount = await giveaway.countDocuments({ guildId: guild.id, ended: false });
-      if (Blacklist) blacklistCount = await Blacklist.countDocuments({ guild: guild.id });
+      if (giveaway)
+        giveawayCount = await giveaway.countDocuments({
+          guildId: guild.id,
+          ended: false,
+        });
+      if (Blacklist)
+        blacklistCount = await Blacklist.countDocuments({ guild: guild.id });
     } catch (e) {
       console.error("Stats error:", e);
     }
@@ -619,18 +1119,13 @@ app.set("views", path.join(__dirname, "views"));
     });
   });
 
-  // ==================== صفحة 404 ====================
+  
   app.use((req, res) => {
     res.status(404).render("404", { botStats: getBotStats() });
   });
 
-  // تشغيل الخادم
-  app.listen(port, () => {
-    console.log(`\n🌐 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━`);
-    console.log(`   DJS-Builder Dashboard v2.0`);
-    console.log(`   🔗 http://localhost:${port}`);
-    console.log(`━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n`);
-  });
+ 
+  app.listen(port, () => {});
 
   return app;
 }