A simple version of a web UI for bot thread content.

apps/bot/src/client.ts

@@ -31,6 +31,7 @@ export class MistSapphireClient extends SapphireClient {
     this.stores.registerPath(join(this.rootData.root, "modules/debug"));
     this.stores.registerPath(join(this.rootData.root, "modules/managed-roles"));
     this.stores.registerPath(join(this.rootData.root, "modules/tickets"));
+    this.stores.registerPath(join(this.rootData.root, "modules/content"));
   }
 
   public override async login(token?: string) {

apps/bot/src/modules/boards/listeners/thread-create.ts

@@ -34,6 +34,8 @@ export class BoardsThreadCreateListener extends Listener<"threadCreate"> {
       "Channel is not a board channel"
     );
 
+
+
     const status = config.tags.find(
       (tag) =>
         tag.isStatus &&

apps/bot/src/modules/content/functions/config.ts

@@ -0,0 +1,18 @@
+import { container } from "@sapphire/pieces";
+
+
+
+// obecne obslugiwany jest tylko jeden kanał
+export async function getChannelWithEnabledContentFetching() {
+  const config = await container.db.contentChannelConfig.findFirst({
+    where: {
+      enabled: true,
+    },
+    select: {
+    channelId: true,
+    },
+  });
+
+  return config
+
+}

apps/bot/src/modules/content/functions/deleteAllAttachments.ts

@@ -0,0 +1,15 @@
+import { container } from "@sapphire/pieces";
+import type { Message } from "discord.js";
+
+export async function deleteAllAttachments(message: Message) {
+  try {
+    await container.db.contentCommentAttachment.deleteMany({
+      where: {
+        commentId: BigInt(message.id),
+      },
+    });
+    console.log('Wszystkie załączniki dla komentarza usunięte.');
+  } catch (error) {
+    console.error('Błąd podczas usuwania załączników:', error);
+  }
+}

apps/bot/src/modules/content/functions/deleteAllReactions.ts

@@ -0,0 +1,18 @@
+import { container } from '@sapphire/pieces';
+import type { Message } from 'discord.js';
+
+export async function deleteAllReactions(message: Message) {
+  const messageId = BigInt(message.id); 
+
+  try {
+    await container.db.contentCommentReactions.deleteMany({
+      where: {
+        commentId: messageId,
+      },
+    });
+
+    console.log(`Wszystkie reakcje dla wiadomości o ID ${message.id} zostały usunięte.`);
+  } catch (error) {
+    console.error('Błąd podczas usuwania reakcji:', error);
+  }
+}

apps/bot/src/modules/content/functions/deleteAllThreadTags.ts

@@ -0,0 +1,16 @@
+// deleteAllThreadTags.ts
+import { container } from "@sapphire/pieces";
+
+
+export async function deleteAllThreadTags(threadId: bigint): Promise<void> {
+  try {
+    await container.db.threadTag.deleteMany({
+      where: {
+        threadId: threadId,
+      },
+    });
+    console.log(`Usunięto wszystkie tagi dla wątku ID: ${threadId}`);
+  } catch (error) {
+    console.error(`Błąd podczas usuwania tagów dla wątku ID: ${threadId}:`, error);
+  }
+}

apps/bot/src/modules/content/functions/getThreadAuthorUsername.ts

@@ -0,0 +1,26 @@
+import type { ThreadChannel } from "discord.js";
+
+
+
+export async function getThreadAuthorUsername(thread: ThreadChannel): Promise<string | null> {
+
+  if (!thread.ownerId) {
+    console.error("Wątek nie ma przypisanego właściciela (ownerId).");
+    return null;
+  }
+
+  try {
+
+    const owner = thread.client.users.cache.get(thread.ownerId);
+
+    if (owner) {
+      return owner.username;
+    }
+
+      const fetchedOwner = await thread.client.users.fetch(thread.ownerId);
+      return fetchedOwner.username;
+  } catch (error) {
+    console.error("Błąd podczas pobierania autora wątku:", error);
+    return null;
+  }
+}

apps/bot/src/modules/content/functions/upsertAttachment.ts

@@ -0,0 +1,27 @@
+import { container } from "@sapphire/pieces";
+import type { Attachment, Message } from "discord.js";
+
+export async function upsertAttachment(attachment: Attachment, message: Message) {
+  try {
+    await container.db.contentCommentAttachment.upsert({
+      where: { id: BigInt(attachment.id) },
+      update: {
+        commentId: BigInt(message.id),
+        url: attachment.url,
+        filename: attachment.name,
+        updatedAt: new Date(),
+      },
+      create: {
+        id: BigInt(attachment.id),
+        commentId: BigInt(message.id),
+        url: attachment.url,
+        filename: attachment.name,
+        createdAt: new Date(),
+        updatedAt: new Date(),
+      },
+    });
+    console.log('Załącznik upsertowany:');
+  } catch (error) {
+    console.error('Błąd podczas upsertowania załącznika:', error);
+  }
+}

apps/bot/src/modules/content/functions/upsertComment.ts

@@ -0,0 +1,34 @@
+import { container } from "@sapphire/pieces";
+import type { Message, ThreadChannel } from "discord.js";
+//import { getThreadAuthorUsername } from "./getThreadAuthorUsername.js";
+
+export async function upsertComment(message: Message, thread: ThreadChannel) {
+
+  const author = message.author.username;
+
+  if (!author) {
+    throw new Error("Wątek nie ma przypisanego właściciela (ownerId) lub ten nie znajduje się w cache.");
+  }
+
+  try {
+    await container.db.contentComments.upsert({
+      where: { id: BigInt(message.id) },
+      update: {
+        content: message.content,
+        author,
+        updatedAt: new Date(),
+      },
+      create: {
+        id: BigInt(message.id),
+        threadId: BigInt(thread.id),
+        content: message.content,
+        author,
+        createdAt: message.createdAt ?? new Date(),
+        updatedAt: new Date(),
+      },
+    });
+    console.log('Wątek upsertowany:');
+  } catch (error) {
+    console.error('Błąd podczas upsertowania wątku', error);
+  }
+}

apps/bot/src/modules/content/functions/upsertReactions.ts

@@ -0,0 +1,57 @@
+import { container } from '@sapphire/pieces';
+import type { MessageReaction, User, ThreadChannel } from 'discord.js';
+
+export async function upsertReaction(
+  reaction: MessageReaction,
+  user: User,
+  thread: ThreadChannel,
+  action: 'add' | 'remove'
+) {
+  const message = reaction.message;
+  const emoji = reaction.emoji.identifier; 
+
+  if (!emoji) {
+    console.error('Nie udało się uzyskać identyfikatora emoji.');
+    return;
+  }
+
+  try {
+
+
+    if (action === 'add') {
+      await container.db.contentCommentReactions.upsert({
+        where: {     
+            commentId_emoji_userId: {
+                commentId: BigInt(message.id),
+                emoji,
+                userId: BigInt(user.id),
+            },
+        },
+        update: {
+          updatedAt: new Date(),
+        },
+        create: {
+          commentId: BigInt(message.id),
+          emoji,
+          userId: BigInt(user.id),
+          createdAt: new Date(),
+          updatedAt: new Date(),
+        },
+      });
+      console.log('Reakcja dodana do bazy danych.');
+    } else if (action === 'remove') {
+      await container.db.contentCommentReactions.delete({
+        where: {      
+            commentId_emoji_userId: {
+                commentId: BigInt(message.id),
+                emoji,
+                userId: BigInt(user.id),
+            },
+        },
+      });
+      console.log('Reakcja usunięta z bazy danych.');
+    }
+  } catch (error) {
+    console.error('Błąd podczas upsertowania reakcji', error);
+  }
+}

apps/bot/src/modules/content/functions/upsertTag.ts

@@ -0,0 +1,35 @@
+// upsertTag.ts
+import { container } from "@sapphire/pieces";
+import type { GuildForumTag } from "discord.js";
+import { assert } from "../../../utils/assert.js";
+
+interface UpsertTagParams {
+  tag: GuildForumTag;
+  channelId: bigint;
+}
+
+export async function upsertTag({ tag, channelId }: UpsertTagParams) {
+  try {
+    await container.db.contentTag.upsert({
+      where: {
+        id: tag.id, 
+      },
+      update: {
+        name: tag.name,
+        emoji: tag.emoji ? tag.emoji.name : null,
+        updatedAt: new Date(),
+      },
+      create: {
+        id: tag.id,
+        channelId: channelId,
+        name: tag.name,
+        emoji: tag.emoji ? tag.emoji.name : null,
+        createdAt: new Date(),
+        updatedAt: new Date(),
+      },
+    });
+    console.log(`Tag upsertowany: ${tag.name}`);
+  } catch (error) {
+    console.error(`Błąd podczas upsertowania tagu "${tag.name}":`, error);
+  }
+}

apps/bot/src/modules/content/functions/upsertTagsForThread.ts

@@ -0,0 +1,28 @@
+// upsertTagsForThread.ts
+import { container } from "@sapphire/pieces";
+
+interface AssignTagsToThreadParams {
+  threadId: bigint;
+  tagIds: string[];
+}
+
+
+export async function upsertTagsForThread({ threadId, tagIds }: AssignTagsToThreadParams): Promise<void> {
+  try {
+    const createThreadTags = tagIds.map((tagId) => ({
+      threadId: threadId,
+      tagId: tagId,
+    }));
+
+    if (createThreadTags.length > 0) {
+      await container.db.threadTag.createMany({
+        data: createThreadTags,
+      });
+      console.log(`Przypisano ${createThreadTags.length} tagi do wątku ID: ${threadId}`);
+    } else {
+      //console.log(`Nie przypisano żadnych tagów do wątku ID: ${threadId}`);
+    }
+  } catch (error) {
+    console.error(`Błąd podczas przypisywania tagów do wątku ID: ${threadId}:`, error);
+  }
+}

apps/bot/src/modules/content/functions/upsertThread.ts

@@ -0,0 +1,33 @@
+import { container } from "@sapphire/pieces";
+import type { ThreadChannel } from "discord.js";
+import { getThreadAuthorUsername } from "./getThreadAuthorUsername.js";
+
+export async function upsertThread(thread: ThreadChannel) {
+
+  const author = await getThreadAuthorUsername(thread);
+
+  if (!author) {
+    throw new Error("Wątek nie ma przypisanego właściciela (ownerId) lub ten nie znajduje się w cache.");
+  }
+
+  try {
+    await container.db.contentThreads.upsert({
+      where: { id: BigInt(thread.id) },
+      update: {
+        content: thread.name,
+        author,
+        updatedAt: new Date(),
+      },
+      create: {
+        id: BigInt(thread.id),
+        content: thread.name,
+        author,
+        createdAt: new Date(),
+        updatedAt: new Date(),
+      },
+    });
+    console.log(`Wątek upsertowany: ${thread.name}`);
+  } catch (error) {
+    console.error(`Błąd podczas upsertowania wątku "${thread.name}":`, error);
+  }
+}

apps/bot/src/modules/content/listeners/message-create.ts

@@ -0,0 +1,38 @@
+import { Listener } from '@sapphire/framework';
+import type { Message, ThreadChannel } from 'discord.js';
+import { getChannelWithEnabledContentFetching } from '../functions/config.js';
+import { upsertComment } from '../functions/upsertComment.js';
+
+export class MessageCreateListener extends Listener {
+  public constructor(context: Listener.Context, options: Listener.Options) {
+    super(context, {
+      ...options,
+      event: 'messageCreate',
+    });
+  }
+
+  public async run(message: Message) {
+    if (message.partial) await message.fetch();
+
+    if (!message.channel.isThread()) return;
+
+    const thread = message.channel as ThreadChannel;
+
+    const result = await getChannelWithEnabledContentFetching();
+
+    if (!result) {
+      console.error('Nie znaleziono konfiguracji kanału.');
+      return;
+    }
+
+    const channelId = result.channelId;
+
+    if (thread.parentId !== channelId.toString()){
+         return;
+    }
+
+    console.log('message was created', message.content);
+
+    await upsertComment(message, thread);
+  }
+}