90399588

Build Type

github

Committed by GitHub

Commit Message

Merge a875dee3c into d61a20b50

Pull Request Pull Request #93: Working on internationalization

Run Details

103 of 678 branches covered (15.19%)

Branch coverage included in aggregate %.

148 of 302 new or added lines in 36 files covered. (49.01%)

9 existing lines in 8 files now uncovered.

546 of 1122 relevant lines covered (48.66%)

1.17 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

23.53

/server/src/bots/telegram/services/registry/messageHandlerRegistry.ts

import { logger } from '../../../../utils/logger';
import { CallBackQueryHandlerWithCommandArgument } from '../../models';
import { getChatId } from '../../utils/chat';
import {
    getCountryByMessage,
    getCountryNameByFlag,
    isMessageCountryFlag,
} from '../../../../utils/featureHelpers/isMessageCountry';
import { showCountryResponse } from '../../botResponse/countryResponse';
import { Country } from '../../../../models/country.models';
import { getAvailableCountries } from '../../../../services/domain/covid19';
import { Answer } from '../../../../models/knowledgebase/answer.models';
import { fetchAnswer } from '../../../../services/api/api-knowledgebase';
import { assistantResponse } from '../../botResponse/assistantResponse';
import { noResponse } from '../../botResponse/noResponse';
import { LogCategory } from '../../../../models/constants';
import * as TelegramBot from 'node-telegram-bot-api';
import { getCountryNameFormat } from '../../../../services/domain/countries';
import { telegramUserService } from '../user';
import { DEFAULT_USER_SETTINGS, User } from '../../../../models/user.model';

export class MessageHandlerRegistry {
    private messageHandlers: {
        [regexp: string]: CallBackQueryHandlerWithCommandArgument;
    } = {};
    public singleParameterAfterCommands: Array<string> = [];

    constructor(private readonly bot: TelegramBot) {
        this.registerCallBackQuery();
    }

    public registerMessageHandler(
        regexps: Array<string>,
        callback: CallBackQueryHandlerWithCommandArgument
    ): MessageHandlerRegistry {
        const systemRegExps = regexps.map((regexp: string) =>
            regexp.toLocaleLowerCase()
        );

        this.singleParameterAfterCommands = [
            ...this.singleParameterAfterCommands,
            ...systemRegExps,
        ];

        systemRegExps.forEach(
            (regexp: string) => (this.messageHandlers[regexp] = callback)
        );
        return this;
    }

    public sendUserNotification(
        chatId: number,
        notification: string
    ): Promise<TelegramBot.Message> {
        return this.bot.sendMessage(chatId, notification);
    }

    public async runCommandHandler(
        message: TelegramBot.Message,
        ikCbData?: string
    ): Promise<TelegramBot.Message> {
        logger.log('info', message);
        const chatId: number = getChatId(message);
        const user: User | null =
            (await telegramUserService.getUser(chatId)) ??
            (await this.createAndAddUser(message, chatId));

        const runCheckupAgainstStr = (ikCbData
            ? ikCbData
            : message.text
        ).toLocaleLowerCase();
        const cbHandlers = this.messageHandlers;

        const suitableKeys: Array<string> = this.getSuitableCbHandlersKey(
            cbHandlers,
            runCheckupAgainstStr
        );

        if (suitableKeys.length === 0) {
            return this.tryDeduceUserCommand(message, chatId, user);
        }

        if (suitableKeys.length > 1) {
            logger.log(
                'info',
                `[INFO] (Might be an error) Several suitable keys for ${runCheckupAgainstStr}. \nKEYS:\n${suitableKeys.join(
                    ';\n'
                )}`,
                LogCategory.MoreThenOneAvailableResponse,
                chatId
            );
        }

        // This statement will invoke wrapper/wrappers
        // (withSingleParameterAfterCommand and/or withTwoArgumentsAfterCommand)
        // around original handler which is defined in telegram/index.ts file
        return cbHandlers[suitableKeys[0]]
            .call(this, {
                bot: this.bot,
                message,
                chatId,
                user,
                messageHandlerRegistry: this,
                commandParameter: ikCbData,
            })
            .then(async () => {
                /**
                 * This logic is for cases when we have some command from
                 * a user, although we didn't invoke it for any reason
                 * @example A user enters /start for the first time (this will **{{1}}**
                 * be executed in cbHandlers[suitableKeys[0]].call (line)
                 * thus he doesn't have setup anything yet. We want to offer
                 * him make language first, therefore we invoke
                 * /UserSettingsRegExps.Language (/language) script
                 * which will offer to choose language for user. However,
                 * after he makes such his decision we still want to execute  **{{1}}**
                 */
                const userBeforeExecutionCbHandler: User = user;
                /**
                 * We're checking userBeforeExecutionCbHandler because
                 * interruptedCommand should have been set up in the **{{1}}**
                 * However, on this cycle we do not want to show user info,
                 * because we just interrupted his command by our's. After he
                 * proceeds with our, it will be next cycle and we should then
                 * check.
                 */
                if (userBeforeExecutionCbHandler.state?.interruptedCommand) {
                    const upToDateUser: User = await telegramUserService.getUser(
                        user
                    );
                    /**
                     * Always update up-to-date user
                     */
                    await telegramUserService.setUserInterruptedCommand(
                        upToDateUser,
                        null
                    );
                    return this.runCommandHandler({
                        ...message,
                        text: upToDateUser.state.interruptedCommand,
                    });
                }
            });
    }

    private async tryDeduceUserCommand(
        message: TelegramBot.Message,
        chatId: number,
        user: User
    ): Promise<TelegramBot.Message> {
        if (isMessageCountryFlag(message.text)) {
            const countryName: string = getCountryNameByFlag(message.text);
            return showCountryResponse({
                bot: this.bot,
                message,
                chatId,
                user,
                commandParameter: countryName,
            });
        }

        const countries: Array<Country> = await getAvailableCountries();
        const country: Country | undefined = getCountryByMessage(
            getCountryNameFormat(message.text),
            countries
        );
        if (country) {
            return showCountryResponse({
                bot: this.bot,
                message,
                chatId,
                commandParameter: country.name,
                user,
            });
        }

        const answers: Array<Answer> = await fetchAnswer(message.text);
        if (answers?.length) {
            return assistantResponse(this.bot, answers, chatId, user);
        }

        return noResponse({
            bot: this.bot,
            message,
            chatId,
            user,
        });
    }

    private registerCallBackQuery() {
        this.bot.on('callback_query', ({ id, data, message, from }) => {
            this.bot
                .answerCallbackQuery(id, { text: `${data} in progress...` })
                .then(() => {
                    return this.runCommandHandler(
                        {
                            ...message,
                            from, // As in cases of answerCallbackQuery original from in message will be bot sender,
                            // But we do want it still to be user. Do we? :D
                        },
                        data
                    );
                });
        });
    }

    private getSuitableCbHandlersKey(
        cbHandlers: {
            [regexp: string]: CallBackQueryHandlerWithCommandArgument;
        },
        runCheckupAgainstStr: string
    ): Array<string> {
        return Object.keys(cbHandlers).filter(
            (cbHandlerRegExpKey: string) =>
                !!runCheckupAgainstStr.match(
                    new RegExp(cbHandlerRegExpKey, 'g')
                )
        );
    }

    private async createAndAddUser(
        message: TelegramBot.Message,
        chatId: number
    ): Promise<User> {
        return telegramUserService.addUser({
            ...DEFAULT_USER_SETTINGS,
            chatId,
            userName: message.chat?.username || '',
            firstName: message.chat?.first_name || '',
            lastName: message.chat?.last_name || '',
            startedOn: Date.now(),
        });
    }
}

1	import { logger } from '../../../../utils/logger';	2✔
2	import { CallBackQueryHandlerWithCommandArgument } from '../../models';
3	import { getChatId } from '../../utils/chat';	2✔
4	import {	2✔
5	getCountryByMessage,
6	getCountryNameByFlag,
7	isMessageCountryFlag,
8	} from '../../../../utils/featureHelpers/isMessageCountry';
9	import { showCountryResponse } from '../../botResponse/countryResponse';	2✔
10	import { Country } from '../../../../models/country.models';
11	import { getAvailableCountries } from '../../../../services/domain/covid19';	2✔
12	import { Answer } from '../../../../models/knowledgebase/answer.models';
13	import { fetchAnswer } from '../../../../services/api/api-knowledgebase';	2✔
14	import { assistantResponse } from '../../botResponse/assistantResponse';	2✔
15	import { noResponse } from '../../botResponse/noResponse';	2✔
16	import { LogCategory } from '../../../../models/constants';	2✔
17	import * as TelegramBot from 'node-telegram-bot-api';
18	import { getCountryNameFormat } from '../../../../services/domain/countries';	2✔
19	import { telegramUserService } from '../user';	2✔
20	import { DEFAULT_USER_SETTINGS, User } from '../../../../models/user.model';	2✔
21
22	export class MessageHandlerRegistry {	2✔
23	private messageHandlers: {	2✔
24	[regexp: string]: CallBackQueryHandlerWithCommandArgument;
25	} = {};
26	public singleParameterAfterCommands: Array<string> = [];	2✔
27
28	constructor(private readonly bot: TelegramBot) {	2✔
29	this.registerCallBackQuery();	2✔
30	}
31
32	public registerMessageHandler(
33	regexps: Array<string>,
34	callback: CallBackQueryHandlerWithCommandArgument
35	): MessageHandlerRegistry {
36	const systemRegExps = regexps.map((regexp: string) =>	20✔
37	regexp.toLocaleLowerCase()	36✔
38	);
39
40	this.singleParameterAfterCommands = [	20✔
41	...this.singleParameterAfterCommands,
42	...systemRegExps,
43	];
44
45	systemRegExps.forEach(	20✔
46	(regexp: string) => (this.messageHandlers[regexp] = callback)	36✔
47	);
48	return this;	20✔
49	}
50
51	public sendUserNotification(
52	chatId: number,
53	notification: string
54	): Promise<TelegramBot.Message> {
55	return this.bot.sendMessage(chatId, notification);	×
56	}
57
58	public async runCommandHandler(
59	message: TelegramBot.Message,
60	ikCbData?: string
61	): Promise<TelegramBot.Message> {
62	logger.log('info', message);	×
NEW 63	const chatId: number = getChatId(message);	×
NEW 64	const user: User \| null =	×
65	(await telegramUserService.getUser(chatId)) ??	×
66	(await this.createAndAddUser(message, chatId));
67
68	const runCheckupAgainstStr = (ikCbData	×
69	? ikCbData	×
70	: message.text
71	).toLocaleLowerCase();
72	const cbHandlers = this.messageHandlers;	×
73
NEW 74	const suitableKeys: Array<string> = this.getSuitableCbHandlersKey(	×
75	cbHandlers,
76	runCheckupAgainstStr
77	);
78
79	if (suitableKeys.length === 0) {	×
NEW 80	return this.tryDeduceUserCommand(message, chatId, user);	×
81	}
82
83	if (suitableKeys.length > 1) {	×
84	logger.log(	×
85	'info',
86	`[INFO] (Might be an error) Several suitable keys for ${runCheckupAgainstStr}. \nKEYS:\n${suitableKeys.join(
87	';\n'
88	)}`,
89	LogCategory.MoreThenOneAvailableResponse,
90	chatId
91	);
92	}
93
94	// This statement will invoke wrapper/wrappers
95	// (withSingleParameterAfterCommand and/or withTwoArgumentsAfterCommand)
96	// around original handler which is defined in telegram/index.ts file
NEW 97	return cbHandlers[suitableKeys[0]]	×
98	.call(this, {
99	bot: this.bot,
100	message,
101	chatId,
102	user,
103	messageHandlerRegistry: this,
104	commandParameter: ikCbData,
105	})
NEW 106	.then(async () => {	×
107	/**
108	* This logic is for cases when we have some command from
109	* a user, although we didn't invoke it for any reason
110	* @example A user enters /start for the first time (this will {{1}}
111	* be executed in cbHandlers[suitableKeys[0]].call (line)
112	* thus he doesn't have setup anything yet. We want to offer
113	* him make language first, therefore we invoke
114	* /UserSettingsRegExps.Language (/language) script
115	* which will offer to choose language for user. However,
116	* after he makes such his decision we still want to execute {{1}}
117	*/
NEW 118	const userBeforeExecutionCbHandler: User = user;	×
119	/**
120	* We're checking userBeforeExecutionCbHandler because
121	* interruptedCommand should have been set up in the {{1}}
122	* However, on this cycle we do not want to show user info,
123	* because we just interrupted his command by our's. After he
124	* proceeds with our, it will be next cycle and we should then
125	* check.
126	*/
NEW 127	if (userBeforeExecutionCbHandler.state?.interruptedCommand) {	×
NEW 128	const upToDateUser: User = await telegramUserService.getUser(	×
129	user
130	);
131	/**
132	* Always update up-to-date user
133	*/
NEW 134	await telegramUserService.setUserInterruptedCommand(	×
135	upToDateUser,
136	null
137	);
NEW 138	return this.runCommandHandler({	×
139	...message,
140	text: upToDateUser.state.interruptedCommand,
141	});
142	}
143	});
144	}
145
146	private async tryDeduceUserCommand(
147	message: TelegramBot.Message,
148	chatId: number,
149	user: User
150	): Promise<TelegramBot.Message> {
NEW 151	if (isMessageCountryFlag(message.text)) {	×
NEW 152	const countryName: string = getCountryNameByFlag(message.text);	×
NEW 153	return showCountryResponse({	×
154	bot: this.bot,
155	message,
156	chatId,
157	user,
158	commandParameter: countryName,
159	});
160	}
161
NEW 162	const countries: Array<Country> = await getAvailableCountries();	×
NEW 163	const country: Country \| undefined = getCountryByMessage(	×
164	getCountryNameFormat(message.text),
165	countries
166	);
NEW 167	if (country) {	×
NEW 168	return showCountryResponse({	×
169	bot: this.bot,
170	message,
171	chatId,
172	commandParameter: country.name,
173	user,
174	});
175	}
176
NEW 177	const answers: Array<Answer> = await fetchAnswer(message.text);	×
NEW 178	if (answers?.length) {	×
NEW 179	return assistantResponse(this.bot, answers, chatId, user);	×
180	}
181
NEW 182	return noResponse({	×
183	bot: this.bot,
184	message,
185	chatId,
186	user,
187	});
188	}
189
190	private registerCallBackQuery() {
191	this.bot.on('callback_query', ({ id, data, message, from }) => {	2✔
192	this.bot	×
193	.answerCallbackQuery(id, { text: `${data} in progress...` })
194	.then(() => {
195	return this.runCommandHandler(	×
196	{
197	...message,
198	from, // As in cases of answerCallbackQuery original from in message will be bot sender,
199	// But we do want it still to be user. Do we? :D
200	},
201	data
202	);
203	});
204	});
205	}
206
207	private getSuitableCbHandlersKey(
208	cbHandlers: {
209	[regexp: string]: CallBackQueryHandlerWithCommandArgument;
210	},
211	runCheckupAgainstStr: string
212	): Array<string> {
NEW 213	return Object.keys(cbHandlers).filter(	×
214	(cbHandlerRegExpKey: string) =>
NEW 215	!!runCheckupAgainstStr.match(	×
216	new RegExp(cbHandlerRegExpKey, 'g')
217	)
218	);
219	}
220
221	private async createAndAddUser(
222	message: TelegramBot.Message,
223	chatId: number
224	): Promise<User> {
NEW 225	return telegramUserService.addUser({	×
226	...DEFAULT_USER_SETTINGS,
227	chatId,
228	userName: message.chat?.username \|\| '',	×
229	firstName: message.chat?.first_name \|\| '',	×
230	lastName: message.chat?.last_name \|\| '',	×
231	startedOn: Date.now(),
232	});
233	}
234	}

danbilokha / covid19liveupdates / 90399588

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous