Basic Settings and Message Filtering

BadWordsApp.ts

@@ -1,12 +1,176 @@
 import {
     IAppAccessors,
+    IConfigurationExtend,
+    IConfigurationModify,
+    IEnvironmentRead,
+    IHttp,
     ILogger,
-} from '@rocket.chat/apps-engine/definition/accessors';
-import { App } from '@rocket.chat/apps-engine/definition/App';
-import { IAppInfo } from '@rocket.chat/apps-engine/definition/metadata';
+    IMessageBuilder,
+    IModify,
+    IPersistence,
+    IRead,
+} from "@rocket.chat/apps-engine/definition/accessors";
+import { App } from "@rocket.chat/apps-engine/definition/App";
+import {
+    IMessage,
+    IPreMessageSentModify,
+    IPreMessageSentPrevent,
+    IPreMessageUpdatedModify,
+} from "@rocket.chat/apps-engine/definition/messages";
+import { IAppInfo } from "@rocket.chat/apps-engine/definition/metadata";
+import { ISetting } from "@rocket.chat/apps-engine/definition/settings";
+import { BadWordsCommand } from "./commands/BadWordsCommand";
+import { Settings } from "./config/Settings";
+import { CheckPreMessageSentHandler } from "./handlers/CheckPreMessageSentHandler";
+import { OnSettingsUpdatedHandler } from "./handlers/OnSettingsUpdatedHandler";
+import { PreMessageSentHandler } from "./handlers/PreMessageSentHandler";
+import { getBlockedWords } from "./lib/Settings";
+import { PreMessageSentPreventHandler } from "./handlers/PreMessageSentPreventHandler";
+import {
+    IUIKitInteractionHandler,
+    IUIKitResponse,
+    UIKitBlockInteractionContext,
+} from "@rocket.chat/apps-engine/definition/uikit";
+import { BlockActionHandler } from "./handlers/BlockActionHandler";
 
-export class BadWordsApp extends App {
+export class BadWordsApp
+    extends App
+    implements
+        IPreMessageSentModify,
+        IPreMessageUpdatedModify,
+        IPreMessageSentPrevent,
+        IUIKitInteractionHandler
+{
     constructor(info: IAppInfo, logger: ILogger, accessors: IAppAccessors) {
         super(info, logger, accessors);
     }
+    public blockedWords: Array<string>;
+
+    async executePreMessageSentPrevent(
+        message: IMessage,
+        read: IRead
+    ): Promise<boolean> {
+        const preMessageSentPreventHandler = new PreMessageSentPreventHandler(
+            message,
+            read
+        );
+        return preMessageSentPreventHandler.run();
+    }
+
+    async checkPreMessageSentModify(
+        message: IMessage,
+        read: IRead,
+        http: IHttp
+    ): Promise<boolean> {
+        const checkPreMessageSentHandler = new CheckPreMessageSentHandler(
+            this,
+            message,
+            read,
+            http,
+            this.blockedWords
+        );
+        return checkPreMessageSentHandler.check();
+    }
+
+    async executePreMessageSentModify(
+        message: IMessage,
+        builder: IMessageBuilder,
+        read: IRead,
+        http: IHttp,
+        persist: IPersistence
+    ): Promise<IMessage> {
+        const preMessageSentHandler = new PreMessageSentHandler(
+            this,
+            message,
+            builder,
+            read,
+            http,
+            persist,
+            this.blockedWords
+        );
+        return preMessageSentHandler.run();
+    }
+
+    async checkPreMessageUpdatedModify(
+        message: IMessage,
+        read: IRead,
+        http: IHttp
+    ): Promise<boolean> {
+        const checkPreMessageUpdatedHandler = new CheckPreMessageSentHandler(
+            this,
+            message,
+            read,
+            http,
+            this.blockedWords
+        );
+        return checkPreMessageUpdatedHandler.check();
+    }
+
+    async executePreMessageUpdatedModify(
+        message: IMessage,
+        builder: IMessageBuilder,
+        read: IRead,
+        http: IHttp,
+        persist: IPersistence
+    ): Promise<IMessage> {
+        const preMessageUpdatedHandler = new PreMessageSentHandler(
+            this,
+            message,
+            builder,
+            read,
+            http,
+            persist,
+            this.blockedWords
+        );
+        return preMessageUpdatedHandler.run();
+    }
+
+    async executeBlockActionHandler(
+        context: UIKitBlockInteractionContext,
+        read: IRead,
+        http: IHttp,
+        persist: IPersistence,
+        modify: IModify
+    ): Promise<IUIKitResponse> {
+        const blockActionHandler = new BlockActionHandler(
+            context,
+            read,
+            persist
+        );
+        return blockActionHandler.run();
+    }
+
+    public async onSettingUpdated(
+        setting: ISetting,
+        configurationModify: IConfigurationModify,
+        read: IRead,
+        http: IHttp
+    ): Promise<void> {
+        const settingsUpdated = new OnSettingsUpdatedHandler(
+            this,
+            setting,
+            configurationModify,
+            read,
+            http
+        );
+        this.blockedWords = await settingsUpdated.run();
+    }
+
+    protected async extendConfiguration(
+        configuration: IConfigurationExtend,
+        environmentRead: IEnvironmentRead
+    ): Promise<void> {
+        await Promise.all(
+            Settings.map((setting) =>
+                configuration.settings.provideSetting(setting)
+            )
+        );
+        await configuration.slashCommands.provideSlashCommand(
+            new BadWordsCommand()
+        );
+        this.blockedWords = await getBlockedWords(
+            environmentRead,
+            this.getAccessors().http
+        );
+    }
 }

app.json

@@ -1,7 +1,7 @@
 {
     "id": "925a2e1e-d239-4ab8-a583-57203a8c3754",
     "version": "0.0.1",
-    "requiredApiVersion": "^1.4.0",
+    "requiredApiVersion": "^1.19.0",
     "iconFile": "icon.png",
     "author": {
         "name": "Rocket.Chat",
@@ -11,5 +11,11 @@
     "name": "BadWords",
     "nameSlug": "badwords",
     "classFile": "BadWordsApp.ts",
-    "description": "A simple app to block badwords and apply moderation policies in channels"
+    "description": "A simple app to block badwords and apply moderation policies in channels",
+    "implements": [
+        "IPreMessageSentModify",
+        "IPreMessageUpdatedModify",
+        "IPreMessageSentPrevent",
+        "IUIKitInteractionHandler"
+    ]
 }

commands/BadWordsCommand.ts

@@ -0,0 +1,173 @@
+import {
+    IHttp,
+    IModify,
+    IPersistence,
+    IRead,
+} from "@rocket.chat/apps-engine/definition/accessors";
+import {
+    ISlashCommand,
+    SlashCommandContext,
+} from "@rocket.chat/apps-engine/definition/slashcommands";
+import { sendNotifyMessage } from "../lib/sendNotifyMessage";
+import { showModal } from "../lib/showModal";
+import { banUser, clearStats, unBanUser } from "../lib/storeStats";
+
+export class BadWordsCommand implements ISlashCommand {
+    public command = "bad-words";
+    public i18nParamsExample = "example params";
+    public i18nDescription = "command description";
+    public providesPreview = false;
+
+    public async executor(
+        context: SlashCommandContext,
+        read: IRead,
+        modify: IModify,
+        http: IHttp,
+        persis: IPersistence
+    ): Promise<void> {
+        const triggerId = context.getTriggerId();
+        const room = context.getRoom();
+        const sender = context.getSender();
+        const threadId = context.getThreadId();
+
+        if (sender.roles.includes("admin") || sender.roles.includes("owner")) {
+            const args = context.getArguments();
+            console.log("the args are = ", args);
+            switch (args[0]) {
+                case "stats": {
+                    if (triggerId) {
+                        const modal = await showModal(room, read, modify);
+                        await modify
+                            .getUiController()
+                            .openModalView(modal, { triggerId }, sender);
+                    } else {
+                        sendNotifyMessage(
+                            room,
+                            sender,
+                            threadId,
+                            modify.getNotifier(),
+                            "Something went wrong!!"
+                        );
+                    }
+                    break;
+                }
+
+                case "clear": {
+                    if (args[1]) {
+                        const username = args[1];
+                        const user = await read
+                            .getUserReader()
+                            .getByUsername(username);
+                        if (user) {
+                            clearStats(room.id, user.id, persis, read);
+                            sendNotifyMessage(
+                                room,
+                                sender,
+                                threadId,
+                                modify.getNotifier(),
+                                `*${user.username}'s* record has been cleared`
+                            );
+                        } else {
+                            sendNotifyMessage(
+                                room,
+                                sender,
+                                threadId,
+                                modify.getNotifier(),
+                                "User not found! Please enter a valid username."
+                            );
+                        }
+                    } else {
+                        sendNotifyMessage(
+                            room,
+                            sender,
+                            threadId,
+                            modify.getNotifier(),
+                            "Please provide a username after clear keyword!"
+                        );
+                    }
+                    break;
+                }
+
+                case "ban": {
+                    if (args[1]) {
+                        const username = args[1];
+                        const user = await read
+                            .getUserReader()
+                            .getByUsername(username);
+                        if (user) {
+                            banUser(room.id, user.id, persis, read);
+                            sendNotifyMessage(
+                                room,
+                                sender,
+                                threadId,
+                                modify.getNotifier(),
+                                `*${user.username}* has been banned from this room!`
+                            );
+                        } else {
+                            sendNotifyMessage(
+                                room,
+                                sender,
+                                threadId,
+                                modify.getNotifier(),
+                                "User not found! Please enter a valid username."
+                            );
+                        }
+                    } else {
+                        sendNotifyMessage(
+                            room,
+                            sender,
+                            threadId,
+                            modify.getNotifier(),
+                            "Please provide a username after ban keyword!"
+                        );
+                    }
+                    break;
+                }
+
+                case "unban": {
+                    if (args[1]) {
+                        const username = args[1];
+                        const user = await read
+                            .getUserReader()
+                            .getByUsername(username);
+                        if (user) {
+                            unBanUser(room.id, user.id, persis, read);
+                            sendNotifyMessage(
+                                room,
+                                sender,
+                                threadId,
+                                modify.getNotifier(),
+                                `*${user.username}* has been un-banned from this room!`
+                            );
+                        } else {
+                            sendNotifyMessage(
+                                room,
+                                sender,
+                                threadId,
+                                modify.getNotifier(),
+                                "User not found! Please enter a valid username."
+                            );
+                        }
+                    } else {
+                        sendNotifyMessage(
+                            room,
+                            sender,
+                            threadId,
+                            modify.getNotifier(),
+                            "Please provide a username after unban keyword!"
+                        );
+                    }
+                    break;
+                }
+            }
+        } else {
+            sendNotifyMessage(
+                room,
+                sender,
+                threadId,
+                modify.getNotifier(),
+                "This slash command can be only used by admins and owners"
+            );
+        }
+    }
+}