chz-telegram-bot 0.0.16 → 0.0.18

package/services/telegramApi.ts

@@ -1,33 +1,34 @@
-import { Telegraf } from 'telegraf';
-import { InputFile } from 'telegraf/types';
+import { InputFile, Message } from 'telegraf/types';
 import { ChatContext } from '../entities/context/chatContext';
 import { MessageContext } from '../entities/context/messageContext';
-import { ImageMessage } from '../entities/responses/imageMessage';
-import { TextMessage } from '../entities/responses/textMessage';
-import { VideoMessage } from '../entities/responses/videoMessage';
 import { reverseMap } from '../helpers/reverseMap';
-import { IReplyMessage } from '../types/replyMessage';
 import { IStorageClient } from '../types/storage';
 import { Milliseconds } from '../types/timeValues';
 import { Scheduler } from './taskScheduler';
 import { Logger } from './logger';
 import { Reaction } from '../entities/responses/reaction';
 import { IncomingMessage } from '../entities/incomingMessage';
+import { BotResponse, IReplyMessage } from '../types/response';
+import { UnpinResponse } from '../entities/responses/unpin';
+import { TextMessage } from '../entities/responses/textMessage';
+import { VideoMessage } from '../entities/responses/videoMessage';
+import { ImageMessage } from '../entities/responses/imageMessage';
+import { Telegram } from 'telegraf/typings/telegram';
 
 export class TelegramApiService {
     botName: string;
-    telegraf: Telegraf;
+    telegram: Telegram;
     chats: Map<number, string>;
-    messageQueue: Array<IReplyMessage<unknown> | Reaction> = [];
+    messageQueue: Array<BotResponse> = [];
     storage: IStorageClient;
 
     constructor(
         botName: string,
-        telegraf: Telegraf,
+        telegram: Telegram,
         storage: IStorageClient,
         chats: Map<string, number>
     ) {
-        this.telegraf = telegraf;
+        this.telegram = telegram;
         this.botName = botName;
         this.chats = reverseMap(chats);
         this.storage = storage;
@@ -51,38 +52,44 @@ export class TelegramApiService {
         try {
             await this.processResponse(message);
         } catch (error) {
+            console.dir(error);
             Logger.errorWithTraceId(
                 this.botName,
                 message.traceId,
                 this.chats.get(message.chatId)!,
-                error as string | Error,
+                error,
                 message
             );
         }
     }
 
-    private async processResponse<TType>(
-        response: IReplyMessage<TType> | Reaction
+    private async pinIfShould<T>(
+        response: IReplyMessage<T>,
+        sentMessage: Message
     ) {
-        if ('emoji' in response) {
-            this.telegraf.telegram.setMessageReaction(
+        if (response.shouldPin) {
+            await this.telegram.pinChatMessage(
                 response.chatId,
-                response.messageId,
-                [
-                    {
-                        type: 'emoji',
-                        emoji: response.emoji
-                    }
-                ],
-                true
+                sentMessage.message_id,
+                { disable_notification: true }
             );
 
-            return;
+            await this.storage.updateStateFor(
+                response.sourceActionKey,
+                response.chatId,
+                async (state) => {
+                    state.pinnedMessages.push(sentMessage.message_id);
+                }
+            );
         }
+    }
+
+    private async processResponse(response: BotResponse) {
+        let sentMessage: Message;
 
-        switch (response.constructor) {
-            case TextMessage:
-                await this.telegraf.telegram.sendMessage(
+        switch (response.kind) {
+            case 'text':
+                sentMessage = await this.telegram.sendMessage(
                     response.chatId,
                     response.content as string,
                     {
@@ -92,9 +99,11 @@ export class TelegramApiService {
                         // eslint-disable-next-line @typescript-eslint/no-explicit-any
                     } as any
                 );
+
+                await this.pinIfShould(response, sentMessage);
                 break;
-            case ImageMessage:
-                await this.telegraf.telegram.sendPhoto(
+            case 'image':
+                sentMessage = await this.telegram.sendPhoto(
                     response.chatId,
                     response.content as InputFile,
                     response.replyId
@@ -102,9 +111,11 @@ export class TelegramApiService {
                           ({ reply_to_message_id: response.replyId } as any)
                         : undefined
                 );
+
+                await this.pinIfShould(response, sentMessage);
                 break;
-            case VideoMessage:
-                await this.telegraf.telegram.sendVideo(
+            case 'video':
+                sentMessage = await this.telegram.sendVideo(
                     response.chatId,
                     response.content as InputFile,
                     response.replyId
@@ -112,35 +123,58 @@ export class TelegramApiService {
                           ({ reply_to_message_id: response.replyId } as any)
                         : undefined
                 );
+
+                await this.pinIfShould(response, sentMessage);
                 break;
-            default:
-                Logger.errorWithTraceId(
-                    this.botName,
-                    response.traceId,
-                    this.chats.get(response.chatId)!,
-                    `Unknown message type: ${response.constructor}`,
-                    response
+            case 'react':
+                await this.telegram.setMessageReaction(
+                    response.chatId,
+                    response.messageId,
+                    [
+                        {
+                            type: 'emoji',
+                            emoji: response.emoji
+                        }
+                    ],
+                    true
+                );
+
+                return;
+            case 'unpin':
+                await this.telegram.unpinChatMessage(
+                    response.chatId,
+                    response.messageId
+                );
+
+                await this.storage.updateStateFor(
+                    response.sourceActionKey,
+                    response.chatId,
+                    async (state) => {
+                        state.pinnedMessages = state.pinnedMessages.filter(
+                            (x) => x != response.messageId
+                        );
+                    }
                 );
                 break;
         }
     }
 
-    private enqueueResponse<TType>(response: IReplyMessage<TType>) {
-        this.messageQueue.push(response);
-    }
-
-    private enqueueReaction(reaction: Reaction) {
+    private enqueue(reaction: BotResponse) {
         this.messageQueue.push(reaction);
     }
 
     private getInteractions() {
         return {
-            react: (reaction) => this.enqueueReaction(reaction),
-            respond: (response) => this.enqueueResponse(response)
+            react: (reaction) => this.enqueue(reaction),
+            respond: (response) => this.enqueue(response),
+            unpin: (unpinMessage) => this.enqueue(unpinMessage)
         } as IBotApiInteractions;
     }
 
-    createContextForMessage(incomingMessage: IncomingMessage) {
+    createContextForMessage(
+        incomingMessage: IncomingMessage,
+        commandKey: string
+    ) {
         const firstName = incomingMessage.from?.first_name ?? 'Unknown user';
         const lastName = incomingMessage.from?.last_name
             ? ` ${incomingMessage.from?.last_name}`
@@ -148,6 +182,7 @@ export class TelegramApiService {
 
         return new MessageContext(
             this.botName,
+            commandKey,
             this.getInteractions(),
             incomingMessage.chat.id,
             incomingMessage.chatName,
@@ -160,19 +195,21 @@ export class TelegramApiService {
         );
     }
 
-    createContextForChat(chatId: number, scheduledName: string) {
+    createContextForChat(chatId: number, scheduledKey: string) {
         return new ChatContext(
             this.botName,
+            scheduledKey,
             this.getInteractions(),
             chatId,
             this.chats.get(chatId)!,
-            `Scheduled:${scheduledName}:${chatId}`,
+            `Scheduled:${scheduledKey}:${chatId}`,
             this.storage
         );
     }
 }
 
 export interface IBotApiInteractions {
-    respond: <TType>(response: IReplyMessage<TType>) => void;
+    respond: (response: TextMessage | VideoMessage | ImageMessage) => void;
     react: (reaction: Reaction) => void;
+    unpin: (unpinMessage: UnpinResponse) => void;
 }

package/types/actionState.ts

@@ -1,3 +1,4 @@
 export interface IActionState {
     lastExecutedDate: number;
+    pinnedMessages: number[];
 }

package/types/response.ts

@@ -0,0 +1,34 @@
+import { ImageMessage } from '../entities/responses/imageMessage';
+import { Reaction } from '../entities/responses/reaction';
+import { TextMessage } from '../entities/responses/textMessage';
+import { UnpinResponse } from '../entities/responses/unpin';
+import { VideoMessage } from '../entities/responses/videoMessage';
+
+export const BotResponseTypes = {
+    unpin: 'unpin',
+    text: 'text',
+    image: 'image',
+    video: 'video',
+    react: 'react'
+} as const;
+
+export type BotResponse =
+    | UnpinResponse
+    | Reaction
+    | TextMessage
+    | VideoMessage
+    | ImageMessage;
+
+export interface IChatResponse {
+    kind: keyof typeof BotResponseTypes;
+    chatId: number;
+    traceId: number | string;
+    sourceActionKey: string;
+}
+
+export interface IReplyMessage<TType> extends IChatResponse {
+    content: TType;
+    replyId: number | undefined;
+    disableWebPreview: boolean;
+    shouldPin: boolean;
+}

package/types/storage.ts

@@ -3,6 +3,11 @@ import { IActionState } from './actionState';
 import { IActionWithState } from './actionWithState';
 
 export interface IStorageClient {
+    updateStateFor<TActionState extends IActionState>(
+        sourceActionKey: string,
+        chatId: number,
+        update: (state: TActionState) => Promise<void>
+    ): Promise<void>;
     close(): Promise<void>;
     load<TActionState extends IActionState>(
         key: string

package/types/replyMessage.ts

@@ -1,7 +0,0 @@
-export interface IReplyMessage<TType> {
-    content: TType;
-    chatId: number;
-    replyId: number | undefined;
-    traceId: number | string;
-    disableWebPreview: boolean;
-}