apexify.js 2.3.1 → 2.3.3

package/lib/discord/discord-build/levelingSystem/cLevel.js

@@ -0,0 +1,644 @@
+const EventEmitter = require('events');
+const { updateData, find, searchMany, remove } = require('../../../database/utils');
+const { levelCard, leaderBoard, xpRank } = require('../../../canvas/themes/levels-card');
+const localArray =  require('./cLevelsArray.json');
+
+class LevelingSystem extends EventEmitter {
+  constructor(config) {
+    super();
+
+    this.configCollection = 'configCollection'; // Replace with your actual collection name
+    this.levelsCollection = 'levelsCollection'; // Replace with your actual collection name
+    this.XpCount = config?.XpCount || 5;
+    this.rate = config?.rate || 2;
+    this.channelId = config?.channelId || null;
+    this.guildId = config?.guildId || null;
+    this.levelsArray = config?.levelsArray || localArray;
+    this.levelingMessage = config?.levelUpMessage || 'Congrates {user} you level up to level {level}.' 
+   
+}
+
+async setupConfig() {
+    try {
+      
+      if (!this.guildId || !this.channelId) {
+        throw new Error('Error: Please provide guildId and channelId');
+      }
+
+      if (!Array.isArray(this.levelsArray)) {
+        throw new Error('Error: levelsArray must be an array');
+      }
+
+      for (const levelObj of this.levelsArray) {
+        if (typeof levelObj !== 'object' || !('level' in levelObj) || !('xpCount' in levelObj)) {
+          throw new Error('Error: Invalid structure in levelsArray. Each object should have "level" and "xpCount" properties.');
+        }
+      }
+      
+      const configExists = await find(this.configCollection, { guildId: this.guildId });
+
+      if (!configExists) {
+        await updateData(this.configCollection, { guildId: this.guildId },
+          {
+            $set: {
+            XpCount: this.XpCount,
+            rate: this.rate,
+            channelId: this.channelId,
+            guildId: this.guildId,
+            levelUpMessage: this.levelingMessage,
+            levelsArray: this.levelsArray,
+            },
+          }
+        );
+      } else {
+        await updateData(this.configCollection, { guildId: this.guildId },
+          {
+            $set: {
+            XpCount: this.XpCount,
+            rate: this.rate,
+            channelId: this.channelId,
+            guildId: this.guildId,
+            levelUpMessage: this.levelingMessage,
+            levelsArray: this.levelsArray,
+            },
+          }
+        );
+      }
+    } catch (error) {
+      console.error('Error in setupConfig:', error);
+      this.emit('error', error.message);
+    }
+  }
+
+async disableLevel(guildId) {
+  try {
+    if (!guildId) {
+      throw new Error('Error: GuildId parameter is required. Usage: disbaleLevel(guildId).');
+    }
+
+    const search = await find(this.configCollection, { guildId });
+
+    if (!search) {
+      return 'No data found for this server';
+    }
+
+    const removeData =  await remove(this.configCollection, { guildId });
+
+    const success = {
+      message: `Disabled LevelingSytem for serverId: ${guildId} Successfully.`,
+      results: removeData,
+    }
+
+    return success;
+  } catch (error) {
+    console.log(error.message);
+    throw new Error(`Error: An error occurred while disbaling leveling system.`)
+  }
+}
+
+async xpCard(context, guildId, userId, version = 1) {
+  try {
+    if (!context) {
+      throw new Error('Error: Interactio/Message parameter is required. Usage: xpCard(interaction, guildId, userId). You can replace interaction with message if prefix.');
+    }
+    
+    if (!guildId) {
+      throw new Error('Error: GuildId parameter is required. Usage: xpCard(guildId, userId).');
+    }
+
+    if (!userId) {
+      throw new Error('Error: UserId parameter is required. Usage: xpCard(guildId, userId).');
+    }
+
+    const search = await find(this.levelsCollection, { userId, guildId });
+
+    if (!search) {
+      return 'No data found for this user';
+    }
+
+const rank = await searchMany([
+  { collectionName: this.levelsCollection, displayment: null, filter: { guildId } },
+]);
+
+const sortedLevels = rank.levelsCollection.sort((a, b) => {
+  return b.xpCount - a.xpCount;
+});
+
+const userIndex = sortedLevels.findIndex(user => user.userId === userId);
+let userRank;
+
+if (userIndex !== -1) {
+  userRank = userIndex + 1;
+} else {
+  userRank = 'unknown';
+}
+
+
+  const nextLevelIndex = search.level + 1;
+  let nextLevelData;
+
+  if (nextLevelIndex < this.levelsArray.length) {
+    nextLevelData = this.levelsArray[nextLevelIndex];
+  } else {
+    nextLevelData = { level: 'max', xpCount: 'max' };
+  }
+
+
+    const card = await xpRank(context, guildId, userId, search.level, userRank, search.xpCount, nextLevelData.xpCount, this.levelsArray, version, search.bannerURL) 
+
+    if (!card) return 'An Error occurred while drawing users xpCard.'
+    
+    return card;
+  } catch (error) {
+    console.log(error.message);
+    throw new Error(`An error occurred while sending xpCard.`)
+  }
+}
+  
+
+async addXp(userId, guildId) {
+  try {
+     if (!guildId) {
+      throw new Error('Error: GuildId parameter is required. Usage: addXp(userId, guildId).');
+    }
+
+    if (!userId) {
+      throw new Error('Error: UserId parameter is required. Usage: addXp(userId, guildId).');
+    }
+    
+    const fetchServer = await find(this.configCollection, { guildId: guildId });
+    
+     if (!fetchServer) {
+       return `This server has no leveling system`;
+     }
+    
+    const userRecord = await find(this.levelsCollection, { userId, guildId: guildId });
+
+    let updatedUserRecord;
+
+    if (!userRecord) {
+      updatedUserRecord = await updateData(this.levelsCollection, { userId, guildId: guildId }, {
+        $set: {
+          userId,
+          guildId: guildId,
+          xpCount: this.XpCount * this.rate,
+          level: 0,
+        },
+      });
+    } else {
+      updatedUserRecord = await updateData(this.levelsCollection, { userId, guildId: guildId }, {
+        $inc: { xpCount: this.XpCount * this.rate },
+      });
+
+      if (updatedUserRecord.data.xpCount >= this.levelsArray[this.levelsArray.length - 1].xpCount) {
+
+        await updateData(this.levelsCollection, { userId, guildId: guildId }, {
+          $set: {
+            xpCount: this.levelsArray[this.levelsArray.length - 1].xpCount,
+            level: this.levelsArray[this.levelsArray.length - 1].level,
+          },
+        });
+        
+        return `${userId} reached maximum level`;
+      }
+
+      const levelUp = this.checkLevelUp(updatedUserRecord.data);
+      const channelData = fetchServer.channelId;
+        
+      if (levelUp) {
+        const results = await updateData(this.levelsCollection, { userId, guildId: guildId }, {
+          $set: { level: updatedUserRecord.data.level },
+        });
+        const levelUpMessage = fetchServer.levelUpMessage;
+let editedMessage = levelUpMessage;
+if (editedMessage.includes('{user}')) {
+  editedMessage = editedMessage.replace('{user}', `<@${userId}>`);
+}if (editedMessage.includes('{level}')) {
+  editedMessage = editedMessage.replace('{level}', results.data.level);
+}
+        this.emit('levelup', editedMessage, userId, results.data.level, results.data.xpCount, channelData, updatedUserRecord.data.guildId);
+      }
+    }
+
+    const success = {
+      message: 'User gained xp.',
+      newXp: updatedUserRecord.data.xpCount,
+      newLevel: updatedUserRecord.data.level,
+      data: updatedUserRecord.data,
+    };
+    
+    return success;
+  } catch (error) {
+    this.emit('error', error.message);
+    throw error;
+  }
+}
+
+async setUserBanner(guildId, userId, bannerURL) {
+  try {
+    if (!guildId) {
+      throw new Error('Error: GuildId parameter is required. Usage: setUserBanner(guildId, userId, bannerURL).');
+    }
+
+    if (!userId) {
+      throw new Error('Error: UserId parameter is required. Usage: setUserBanner(guildId, userId, bannerURL).');
+    }
+
+    if (!bannerURL || !bannerURL.startsWith('http')) {
+      throw new Error('Error: BannerURL parameter is required. Usage: setUserBanner(guildId, userId, bannerURL).');
+    }
+    
+    const saveData = await updateData(this.levelsCollection, { userId, guildId }, { $set: { bannerURL }})
+    
+    return saveData.data
+  } catch (error) {
+    console.error(error.message);
+    throw new Error(`Error: An error occurred while setting user banner.`)
+  }
+}
+
+async updateUserLevel(userId, guildId) {
+    try {
+      const userRecord = await find(this.levelsCollection, { userId, guildId });
+      if (!userRecord) {
+        console.error(`User record not found for userId: ${userId}, guildId: ${guildId}`);
+        return;
+      }
+
+      const userXp = userRecord.xpCount;
+
+      let updatedLevel = 0;
+      for (const levelInfo of this.levelsArray) {
+        if (userXp >= levelInfo.xpCount) {
+          updatedLevel = levelInfo.level;
+        } else {
+          break; 
+        }
+      }
+
+      await updateData(this.levelsCollection, { userId, guildId }, {
+        $set: { level: updatedLevel },
+      });
+
+      return updatedLevel;
+    } catch (error) {
+      console.error("Error updating user level:", error.message);
+      throw error;
+    }
+  }
+
+  
+checkLevelUp(userRecord) {
+  let level = this.levelsArray.length - 1;
+
+  while (level >= 0 && userRecord.xpCount <= this.levelsArray[level].xpCount) {
+    level--;
+  }
+
+  if (level < 0) {
+    console.error(`Error: Invalid level data for user with xpCount: ${userRecord.xpCount}`);
+    this.emit('error', `Invalid level data for user with xpCount: ${userRecord.xpCount}`);
+    return false;
+  }
+
+  const nextLevelData = this.levelsArray[level];
+
+  if (userRecord.level < nextLevelData.level) {
+    userRecord.level = nextLevelData.level;
+    return true;
+  }
+
+  return false;
+}
+
+async userInfo(userId, guildId) {
+  try {
+    const userRecord = await find(this.levelsCollection, { userId, guildId });
+
+    if (!userRecord) {
+      return 'No data found for this user.';
+    }
+
+    return {
+      userId: userRecord.userId,
+      XpCount: userRecord.xpCount,
+      Level: userRecord.level,
+      bannerURL: userRecord.bannerURL || `user doesn't have custom banner url`,
+    };
+  } catch (error) {
+    console.error('Error in userInfo:', error);
+    this.emit('error', error.message);
+    return null;
+  }
+}
+  
+async checkConfig(guildId) {
+  try {
+    const configData = await find(this.configCollection, { guildId });
+
+    if (!configData) {
+      return 'No config data found for this server.';
+    }
+
+    return {
+      XpCount: configData.XpCount,
+      rate: configData.rate,
+      channelId: configData.channelId,
+      guildId: configData.guildId,
+      levelsArray: configData.levelsArray,
+    };
+  } catch (error) {
+    console.error('Error in checkConfig:', error);
+    this.emit('error', error.message);
+    return null;
+  }
+}
+  
+async serverLeaderBoard(guildId, topUsers = 10) {
+  try {
+    if (!guildId) {
+      throw new Error(`Error: GuildId must be provided in the parameter serverLeaderBoard(guildId).`)
+    }
+    
+    if (topUsers === 0 || topUsers < -1 ) {
+      throw new Error('Error: serverLeaderBoard cant display 0 members.')
+    }
+    
+    const collectionFilters = [
+      { collectionName: this.levelsCollection, displayment: topUsers, filter: { guildId } }
+    ];
+
+    const search = await searchMany(collectionFilters);
+
+    const usersList = search.levelsCollection;
+
+    if (!usersList) {
+      console.log('No config data found for this server.');
+      return 'No config data found for this server.';
+    }
+
+    if (!Array.isArray(usersList)) {
+      console.error('Error in serverLeaderBoard: usersList is not an array');
+      return [];
+    }
+
+    const sortedUsersList = usersList.sort((a, b) => b.xpCount - a.xpCount);
+
+    let topUsersData;
+
+    if (topUsers === -1) {
+      topUsersData = sortedUsersList;
+    } else {
+      topUsersData = sortedUsersList.slice(0, topUsers);
+    }
+
+    const transformedData = topUsersData.map(user => ({
+      userId: user.userId,
+      xpCount: user.xpCount,
+      level: user.level,
+      guildId: user.guildId
+    }));
+
+    return transformedData;
+  } catch (error) {
+    console.error('Error in serverLeaderBoard:', error);
+    this.emit('error', error.message);
+    return [];
+  }
+}
+
+async topGlobal(topUsers = 10) {
+  try {
+
+   if (topUsers === 0 || topUsers < -1 ) {
+     throw new Error('Error: leaderBoard cant display 0 members.')
+   }
+    
+    const collectionFilters = [
+      { collectionName: this.levelsCollection, displayment: topUsers, filter: {} }
+    ];
+
+    const search = await searchMany(collectionFilters);
+    const usersList = search.levelsCollection;
+
+    if (!usersList) {
+      return 'No config data found for this server.';
+    }
+
+    if (!Array.isArray(usersList)) {
+      console.error('Error in leaderBoard: usersList is not an array');
+      return [];
+    }
+
+    const sortedUsersList = usersList.sort((a, b) => b.xpCount - a.xpCount);
+
+    let topUsersData;
+
+    if (topUsers === -1) {
+      topUsersData = sortedUsersList;
+    } else {
+      topUsersData = sortedUsersList.slice(0, topUsers);
+    }
+
+    const transformedData = topUsersData.map(user => ({
+      userId: user.userId,
+      XpCount: user.xpCount,
+      Level: user.level,
+    }));
+
+    return transformedData;
+  } catch (error) {
+    console.error('Error in leaderBoard:', error);
+    this.emit('error', error.message);
+    return [];
+  }
+}
+  
+  async levelUpCard(message, userId, guildId, options = {}) {
+
+    if (!message) {
+      throw new Error('Error: Please define message paramter in userCard(message, userId)');
+    }
+    
+    if (!userId) {
+      throw new Error('Error: Please define userId paramter in userCard(message, userId)');
+    }
+    
+    try {
+      const userRecord = await find(this.levelsCollection, { userId, guildId });
+
+      if (!userRecord) {
+        return 'No data found for this user.';
+      }
+
+      const attachment = await levelCard(message, userRecord, options);
+
+      return attachment;
+    } catch (error) {
+      console.error(error.message)
+      throw error;
+    }
+  }
+
+async serverLeaderBoardCard(message, guildId, version = 1, colorHex = 'random') {
+  
+    if (!guildId) {
+      throw new Error(`Error: Message must be provided in the parameter leaderBoardCard(message, guildId).`)
+    }
+  
+    if (!guildId) {
+      throw new Error(`Error: GuildId must be provided in the parameter leaderBoardCard(message, guildId).`)
+    }
+
+  try {
+    const fetchServer = await find(this.configCollection, { guildId: guildId });
+    
+     if (!fetchServer) {
+       return `This server has no leveling system`;
+     }
+    
+    const leaderBoardData = await this.serverLeaderBoard(guildId, 5);
+    const card = await leaderBoard(message, leaderBoardData, version, colorHex)
+
+      return card;
+    } catch (error) {
+      console.error(error.message);
+    }
+  }
+  
+async editXp(guildId, userId, xpAmount) {
+  try {  
+    if (!guildId) {
+      throw new Error(`Error: GuildId isn't provided. Please use editXp(guildId, userId, xpAmount).`)
+    }
+    
+    if (!userId) {
+      throw new Error(`Error: UserId isn't provided. Please use editXp(guildId, userId, xpAmount).`)
+    }  
+       
+    if (!xpAmount || typeof xpAmount !== 'number') {
+      throw new Error('Error: Please xpAmount editXp(guidId, userId, xpAmount). xpAmount must be a number.');
+    }
+
+    const search = await find(this.levelsCollection, { guildId, userId });
+
+    if (!search) {
+      return 'This user has no leveling data'
+    }
+
+    const searchServer = await find(this.configCollection, { guildId });
+    const channelId = searchServer.channelId;
+    const prevLevel = search.level;
+
+    const update = await updateData(this.levelsCollection, { guildId, userId }, { $inc: { xpCount: xpAmount }})
+
+
+    const levelUp = await this.updateUserLevel(userId, guildId);
+
+    if (levelUp > prevLevel) {
+  
+  const results = await updateData(this.levelsCollection, { userId, guildId }, {
+          $set: { level: updatedUserRecord.data.level },
+        });
+
+const levelUpMessage = fetchServer.levelUpMessage;
+let editedMessage = levelUpMessage;
+if (editedMessage.includes('{user}')) {
+  editedMessage = editedMessage.replace('{user}', `<@${userId}>`);
+}if (editedMessage.includes('{level}')) {
+  editedMessage = editedMessage.replace('{level}', results.data.level);
+}
+        this.emit('levelup', editedMessage, userId, results.data.level, results.data.xpCount, channelId, updatedUserRecord.data.guildId);
+    }
+    
+    const success = {
+      message: 'Updated user Xp successfully',
+      newXp: update.data.xpCount,
+      newLevel: levelUp,
+    }
+    
+    return success;
+  } catch (error) {
+    console.error("Error editing XP:", error.message);
+    throw new Error("Failed to update user XP");
+    }
+  }
+
+async removeUser(guildId, userId) {
+  try { 
+    if (!guildId) {
+      throw new Error(`Error: GuildId isn't provided. Please use removeUser(guildId, userId).`)
+    }
+    
+    if (!userId) {
+      throw new Error(`Error: UserId isn't provided. Please use removeUser(guildId, userId).`)
+    }
+    
+    const search = await find(this.levelsCollection, { guildId, userId });
+
+    if (!search) {
+      return 'This user has no leveling data'
+    }
+    
+    const deleteUser = await remove(this.levelsCollection, { guildId, userId });
+
+    const success = {
+      message: 'User removed successfully',
+      results: deleteUser,
+    }
+
+    return success;
+  } catch (error) {
+    console.error('Error while removing user from data due to:', error.message)
+    throw new Error(`Couldn't remove user from data.`)
+    }
+  }
+
+ async liveServerLeaderboard(context, guildId, channelId, timer = 10000, version = 1, colorHex) {
+  try {
+    if (!guildId) {
+      throw new Error(`Error: GuildId isn't provided. Please use liveServerLeaderboard(client, guildId, channelId).`);
+    }
+
+    if (!channelId) {
+      throw new Error(`Error: ChannelId isn't provided. Please use liveServerLeaderboard(client, guildId, channelId).`);
+    }
+
+    const fetchServer = await find(this.configCollection, { guildId: guildId });
+
+    if (!fetchServer) {
+      return `This server has no leveling system`;
+    }
+
+    const existingConfig = await find('liveLeaderBoard', { guildId, channelId });
+
+    await updateData('liveLeaderBoard', { guildId, channelId }, { $set: { guildId, channelId, version } });
+
+    const card = await this.serverLeaderBoardCard(context.client, guildId, version, colorHex);
+
+    const channel = context.client.channels.cache.get(channelId);
+
+    if (channel) {
+      const liveLeaderboardMessageId = existingConfig?.messageId;
+      const existingMessage = liveLeaderboardMessageId ? await channel.messages.fetch(liveLeaderboardMessageId).catch(() => null) : null;
+
+      if (existingMessage) {
+        await existingMessage.edit({ content: '# LIVE SERVER LEADERBOARD.', files: [card] });
+      } else {
+        const newMessage = await channel.send({ content: '# LIVE SERVER LEADERBOARD.', files: [card] });
+        await updateData('liveLeaderBoard', { guildId, channelId }, { $set: { messageId: newMessage.id } });
+      }
+    } else {
+      console.error('Channel not found');
+    }
+
+    setTimeout(() => {
+      this.liveServerLeaderboard(context, guildId, channelId, timer, version, colorHex);
+    }, timer);
+  } catch (error) {
+    console.error('Error:', error.message);
+    }
+  }
+}
+
+module.exports = LevelingSystem;