@futdevpro/nts-dynamo 1.15.154 → 1.15.156

package/build/_modules/bot/_modules/discord-bot/_services/dib-messaging-provider.control-service.js

@@ -1,498 +1,498 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DyNTS_DiB_MessagingProvider_ControlService = void 0;
-const discord_js_1 = require("discord.js");
-const fsm_dynamo_1 = require("@futdevpro/fsm-dynamo");
-const bot_messaging_provider_service_base_1 = require("../../../_services/bot-messaging-provider.service-base");
-const messaging_1 = require("@futdevpro/fsm-dynamo/messaging");
-const global_settings_const_1 = require("../../../../../_collections/global-settings.const");
-const bot_channel_wrapper_interface_1 = require("../../../_models/bot-channel-wrapper.interface");
-const bot_message_wrapper_interface_1 = require("../../../_models/bot-message-wrapper.interface");
-const bot_user_wrapper_interface_1 = require("../../../_models/bot-user-wrapper.interface");
-class DyNTS_DiB_MessagingProvider_ControlService extends bot_messaging_provider_service_base_1.DyNTS_Bot_MessagingProvider_ServiceBase {
-    name = 'discord';
-    type = messaging_1.DyFM_Msg_Provider_Type.discord;
-    get botId() {
-        return this.client.user?.id;
-    }
-    get botDisplayName() {
-        return this.client.user?.displayName;
-    }
-    config;
-    client;
-    guild;
-    constructor(setConfig) {
-        super();
-        this.config = setConfig;
-    }
-    // Public accessors for Discord-specific objects (for backward compatibility with CCAP)
-    get discordClient() {
-        return this.client;
-    }
-    get discordGuild() {
-        return this.guild;
-    }
-    async setup(issuer) {
-        try {
-            this.client = new discord_js_1.Client({
-                intents: this.config.intents,
-                partials: this.config.partials,
-            });
-        }
-        catch (error) {
-            fsm_dynamo_1.DyFM_Error.logSimple('Error during Discord bot setup:', error);
-            throw new fsm_dynamo_1.DyFM_Error({
-                ...this.getDefaultErrorSettings('setup', error, issuer),
-                errorCode: `${global_settings_const_1.DyNTS_global_settings.systemShortCodeName}|DyNTS-DiB-MessagingProvider-S000`,
-            });
-        }
-    }
-    async start(issuer) {
-        try {
-            if (!this.client) {
-                throw new Error('Discord client not initialized. Call setup() first.');
-            }
-            return new Promise((resolve, reject) => {
-                this.client.on('ready', async () => {
-                    if (global_settings_const_1.DyNTS_global_settings.bot_settings?.debugLevel >= 1) {
-                        fsm_dynamo_1.DyFM_Log.success(`Discord bot logged in as ${this.client.user?.tag}`);
-                    }
-                    // Get guild
-                    this.guild = this.client.guilds.cache.get(this.config.guildId);
-                    if (!this.guild) {
-                        reject(new Error(`Discord server not found with ID: ${this.config.guildId}`));
-                        return;
-                    }
-                    resolve();
-                });
-                this.client.login(this.config.token).catch(reject);
-            });
-        }
-        catch (error) {
-            fsm_dynamo_1.DyFM_Error.logSimple('Error during Discord bot start:', error);
-            throw new fsm_dynamo_1.DyFM_Error({
-                ...this.getDefaultErrorSettings('start', error, issuer),
-                errorCode: `${global_settings_const_1.DyNTS_global_settings.systemShortCodeName}|DyNTS-DiB-MessagingProvider-S001`,
-            });
-        }
-    }
-    async getChannelByName(name) {
-        if (this.channelCache.has(name)) {
-            return await this.wrapChannel(this.channelCache.get(name));
-        }
-        const channel = this.guild.channels.cache.find((ch) => ch.name === name && ch.isTextBased());
-        if (!channel) {
-            throw new Error(`No text channel found with name "${name}"`);
-        }
-        this.channelCache.set(name, channel);
-        return await this.wrapChannel(channel);
-    }
-    async getChannelById(id) {
-        const channel = this.guild.channels.cache.get(id);
-        if (!channel) {
-            throw new Error(`No text channel found with ID "${id}"`);
-        }
-        if (!this.channelCache.has(channel.name)) {
-            this.channelCache.set(channel.name, channel);
-        }
-        return await this.wrapChannel(channel);
-    }
-    async sendMessageToChannelByName(channelName, message) {
-        const discordChannel = await this.getChannelByName(channelName);
-        return await this.sendMessageToChannel(discordChannel, message);
-        /* if (!discordChannel) {
-          throw new Error(`No text channel found with name "${channelName}"`);
-        }
-    
-        if (!discordChannel.rawPlatformChannel.isTextBased()) {
-          throw new Error(`Channel "${channelName}" is not a text channel`);
-        }
-    
-        //const sentMessage: Message = await (discordChannel.rawPlatformChannel as TextChannel).send(message);
-        const channel: TextChannel = discordChannel.rawPlatformChannel as TextChannel;
-    
-        let firstMessage: Message;
-        const originalMessage: string = message;
-        if (message.length > 2_000) { // 2000 characters per message
-          while (message.length) {
-            if (!firstMessage) {
-              firstMessage = await channel.send(message.substring(0, 2_000));
-            } else {
-              await channel.send(message.substring(0, 2_000));
-            }
-    
-            message = message.substring(2_000);
-          }
-    
-          firstMessage.content = originalMessage;
-          return this.wrapMessage(firstMessage);
-        } else {
-          const messageSent: Message = await channel.send(message);
-          return this.wrapMessage(messageSent);
-        } */
-    }
-    async getMessagesFromChannelByChannelName(channelName, limit = 100) {
-        const channel = await this.getChannelByName(channelName);
-        if (!channel.rawPlatformChannel.isTextBased()) {
-            throw new Error(`Channel "${channelName}" is not a text channel`);
-        }
-        const messages = await channel.rawPlatformChannel.messages.fetch({
-            limit: limit
-        });
-        return await Promise.all(Array.from(messages.values()).map(async (msg) => await this.wrapMessage(msg)));
-    }
-    async getLastMessageInChannel(channelName) {
-        const channel = await this.getChannelByName(channelName);
-        if (!channel.rawPlatformChannel.isTextBased()) {
-            throw new Error(`Channel "${channelName}" is not a text channel`);
-        }
-        const messages = await channel.rawPlatformChannel.messages.fetch({
-            limit: 1
-        });
-        const lastMessage = messages.first();
-        return lastMessage ? await this.wrapMessage(lastMessage) : null;
-    }
-    async clearChannel(channel) {
-        if (!channel.rawPlatformChannel.isTextBased()) {
-            throw new Error(`Channel "${channel.name}" is not a text channel`);
-        }
-        let lastId = undefined;
-        let fetched = 0;
-        const maxFetch = 1000;
-        while (fetched < maxFetch) {
-            const options = { limit: 100 };
-            if (lastId) {
-                options.before = lastId;
-            }
-            const messageCollection = await channel.rawPlatformChannel.messages.fetch(options);
-            if (messageCollection.size === 0) {
-                break;
-            }
-            const deletePromises = Array.from(messageCollection.values()).map((message) => message.delete().catch((error) => {
-                fsm_dynamo_1.DyFM_Error.logSimple('Failed to delete message', error);
-            }));
-            await Promise.all(deletePromises);
-            lastId = Array.from(messageCollection.values()).pop()?.id;
-            fetched += messageCollection.size;
-        }
-    }
-    // Message operations
-    async sendMessageToChannel(channel, content) {
-        if (!channel.rawPlatformChannel.isTextBased()) {
-            throw new Error(`Channel "${channel.name}" is not a text channel`);
-        }
-        const discordTextChannel = channel.rawPlatformChannel;
-        const originalContent = content;
-        let firstMessage;
-        if (content.length > 2_000) { // 2000 characters per message
-            while (content.length) {
-                if (!firstMessage) {
-                    firstMessage = await discordTextChannel.send(content.substring(0, 2_000));
-                }
-                else {
-                    await discordTextChannel.send(content.substring(0, 2_000));
-                }
-                content = content.substring(2_000);
-            }
-            firstMessage.content = originalContent;
-            return await this.wrapMessage(firstMessage);
-        }
-        else {
-            const message = await discordTextChannel.send(content);
-            return await this.wrapMessage(message);
-        }
-    }
-    async replyToMessage(message, content) {
-        try {
-            /* const channel = this.guild.channels.cache.get(channelId) as TextChannel;
-            if (!channel) {
-              throw new Error(`Channel not found with ID: ${channelId}`);
-            }
-            const message = await channel.messages.fetch(messageId); */
-            if (!message.rawPlatformMessage.channel.isTextBased()) {
-                throw new Error(`Message "${message.id}" is not a text message`);
-            }
-            const originalContent = content;
-            if (content.length > 2_000) {
-                let firstMessage;
-                while (content.length) {
-                    if (!firstMessage) {
-                        firstMessage = await message.rawPlatformMessage.channel.send(content.substring(0, 2_000));
-                    }
-                    else {
-                        await message.reply(content.substring(0, 2_000));
-                    }
-                    content = content.substring(2_000);
-                }
-                firstMessage.content = originalContent;
-                return await this.wrapMessage(firstMessage);
-            }
-            else {
-                const reply = await message.rawPlatformMessage.reply(content);
-                return await this.wrapMessage(reply);
-            }
-        }
-        catch (error) {
-            fsm_dynamo_1.DyFM_Error.logSimple('Error replying to message:', error);
-            throw new fsm_dynamo_1.DyFM_Error({
-                ...this.getDefaultErrorSettings('replyToMessage', error, message.issuer),
-                errorCode: `${global_settings_const_1.DyNTS_global_settings.systemShortCodeName}|DyNTS-DiB-MessagingProvider-S002`,
-            });
-        }
-    }
-    async sendTyping(channel) {
-        if (!channel.rawPlatformChannel.isTextBased()) {
-            throw new Error(`Channel "${channel.name}" is not a text channel`);
-        }
-        await channel.rawPlatformChannel.sendTyping();
-    }
-    async sendTypingForMessage(message) {
-        if (!message.rawPlatformMessage.channel.isTextBased()) {
-            throw new Error(`Message "${message.id}" is not a text message`);
-        }
-        await message.rawPlatformMessage.channel.sendTyping();
-    }
-    async fetchMessages(channel, limit) {
-        if (!channel.rawPlatformChannel.isTextBased()) {
-            throw new Error(`Channel "${channel.name}" is not a text channel`);
-        }
-        const messages = await channel.rawPlatformChannel.messages.fetch({
-            limit: limit
-        });
-        return await Promise.all(Array.from(messages.values()).map(async (msg) => await this.wrapMessage(msg)));
-    }
-    async fetchMessagesById(id, limit) {
-        const channel = await this.getChannelById(id);
-        return this.fetchMessages(channel, limit);
-    }
-    async fetchMessagesForMessage(message, limit) {
-        if (!message.rawPlatformMessage.channel.isTextBased()) {
-            throw new Error(`Message "${message.id}" is not a text message`);
-        }
-        const messages = await message.rawPlatformMessage.channel.messages.fetch({
-            limit: limit
-        });
-        return await Promise.all(Array.from(messages.values()).map(async (msg) => await this.wrapMessage(msg)));
-    }
-    async fetchAllMessagesWithPaging(channel, maxFetch = 1000) {
-        if (!channel.rawPlatformChannel.isTextBased()) {
-            throw new Error(`Channel "${channel.name}" is not a text channel`);
-        }
-        let lastId = undefined;
-        let fetched = 0;
-        const allMessages = [];
-        while (fetched < maxFetch) {
-            const options = { limit: 100 };
-            if (lastId)
-                options.before = lastId;
-            const messageCollection = await channel.rawPlatformChannel.messages.fetch(options);
-            if (messageCollection.size === 0)
-                break;
-            await fsm_dynamo_1.DyFM_Array.asyncForEach(Array.from(messageCollection.values()), async (msg) => {
-                allMessages.push(await this.wrapMessage(msg));
-            });
-            lastId = Array.from(messageCollection.values()).pop()?.id;
-            fetched += messageCollection.size;
-        }
-        return allMessages;
-    }
-    async deleteMessage(message) {
-        await message.rawPlatformMessage.delete();
-    }
-    // User operations
-    async updateMessage(message, issuer) {
-        throw new Error('Discord provider not yet implemented');
-    }
-    async getUserByName(username) {
-        const member = this.guild.members.cache.find((m) => m.user.username === username);
-        if (!member) {
-            throw new Error(`User not found with username: ${username}`);
-        }
-        return await this.wrapUser(member);
-    }
-    getUserMention(userId) {
-        return `<@${userId}>`;
-    }
-    async readMembersInChannel(channelName) {
-        const channel = await this.getChannelByName(channelName);
-        const members = await this.fetchMembersInGuild(this.guild);
-        const allowedMembers = members.filter((member) => channel.rawPlatformChannel.isTextBased() &&
-            channel.rawPlatformChannel.permissionsFor(member)?.has('ViewChannel'));
-        return await fsm_dynamo_1.DyFM_Array.asyncMap(Array.from(allowedMembers.values()), async (member) => await this.wrapUser(member));
-    }
-    async fetchMembersInGuild(guild) {
-        try {
-            // Try to fetch with a limit to avoid timeout
-            return await guild?.members.fetch({ limit: 1000 });
-        }
-        catch (fetchError) {
-            throw new fsm_dynamo_1.DyFM_Error({
-                errorCode: 'DIB-OPS-FMI0',
-                message: 'Failed to fetch members',
-                error: fetchError,
-            });
-        }
-    }
-    async readMemberNamesInChannel(channelName) {
-        const members = await this.readMembersInChannel(channelName);
-        return members.map((member) => member.username);
-    }
-    // Advanced message queries
-    async getLastMessageSentBy(channelName, username) {
-        const channel = await this.getChannelByName(channelName);
-        const messages = await this.fetchAllMessagesWithPaging(channel, 1000);
-        return messages.find((msg) => msg.authorName === username) || null;
-    }
-    async getLastMentionOf(channelName, username) {
-        const channel = await this.getChannelByName(channelName);
-        const messages = await this.fetchAllMessagesWithPaging(channel, 1000);
-        return messages.find((msg) => msg.content.includes(`@${username}`) ||
-            msg.content.includes(`<@${username}>`)) || null;
-    }
-    // Advanced message queries
-    async readLastMessageDatesByMembers(channelName, memberNames) {
-        const channel = await this.getChannelByName(channelName);
-        const messages = await this.fetchAllMessagesWithPaging(channel, 1000);
-        const memberStatus = {};
-        memberNames.forEach((name) => {
-            memberStatus[name] = { lastMessageDate: null, allMessages: 0 };
-        });
-        const cutoffTime = Date.now() - (3 * fsm_dynamo_1.week); // 3 weeks
-        messages.forEach((message) => {
-            if (message.timestamp < cutoffTime)
-                return;
-            const author = message.authorName;
-            if (memberStatus[author] !== undefined) {
-                memberStatus[author].allMessages++;
-                if (!memberStatus[author].lastMessageDate) {
-                    memberStatus[author].lastMessageDate = new Date(message.timestamp);
-                }
-            }
-        });
-        return memberNames.map((memberName) => {
-            const status = memberStatus[memberName];
-            return {
-                memberName: memberName,
-                allMessages: status.allMessages,
-                lastMessageDate: status.lastMessageDate
-            };
-        });
-    }
-    // Advanced message queries
-    async readLastMessageWithMemberNamePingInIt(channelName, users) {
-        const channel = await this.getChannelByName(channelName);
-        const messages = await this.fetchAllMessagesWithPaging(channel, 1000);
-        const memberStatus = {};
-        users.forEach((user) => {
-            memberStatus[user.username] = { lastMentionDate: null, allMentions: 0 };
-        });
-        const cutoffTime = Date.now() - (3 * fsm_dynamo_1.week); // 3 weeks
-        messages.forEach((message) => {
-            if (message.timestamp < cutoffTime)
-                return;
-            users.forEach((user) => {
-                if (message.content.includes(`@${user.id}`) &&
-                    !memberStatus[user.username].lastMentionDate) {
-                    memberStatus[user.username].lastMentionDate = new Date(message.timestamp);
-                    memberStatus[user.username].allMentions++;
-                }
-            });
-        });
-        return users.map((user) => {
-            const status = memberStatus[user.username];
-            return {
-                memberId: user.id,
-                memberName: user.username,
-                allMentions: status.allMentions,
-                lastMentionDate: status.lastMentionDate
-            };
-        });
-    }
-    // Discord-specific features
-    getRoleByName(roleName) {
-        if (this.roleCache.has(roleName)) {
-            return this.roleCache.get(roleName);
-        }
-        const role = this.guild.roles.cache.find((r) => r.name === roleName);
-        if (role) {
-            this.roleCache.set(roleName, role);
-        }
-        return role;
-    }
-    async getRolePingByName(roleName) {
-        const role = this.getRoleByName(roleName);
-        return role ? `<@&${role.id}>` : '';
-    }
-    async getRolePingsByName(roleNames) {
-        const pings = await Promise.all(roleNames.map((roleName) => this.getRolePingByName(roleName)));
-        return pings.join(' ');
-    }
-    async create_onMessageEventListener(handler) {
-        this.client.on('messageCreate', async (message) => {
-            await handler(await this.wrapMessage(message), 'discord');
-        });
-    }
-    create_onErrorEventListener(handler) {
-        this.client.on('error', (error) => {
-            handler(error);
-        });
-    }
-    async sendReport(message) {
-        return await this.sendMessageToChannelByName(this.config.reportChannelName, message);
-    }
-    async sendReportIn(message) {
-        return await this.sendMessageToChannelByName(this.config.reportChannelName, `${this.botDisplayName} report for duty! ` +
-            `(v${global_settings_const_1.DyNTS_global_settings.systemVersion} ${global_settings_const_1.DyNTS_global_settings.env_settings?.environment})`);
-    }
-    async wrapMessage(message) {
-        let replyTo = null;
-        if (message.reference?.messageId) {
-            replyTo = message.channel.messages.cache.get(message.reference.messageId);
-        }
-        return new bot_message_wrapper_interface_1.DyNTS_Bot_MessageWrapper({
-            id: message.id,
-            content: message.content,
-            authorId: message.author.id,
-            authorName: message.author.username,
-            authorDisplayName: message.author.displayName,
-            channelId: message.channel.id,
-            channelName: message.channel?.name || 'DM Channel with ' + message.channel.recipient.username,
-            timestamp: message.createdTimestamp,
-            isBot: message.author.bot,
-            isTextBased: message.channel.isTextBased(),
-            isVoiceBased: false, /* message.channel.isVoiceBased(), */
-            isDM: message.channel.isDMBased(),
-            mentions: Array.from(message.mentions.users.keys()),
-            replyToMessageId: message.reference?.messageId,
-            replyToMessageAuthorId: replyTo?.author?.id,
-            rawPlatformMessage: message,
-            issuer: message.author.id,
-            channel: await this.wrapChannel(message.channel),
-            /* user: this.wrapUser(message.author), */
-            provider: this,
-        });
-    }
-    async wrapChannel(channel) {
-        return new bot_channel_wrapper_interface_1.DyNTS_Bot_ChannelWrapper({
-            id: channel.id,
-            name: channel.name || ('DM Channel with ' + channel.recipient.username),
-            isTextBased: channel.isTextBased(),
-            isDM: channel.isDMBased(),
-            isVoiceBased: channel.isVoiceBased(),
-            rawPlatformChannel: channel,
-            provider: this,
-        });
-    }
-    async wrapUser(user) {
-        return new bot_user_wrapper_interface_1.DyNTS_Bot_UserWrapper({
-            id: user.user.id,
-            username: user.user.username,
-            displayName: user.displayName,
-            isBot: user.user.bot,
-            rawPlatformUser: user,
-            provider: this,
-        });
-    }
-}
-exports.DyNTS_DiB_MessagingProvider_ControlService = DyNTS_DiB_MessagingProvider_ControlService;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DyNTS_DiB_MessagingProvider_ControlService = void 0;
+const discord_js_1 = require("discord.js");
+const fsm_dynamo_1 = require("@futdevpro/fsm-dynamo");
+const bot_messaging_provider_service_base_1 = require("../../../_services/bot-messaging-provider.service-base");
+const messaging_1 = require("@futdevpro/fsm-dynamo/messaging");
+const global_settings_const_1 = require("../../../../../_collections/global-settings.const");
+const bot_channel_wrapper_interface_1 = require("../../../_models/bot-channel-wrapper.interface");
+const bot_message_wrapper_interface_1 = require("../../../_models/bot-message-wrapper.interface");
+const bot_user_wrapper_interface_1 = require("../../../_models/bot-user-wrapper.interface");
+class DyNTS_DiB_MessagingProvider_ControlService extends bot_messaging_provider_service_base_1.DyNTS_Bot_MessagingProvider_ServiceBase {
+    name = 'discord';
+    type = messaging_1.DyFM_Msg_Provider_Type.discord;
+    get botId() {
+        return this.client.user?.id;
+    }
+    get botDisplayName() {
+        return this.client.user?.displayName;
+    }
+    config;
+    client;
+    guild;
+    constructor(setConfig) {
+        super();
+        this.config = setConfig;
+    }
+    // Public accessors for Discord-specific objects (for backward compatibility with CCAP)
+    get discordClient() {
+        return this.client;
+    }
+    get discordGuild() {
+        return this.guild;
+    }
+    async setup(issuer) {
+        try {
+            this.client = new discord_js_1.Client({
+                intents: this.config.intents,
+                partials: this.config.partials,
+            });
+        }
+        catch (error) {
+            fsm_dynamo_1.DyFM_Error.logSimple('Error during Discord bot setup:', error);
+            throw new fsm_dynamo_1.DyFM_Error({
+                ...this.getDefaultErrorSettings('setup', error, issuer),
+                errorCode: `${global_settings_const_1.DyNTS_global_settings.systemShortCodeName}|DyNTS-DiB-MessagingProvider-S000`,
+            });
+        }
+    }
+    async start(issuer) {
+        try {
+            if (!this.client) {
+                throw new Error('Discord client not initialized. Call setup() first.');
+            }
+            return new Promise((resolve, reject) => {
+                this.client.on('ready', async () => {
+                    if (global_settings_const_1.DyNTS_global_settings.bot_settings?.debugLevel >= 1) {
+                        fsm_dynamo_1.DyFM_Log.success(`Discord bot logged in as ${this.client.user?.tag}`);
+                    }
+                    // Get guild
+                    this.guild = this.client.guilds.cache.get(this.config.guildId);
+                    if (!this.guild) {
+                        reject(new Error(`Discord server not found with ID: ${this.config.guildId}`));
+                        return;
+                    }
+                    resolve();
+                });
+                this.client.login(this.config.token).catch(reject);
+            });
+        }
+        catch (error) {
+            fsm_dynamo_1.DyFM_Error.logSimple('Error during Discord bot start:', error);
+            throw new fsm_dynamo_1.DyFM_Error({
+                ...this.getDefaultErrorSettings('start', error, issuer),
+                errorCode: `${global_settings_const_1.DyNTS_global_settings.systemShortCodeName}|DyNTS-DiB-MessagingProvider-S001`,
+            });
+        }
+    }
+    async getChannelByName(name) {
+        if (this.channelCache.has(name)) {
+            return await this.wrapChannel(this.channelCache.get(name));
+        }
+        const channel = this.guild.channels.cache.find((ch) => ch.name === name && ch.isTextBased());
+        if (!channel) {
+            throw new Error(`No text channel found with name "${name}"`);
+        }
+        this.channelCache.set(name, channel);
+        return await this.wrapChannel(channel);
+    }
+    async getChannelById(id) {
+        const channel = this.guild.channels.cache.get(id);
+        if (!channel) {
+            throw new Error(`No text channel found with ID "${id}"`);
+        }
+        if (!this.channelCache.has(channel.name)) {
+            this.channelCache.set(channel.name, channel);
+        }
+        return await this.wrapChannel(channel);
+    }
+    async sendMessageToChannelByName(channelName, message) {
+        const discordChannel = await this.getChannelByName(channelName);
+        return await this.sendMessageToChannel(discordChannel, message);
+        /* if (!discordChannel) {
+          throw new Error(`No text channel found with name "${channelName}"`);
+        }
+    
+        if (!discordChannel.rawPlatformChannel.isTextBased()) {
+          throw new Error(`Channel "${channelName}" is not a text channel`);
+        }
+    
+        //const sentMessage: Message = await (discordChannel.rawPlatformChannel as TextChannel).send(message);
+        const channel: TextChannel = discordChannel.rawPlatformChannel as TextChannel;
+    
+        let firstMessage: Message;
+        const originalMessage: string = message;
+        if (message.length > 2_000) { // 2000 characters per message
+          while (message.length) {
+            if (!firstMessage) {
+              firstMessage = await channel.send(message.substring(0, 2_000));
+            } else {
+              await channel.send(message.substring(0, 2_000));
+            }
+    
+            message = message.substring(2_000);
+          }
+    
+          firstMessage.content = originalMessage;
+          return this.wrapMessage(firstMessage);
+        } else {
+          const messageSent: Message = await channel.send(message);
+          return this.wrapMessage(messageSent);
+        } */
+    }
+    async getMessagesFromChannelByChannelName(channelName, limit = 100) {
+        const channel = await this.getChannelByName(channelName);
+        if (!channel.rawPlatformChannel.isTextBased()) {
+            throw new Error(`Channel "${channelName}" is not a text channel`);
+        }
+        const messages = await channel.rawPlatformChannel.messages.fetch({
+            limit: limit
+        });
+        return await Promise.all(Array.from(messages.values()).map(async (msg) => await this.wrapMessage(msg)));
+    }
+    async getLastMessageInChannel(channelName) {
+        const channel = await this.getChannelByName(channelName);
+        if (!channel.rawPlatformChannel.isTextBased()) {
+            throw new Error(`Channel "${channelName}" is not a text channel`);
+        }
+        const messages = await channel.rawPlatformChannel.messages.fetch({
+            limit: 1
+        });
+        const lastMessage = messages.first();
+        return lastMessage ? await this.wrapMessage(lastMessage) : null;
+    }
+    async clearChannel(channel) {
+        if (!channel.rawPlatformChannel.isTextBased()) {
+            throw new Error(`Channel "${channel.name}" is not a text channel`);
+        }
+        let lastId = undefined;
+        let fetched = 0;
+        const maxFetch = 1000;
+        while (fetched < maxFetch) {
+            const options = { limit: 100 };
+            if (lastId) {
+                options.before = lastId;
+            }
+            const messageCollection = await channel.rawPlatformChannel.messages.fetch(options);
+            if (messageCollection.size === 0) {
+                break;
+            }
+            const deletePromises = Array.from(messageCollection.values()).map((message) => message.delete().catch((error) => {
+                fsm_dynamo_1.DyFM_Error.logSimple('Failed to delete message', error);
+            }));
+            await Promise.all(deletePromises);
+            lastId = Array.from(messageCollection.values()).pop()?.id;
+            fetched += messageCollection.size;
+        }
+    }
+    // Message operations
+    async sendMessageToChannel(channel, content) {
+        if (!channel.rawPlatformChannel.isTextBased()) {
+            throw new Error(`Channel "${channel.name}" is not a text channel`);
+        }
+        const discordTextChannel = channel.rawPlatformChannel;
+        const originalContent = content;
+        let firstMessage;
+        if (content.length > 2_000) { // 2000 characters per message
+            while (content.length) {
+                if (!firstMessage) {
+                    firstMessage = await discordTextChannel.send(content.substring(0, 2_000));
+                }
+                else {
+                    await discordTextChannel.send(content.substring(0, 2_000));
+                }
+                content = content.substring(2_000);
+            }
+            firstMessage.content = originalContent;
+            return await this.wrapMessage(firstMessage);
+        }
+        else {
+            const message = await discordTextChannel.send(content);
+            return await this.wrapMessage(message);
+        }
+    }
+    async replyToMessage(message, content) {
+        try {
+            /* const channel = this.guild.channels.cache.get(channelId) as TextChannel;
+            if (!channel) {
+              throw new Error(`Channel not found with ID: ${channelId}`);
+            }
+            const message = await channel.messages.fetch(messageId); */
+            if (!message.rawPlatformMessage.channel.isTextBased()) {
+                throw new Error(`Message "${message.id}" is not a text message`);
+            }
+            const originalContent = content;
+            if (content.length > 2_000) {
+                let firstMessage;
+                while (content.length) {
+                    if (!firstMessage) {
+                        firstMessage = await message.rawPlatformMessage.channel.send(content.substring(0, 2_000));
+                    }
+                    else {
+                        await message.reply(content.substring(0, 2_000));
+                    }
+                    content = content.substring(2_000);
+                }
+                firstMessage.content = originalContent;
+                return await this.wrapMessage(firstMessage);
+            }
+            else {
+                const reply = await message.rawPlatformMessage.reply(content);
+                return await this.wrapMessage(reply);
+            }
+        }
+        catch (error) {
+            fsm_dynamo_1.DyFM_Error.logSimple('Error replying to message:', error);
+            throw new fsm_dynamo_1.DyFM_Error({
+                ...this.getDefaultErrorSettings('replyToMessage', error, message.issuer),
+                errorCode: `${global_settings_const_1.DyNTS_global_settings.systemShortCodeName}|DyNTS-DiB-MessagingProvider-S002`,
+            });
+        }
+    }
+    async sendTyping(channel) {
+        if (!channel.rawPlatformChannel.isTextBased()) {
+            throw new Error(`Channel "${channel.name}" is not a text channel`);
+        }
+        await channel.rawPlatformChannel.sendTyping();
+    }
+    async sendTypingForMessage(message) {
+        if (!message.rawPlatformMessage.channel.isTextBased()) {
+            throw new Error(`Message "${message.id}" is not a text message`);
+        }
+        await message.rawPlatformMessage.channel.sendTyping();
+    }
+    async fetchMessages(channel, limit) {
+        if (!channel.rawPlatformChannel.isTextBased()) {
+            throw new Error(`Channel "${channel.name}" is not a text channel`);
+        }
+        const messages = await channel.rawPlatformChannel.messages.fetch({
+            limit: limit
+        });
+        return await Promise.all(Array.from(messages.values()).map(async (msg) => await this.wrapMessage(msg)));
+    }
+    async fetchMessagesById(id, limit) {
+        const channel = await this.getChannelById(id);
+        return this.fetchMessages(channel, limit);
+    }
+    async fetchMessagesForMessage(message, limit) {
+        if (!message.rawPlatformMessage.channel.isTextBased()) {
+            throw new Error(`Message "${message.id}" is not a text message`);
+        }
+        const messages = await message.rawPlatformMessage.channel.messages.fetch({
+            limit: limit
+        });
+        return await Promise.all(Array.from(messages.values()).map(async (msg) => await this.wrapMessage(msg)));
+    }
+    async fetchAllMessagesWithPaging(channel, maxFetch = 1000) {
+        if (!channel.rawPlatformChannel.isTextBased()) {
+            throw new Error(`Channel "${channel.name}" is not a text channel`);
+        }
+        let lastId = undefined;
+        let fetched = 0;
+        const allMessages = [];
+        while (fetched < maxFetch) {
+            const options = { limit: 100 };
+            if (lastId)
+                options.before = lastId;
+            const messageCollection = await channel.rawPlatformChannel.messages.fetch(options);
+            if (messageCollection.size === 0)
+                break;
+            await fsm_dynamo_1.DyFM_Array.asyncForEach(Array.from(messageCollection.values()), async (msg) => {
+                allMessages.push(await this.wrapMessage(msg));
+            });
+            lastId = Array.from(messageCollection.values()).pop()?.id;
+            fetched += messageCollection.size;
+        }
+        return allMessages;
+    }
+    async deleteMessage(message) {
+        await message.rawPlatformMessage.delete();
+    }
+    // User operations
+    async updateMessage(message, issuer) {
+        throw new Error('Discord provider not yet implemented');
+    }
+    async getUserByName(username) {
+        const member = this.guild.members.cache.find((m) => m.user.username === username);
+        if (!member) {
+            throw new Error(`User not found with username: ${username}`);
+        }
+        return await this.wrapUser(member);
+    }
+    getUserMention(userId) {
+        return `<@${userId}>`;
+    }
+    async readMembersInChannel(channelName) {
+        const channel = await this.getChannelByName(channelName);
+        const members = await this.fetchMembersInGuild(this.guild);
+        const allowedMembers = members.filter((member) => channel.rawPlatformChannel.isTextBased() &&
+            channel.rawPlatformChannel.permissionsFor(member)?.has('ViewChannel'));
+        return await fsm_dynamo_1.DyFM_Array.asyncMap(Array.from(allowedMembers.values()), async (member) => await this.wrapUser(member));
+    }
+    async fetchMembersInGuild(guild) {
+        try {
+            // Try to fetch with a limit to avoid timeout
+            return await guild?.members.fetch({ limit: 1000 });
+        }
+        catch (fetchError) {
+            throw new fsm_dynamo_1.DyFM_Error({
+                errorCode: 'DIB-OPS-FMI0',
+                message: 'Failed to fetch members',
+                error: fetchError,
+            });
+        }
+    }
+    async readMemberNamesInChannel(channelName) {
+        const members = await this.readMembersInChannel(channelName);
+        return members.map((member) => member.username);
+    }
+    // Advanced message queries
+    async getLastMessageSentBy(channelName, username) {
+        const channel = await this.getChannelByName(channelName);
+        const messages = await this.fetchAllMessagesWithPaging(channel, 1000);
+        return messages.find((msg) => msg.authorName === username) || null;
+    }
+    async getLastMentionOf(channelName, username) {
+        const channel = await this.getChannelByName(channelName);
+        const messages = await this.fetchAllMessagesWithPaging(channel, 1000);
+        return messages.find((msg) => msg.content.includes(`@${username}`) ||
+            msg.content.includes(`<@${username}>`)) || null;
+    }
+    // Advanced message queries
+    async readLastMessageDatesByMembers(channelName, memberNames) {
+        const channel = await this.getChannelByName(channelName);
+        const messages = await this.fetchAllMessagesWithPaging(channel, 1000);
+        const memberStatus = {};
+        memberNames.forEach((name) => {
+            memberStatus[name] = { lastMessageDate: null, allMessages: 0 };
+        });
+        const cutoffTime = Date.now() - (3 * fsm_dynamo_1.week); // 3 weeks
+        messages.forEach((message) => {
+            if (message.timestamp < cutoffTime)
+                return;
+            const author = message.authorName;
+            if (memberStatus[author] !== undefined) {
+                memberStatus[author].allMessages++;
+                if (!memberStatus[author].lastMessageDate) {
+                    memberStatus[author].lastMessageDate = new Date(message.timestamp);
+                }
+            }
+        });
+        return memberNames.map((memberName) => {
+            const status = memberStatus[memberName];
+            return {
+                memberName: memberName,
+                allMessages: status.allMessages,
+                lastMessageDate: status.lastMessageDate
+            };
+        });
+    }
+    // Advanced message queries
+    async readLastMessageWithMemberNamePingInIt(channelName, users) {
+        const channel = await this.getChannelByName(channelName);
+        const messages = await this.fetchAllMessagesWithPaging(channel, 1000);
+        const memberStatus = {};
+        users.forEach((user) => {
+            memberStatus[user.username] = { lastMentionDate: null, allMentions: 0 };
+        });
+        const cutoffTime = Date.now() - (3 * fsm_dynamo_1.week); // 3 weeks
+        messages.forEach((message) => {
+            if (message.timestamp < cutoffTime)
+                return;
+            users.forEach((user) => {
+                if (message.content.includes(`@${user.id}`) &&
+                    !memberStatus[user.username].lastMentionDate) {
+                    memberStatus[user.username].lastMentionDate = new Date(message.timestamp);
+                    memberStatus[user.username].allMentions++;
+                }
+            });
+        });
+        return users.map((user) => {
+            const status = memberStatus[user.username];
+            return {
+                memberId: user.id,
+                memberName: user.username,
+                allMentions: status.allMentions,
+                lastMentionDate: status.lastMentionDate
+            };
+        });
+    }
+    // Discord-specific features
+    getRoleByName(roleName) {
+        if (this.roleCache.has(roleName)) {
+            return this.roleCache.get(roleName);
+        }
+        const role = this.guild.roles.cache.find((r) => r.name === roleName);
+        if (role) {
+            this.roleCache.set(roleName, role);
+        }
+        return role;
+    }
+    async getRolePingByName(roleName) {
+        const role = this.getRoleByName(roleName);
+        return role ? `<@&${role.id}>` : '';
+    }
+    async getRolePingsByName(roleNames) {
+        const pings = await Promise.all(roleNames.map((roleName) => this.getRolePingByName(roleName)));
+        return pings.join(' ');
+    }
+    async create_onMessageEventListener(handler) {
+        this.client.on('messageCreate', async (message) => {
+            await handler(await this.wrapMessage(message), 'discord');
+        });
+    }
+    create_onErrorEventListener(handler) {
+        this.client.on('error', (error) => {
+            handler(error);
+        });
+    }
+    async sendReport(message) {
+        return await this.sendMessageToChannelByName(this.config.reportChannelName, message);
+    }
+    async sendReportIn(message) {
+        return await this.sendMessageToChannelByName(this.config.reportChannelName, `${this.botDisplayName} report for duty! ` +
+            `(v${global_settings_const_1.DyNTS_global_settings.systemVersion} ${global_settings_const_1.DyNTS_global_settings.env_settings?.environment})`);
+    }
+    async wrapMessage(message) {
+        let replyTo = null;
+        if (message.reference?.messageId) {
+            replyTo = message.channel.messages.cache.get(message.reference.messageId);
+        }
+        return new bot_message_wrapper_interface_1.DyNTS_Bot_MessageWrapper({
+            id: message.id,
+            content: message.content,
+            authorId: message.author.id,
+            authorName: message.author.username,
+            authorDisplayName: message.author.displayName,
+            channelId: message.channel.id,
+            channelName: message.channel?.name || 'DM Channel with ' + message.channel.recipient.username,
+            timestamp: message.createdTimestamp,
+            isBot: message.author.bot,
+            isTextBased: message.channel.isTextBased(),
+            isVoiceBased: false, /* message.channel.isVoiceBased(), */
+            isDM: message.channel.isDMBased(),
+            mentions: Array.from(message.mentions.users.keys()),
+            replyToMessageId: message.reference?.messageId,
+            replyToMessageAuthorId: replyTo?.author?.id,
+            rawPlatformMessage: message,
+            issuer: message.author.id,
+            channel: await this.wrapChannel(message.channel),
+            /* user: this.wrapUser(message.author), */
+            provider: this,
+        });
+    }
+    async wrapChannel(channel) {
+        return new bot_channel_wrapper_interface_1.DyNTS_Bot_ChannelWrapper({
+            id: channel.id,
+            name: channel.name || ('DM Channel with ' + channel.recipient.username),
+            isTextBased: channel.isTextBased(),
+            isDM: channel.isDMBased(),
+            isVoiceBased: channel.isVoiceBased(),
+            rawPlatformChannel: channel,
+            provider: this,
+        });
+    }
+    async wrapUser(user) {
+        return new bot_user_wrapper_interface_1.DyNTS_Bot_UserWrapper({
+            id: user.user.id,
+            username: user.user.username,
+            displayName: user.displayName,
+            isBot: user.user.bot,
+            rawPlatformUser: user,
+            provider: this,
+        });
+    }
+}
+exports.DyNTS_DiB_MessagingProvider_ControlService = DyNTS_DiB_MessagingProvider_ControlService;
 //# sourceMappingURL=dib-messaging-provider.control-service.js.map