Merge remote-tracking branch 'origin/master'

package.json

@@ -1,6 +1,6 @@
 {
   "name": "synergy3",
-  "version": "3.13.4",
+  "version": "3.14.3",
   "description": "Synergy 3 - Powerful Discord BOT Framework.",
   "license": "MIT",
   "author": {

src/GuildManager.ts

@@ -1,6 +1,6 @@
 import Discord from "discord.js";
 
-import { Op } from "sequelize";
+import { Op, Transaction } from "sequelize";
 import { sequelize } from "./Database";
 
 import { GlobalLogger } from "./GlobalLogger";
@@ -90,15 +90,23 @@ export default class GuildManager extends CachedManager<Guild> {
     }
 
     public override async destroy() {
+        let t = await sequelize().transaction();
+
         for(let k of this.cacheStorage.keys()) {
-            await this.onCacheEntryDeleted(k, this.cacheStorage.get(k)!);
+            await this.onCacheEntryDeleted(k, this.cacheStorage.get(k)!, t);
+        }
+
+        try {
+            await t.commit();
+        } catch (e) {
+            GlobalLogger.root.error("GuildManager.destroy Error:", e, "\nTransaction:", t);
+            await t.rollback();
         }
+
         await super.destroy();
     }
 
-    private async onCacheEntryDeleted(discordId: string, guild: Guild) {
-        let t = await sequelize().transaction();
-
+    private async onCacheEntryDeleted(discordId: string, guild: Guild, transaction?: Transaction) {
         await StorageGuild.update({
             id: guild.id,
             group: guild.group,
@@ -113,7 +121,7 @@ export default class GuildManager extends CachedManager<Guild> {
             where: {
                 id: guild.id
             },
-            transaction: t
+            transaction
         }).catch(err => GlobalLogger.root.error("GuildManager.syncCacheEntry Error Updating StorageGuild:", err));
     }
 }

src/ModuleDataManager.ts

@@ -72,66 +72,67 @@ export default class ModuleDataManager{
         this.bot.events.once("Stop", () => { clearInterval(this.timer); });
     }
 
-    public getContainer(uuid: string) {
-        return new Promise<ModuleDataContainer>(async (resolve, reject) => {
-            let container = dataContainers.get(uuid);
-            if(container){
-                return resolve(container);
-            }
-
-            StorageModuleDataContainer.findOrCreate({
-                where: {
-                    uuid
-                },
-                defaults: {
-                    uuid: uuid,
-                    kvData: {}
-                } as StorageModuleDataContainer
-            }).then(async storage_container => {
-                container = new ModuleDataContainer(this.bot, uuid, storage_container[0].kvData);
-                dataContainers.set(uuid, container);
-                return resolve(container);
-            }).catch(reject);
-        });
+    public async getContainer(uuid: string) {
+        let container = dataContainers.get(uuid);
+        if(container){
+            return container;
+        }
+
+        let storageContainer = await StorageModuleDataContainer.findOrCreate({
+            where: {
+                uuid
+            },
+            defaults: {
+                uuid: uuid,
+                kvData: {}
+            } as StorageModuleDataContainer
+        })
+        container = new ModuleDataContainer(this.bot, uuid, storageContainer[0].kvData);
+        dataContainers.set(uuid, container);
+        return container;
     }
 
     /**
      * Don't execute this function directly! It is for internal calls 
      */
-    public _loadFromStorage() {
-        return new Promise<void>(async (resolve, reject) => {
-            StorageModuleDataContainer.findAll().then(async containers => {
-                for(let c of containers){
-                    dataContainers.set(c.uuid, new ModuleDataContainer(this.bot, c.uuid, c.kvData));
-                }
-                return resolve();
-            }).catch(reject);
-        });
+    public async _loadFromStorage() {
+        let containers = await StorageModuleDataContainer.findAll();
+        for(let c of containers){
+            dataContainers.set(c.uuid, new ModuleDataContainer(this.bot, c.uuid, c.kvData));
+        }
     }
 
     /**
      * Don't execute this function directly! It is for internal calls 
      */
-    public _syncStorage(){
-        return new Promise<void>(async (resolve) => {
-            GlobalLogger.root.info("[ModuleDataManager] Saving data to storage...");
-            let t = await sequelize().transaction();
-            for(let c of dataContainers){
-                let mdata = moduleDatas.get(c[0]);
-                if(!mdata) continue;
+    public async _syncStorage(){
+        GlobalLogger.root.info("[ModuleDataManager] Saving data to storage...");
+
+        let t = await sequelize().transaction();
 
+        for(let c of dataContainers){
+            let mdata = moduleDatas.get(c[0]);
+            if(!mdata) continue;
+
+            try {
                 await StorageModuleDataContainer.update({
                     kvData: mdata
                 }, {
                     where: {
                         uuid: c[0]
                     },
                     transaction: t
-                }).catch(err => GlobalLogger.root.warn("ModuleDataManager.syncStorage Error Updating StorageModuleDataContainer:", err));
-
+                });
+            } catch (e) {
+                GlobalLogger.root.error(`ModuleDataManager._syncStorage Error updating container "${c[0]}":`, e);
             }
-            await t.commit().catch(err => GlobalLogger.root.error("ModuleDataManager.syncStorage Error Committing:", err));
-            return resolve();
-        });
+        }
+
+        try {
+            await t.commit();
+        } catch (e) {
+            GlobalLogger.root.error("ModuleDataManager.syncStorage Error committing transaction:", e, "\nTransaction:", t);
+            await t.rollback();
+        }
     }
 }

src/Modules/Core/Avatar.ts

@@ -1,7 +1,7 @@
 import Discord from "discord.js";
 import { Emojis, Colors } from "../../Utils";
 import Module from "../Module";
-import { Synergy } from "../..";
+import { Synergy, SynergyUserError } from "../..";
 import Access, { AccessTarget } from "../../Structures/Access";
 
 export default class Avatar extends Module{
@@ -29,47 +29,21 @@ export default class Avatar extends Module{
         );
     }
 
-    public Run(interaction: Discord.CommandInteraction){
-        return new Promise<void>(async (resolve, reject) => {
-            let user = interaction.options.getUser("target_user");
-            if(!user){
-                let avatar = interaction.user.avatarURL({ size: 2048 });
-                if(avatar){
-                    let embd = new Discord.EmbedBuilder({
-                        title: `${interaction.user.username}'s avatar`,
-                        image: { url: avatar },
-                        color: Colors.Noraml
-                    });
-                    await interaction.reply({ embeds: [embd]}).catch(reject);
-                    return resolve();
-                }else{
-                    let embd = new Discord.EmbedBuilder({
-                        title: `${Emojis.RedErrorCross} Cannot get your avatar!`,
-                        color: Colors.Error
-                    });
-                    await interaction.reply({ embeds: [embd] }).catch(reject);
-                    return resolve();
-                }                    
-            }else{
-                var avatar = user.avatarURL({ size: 2048 });
+    public async Run(interaction: Discord.CommandInteraction){
+        let user = interaction.options.getUser("target_user");
+        if(!user){
+            user = interaction.user;
+        }
 
-                if(!avatar){
-                    let embd = new Discord.EmbedBuilder({
-                        title: `${Emojis.RedErrorCross} Cannot get user's avatar!`,
-                        color: Colors.Error
-                    });
-                    await interaction.reply({ embeds: [embd] }).catch(reject);
-                    return resolve();
-                }
+        let avatar = user.avatarURL({ size: 2048 });
 
-                let embd = new Discord.EmbedBuilder({
-                    title: `${user.username}'s avatar`,
-                    image: { url: avatar },
-                    color: Colors.Noraml
-                });
-                await interaction.reply({ embeds: [embd]}).catch(reject);
-                return resolve();
-            }
+        if(!avatar){
+            throw new SynergyUserError("Cannot get user's avatar!")
+        }
+
+        await interaction.reply({
+            content: `${user.username}'s avatar`,
+            files: [ avatar ]
         });
     }
 }

src/Modules/Core/Config.ts

@@ -202,7 +202,7 @@ export default class Config extends Module{
     public async interactionRouter(interaction: Discord.ChatInputCommandInteraction, user: User) {
         let subcommandGroup = interaction.options.getSubcommandGroup(true);
         let namespace = interaction.options.getString("namespace", true);
-        let ephemeralTarget = await this.getEphemeralTarget(interaction, namespace);
+        let ephemeralTarget = await this.getEphemeralTarget(interaction, user, namespace);
 
         if(!await this.checkPermissions(interaction, user, namespace)) {
             throw new MissingPermissionsError();
@@ -431,10 +431,10 @@ export default class Config extends Module{
         }
     }
 
-    private async getEphemeralTarget(interaction: Discord.ChatInputCommandInteraction, namespace: string) {
+    private async getEphemeralTarget(interaction: Discord.ChatInputCommandInteraction, user: User, namespace: string) {
         switch (namespace) {
             case "user": {
-                return interaction.user.id;
+                return user.unifiedId;
             }
 
             case "guild": {

src/Modules/Core/Profile.ts

@@ -14,6 +14,7 @@ export default class Profile extends Module{
 
     public Access: AccessTarget[] = [ Access.PLAYER(), Access.BANNED() ]
 
+    private static customProfileFields: Discord.EmbedField[] = [];
 
     constructor(bot: Synergy, UUID: string) {
         super(bot, UUID);
@@ -31,26 +32,39 @@ export default class Profile extends Module{
             .commit()
         );
     }
+
+    public static addCustomField(field: Discord.EmbedField) {
+        Profile.customProfileFields.push(field);
+    }
 
     private createMessageTemplate(user: User){
-        return new Discord.EmbedBuilder({
+        let embed = new Discord.EmbedBuilder({
             title: `${user.nickname}'s profile`,
             thumbnail: user.discord?.avatar ? { url: user.discord.avatar } : undefined,
             fields: [
-                { name: "Info", value:  `ID: ${user.unifiedId}\n` +
+                { name: "Info", value:  `UnifiedId: ${user.unifiedId}\n` +
                                         `Groups: ${user.groups.join(", ")}\n` +
                                         `Language: ${user.lang}` },
-
-                user.discord ? { name: "Discord", value:`DiscordID: ${user.discord.id}\n` +
-                                                        `Tag: ${user.discord.tag}\n` +
-                                                        `Registered: ${Utils.ts(user.discord.createdAt)}` } : { name: "Discord", value: "wtf u don't have discord O_o" },
 
                 { name: "Economy", value:   `Points: ${user.economy.points}\n` +
                                             `LVL: ${user.economy.lvl}\n` +
                                             `XP: ${user.economy.xp}` },
                 ],
             color: Colors.Noraml
         });
+        if(user.discord) {
+            embed.addFields({
+                name: "Discord",
+                value:`DiscordID: ${user.discord.id}\n` +
+                    `Tag: ${user.discord.tag}\n` +
+                    `Registered: ${Utils.ts(user.discord.createdAt)}`
+            });
+        }
+        if(Profile.customProfileFields.length !== 0) {
+            embed.addFields(Profile.customProfileFields);
+        }
+
+        return embed;
     }
 
     public async Run(interaction: Discord.ChatInputCommandInteraction, user: User) {
@@ -71,7 +85,7 @@ export default class Profile extends Module{
             target = await this.bot.users.get(userId);
         }
         if(!target) {
-            target = await this.bot.users.createFromDiscord(interaction.user);
+            target = await this.bot.users.createFromDiscord(target_user);
         }
 
         await interaction.reply({embeds: [this.createMessageTemplate(target)]});

src/Structures/User.ts

@@ -82,17 +82,29 @@ export default class User implements UserOptions{
             };
         }
 
+        let economyOpts: UserEconomyOptions;
+
+        if(storageUser.economy) {
+            economyOpts = {
+                points: storageUser.economy.economyPoints,
+                lvl: storageUser.economy.economyLVL,
+                xp: storageUser.economy.economyXP
+            }
+        } else {
+            economyOpts = bot.options.userDefaultEconomy ?? {
+                points: 0.0005,
+                lvl: 1,
+                xp: 0
+            }
+        }
+
         return new User(bot, {
             unifiedId: storageUser.unifiedId,
             nickname: storageUser.nickname,
             groups: storageUser.groups,
             lang: storageUser.lang,
             discord: discordOpts,
-            economy: {
-                points: storageUser.economy.economyPoints,
-                lvl: storageUser.economy.economyLVL,
-                xp: storageUser.economy.economyXP
-            }
+            economy: economyOpts
         });
     }
 }