Merge be540d2 into 9bb6532

server/src/bots/telegram/botResponse/availableResponse.ts

@@ -10,7 +10,11 @@ import * as TelegramBot from 'node-telegram-bot-api';
 export const showAvailableCountriesResponse: CallBackQueryHandlerWithCommandArgument = async ({
     bot,
     chatId,
+    user,
 }: CallBackQueryParameters): Promise<TelegramBot.Message> => {
     const countries: Array<Country> = await getAvailableCountries();
-    return bot.sendMessage(chatId, getShowCountriesMessage(countries));
+    return bot.sendMessage(
+        chatId,
+        getShowCountriesMessage(user.settings?.locale, countries)
+    );
 };

server/src/bots/telegram/botResponse/countriesResponse.ts

@@ -1,14 +1,20 @@
 import {
+    CountryActiveSituationInfo,
     CountrySituationInfo,
     WorldOverallInformation,
 } from '../../../models/covid19.models';
 import {
+    getCountriesForContinentMessage,
     getCountriesTableHTMLMessage,
     getCountriesWorldMessage,
     getTableCountryRowMessage,
     getTableHeader,
 } from '../../../messages/feature/countriesMessages';
-import { getContinentsInlineKeyboard } from '../services/keyboard';
+import {
+    getContinentCountriesCheckOutOfferMessageInlineKeyboard,
+    getContinentsInlineKeyboard,
+    getCountriesInlineKeyboard,
+} from '../services/keyboard';
 import {
     CallBackQueryHandlerWithCommandArgument,
     CallBackQueryParameters,
@@ -17,8 +23,32 @@ import {
     getContinentOverallInformation,
     getWorldOverallInformation,
 } from '../../../services/domain/countries';
+import * as TelegramBot from 'node-telegram-bot-api';
+import { Continents } from '../../../models/constants';
+import { isTextEqual } from '../../../utils/isEqual';
 
-export const countriesByContinentResponse = (continent) => async ({
+export const countriesForContinentResponse = async ({
+    bot,
+    user,
+    chatId,
+    commandParameter,
+}: CallBackQueryParameters): Promise<TelegramBot.Message> => {
+    const { countriesSituation } = await getContinentOverallInformation(
+        commandParameter
+    );
+
+    const sortedCountriesSituation: Array<CountryActiveSituationInfo> = countriesSituation.sort(
+        (country1, country2) => country2.active - country1.active
+    );
+
+    return bot.sendMessage(
+        chatId,
+        getCountriesForContinentMessage(user.settings?.locale),
+        getCountriesInlineKeyboard(sortedCountriesSituation)
+    );
+};
+
+export const countriesTableByContinentResponse = (continent: string) => async ({
     bot,
     user,
     chatId,
@@ -33,13 +63,15 @@ export const countriesByContinentResponse = (continent) => async ({
     const portionMessage = [getTableHeader(user.settings?.locale)];
     portionMessage.push();
 
-    countriesSituation
-        .sort((country1, country2) => country2.active - country1.active)
-        .forEach(({ name, active, recovered, deaths }) =>
-            portionMessage.push(
-                getTableCountryRowMessage(name, active, recovered, deaths)
-            )
-        );
+    const sortedCountriesSituation: Array<CountryActiveSituationInfo> = countriesSituation.sort(
+        (country1, country2) => country2.active - country1.active
+    );
+
+    sortedCountriesSituation.forEach(({ name, active, recovered, deaths }) =>
+        portionMessage.push(
+            getTableCountryRowMessage(name, active, recovered, deaths)
+        )
+    );
 
     return bot.sendMessage(
         chatId,
@@ -52,15 +84,40 @@ export const countriesByContinentResponse = (continent) => async ({
             countriesSituation,
             portionMessage
         ),
-        { parse_mode: 'HTML' }
+        {
+            parse_mode: 'HTML',
+            reply_markup: {
+                inline_keyboard: getContinentCountriesCheckOutOfferMessageInlineKeyboard(
+                    user.settings?.locale,
+                    continent
+                ),
+            },
+        }
     );
 };
 
-export const countriesResponse: CallBackQueryHandlerWithCommandArgument = async ({
+export const worldByContinentOverallResponse: CallBackQueryHandlerWithCommandArgument = async ({
     bot,
     user,
     chatId,
+    message,
+    commandParameter,
 }: CallBackQueryParameters) => {
+    if (
+        !!commandParameter &&
+        Object.keys(Continents).some((continent) =>
+            isTextEqual(continent, commandParameter)
+        )
+    ) {
+        return countriesForContinentResponse({
+            bot,
+            user,
+            chatId,
+            message,
+            commandParameter,
+        });
+    }
+
     const {
         confirmed,
         recovered,

server/src/bots/telegram/botResponse/helpResponse.ts

@@ -4,7 +4,7 @@ import {
     CallBackQueryParameters,
 } from '../models';
 import * as TelegramBot from 'node-telegram-bot-api';
-import { getFullMenuKeyboard } from '../services/keyboard';
+import { getFullClickableFeaturesInlineKeyBoard } from '../services/keyboard';
 
 export const helpInfoResponse: CallBackQueryHandlerWithCommandArgument = async ({
     bot,
@@ -13,7 +13,7 @@ export const helpInfoResponse: CallBackQueryHandlerWithCommandArgument = async (
 }: CallBackQueryParameters): Promise<TelegramBot.Message> => {
     return bot.sendMessage(
         chatId,
-        getHelpMessage(),
-        getFullMenuKeyboard(chatId, user.settings?.locale)
+        getHelpMessage(user.settings?.locale),
+        getFullClickableFeaturesInlineKeyBoard(user.settings?.locale)
     );
 };

server/src/bots/telegram/botResponse/settingsResponse.ts

@@ -1,4 +1,7 @@
-import { getLocalizationInlineKeyboard } from '../services/keyboard';
+import {
+    getFullMenuKeyboard,
+    getLocalizationInlineKeyboard,
+} from '../services/keyboard';
 import {
     CallBackQueryHandlerWithCommandArgument,
     CallBackQueryParameters,
@@ -68,6 +71,7 @@ export const settingsLanguageResponse: CallBackQueryHandlerWithCommandArgument =
         // We cannot use "User" from parameter in the bot.sendMessage(
         // because that "User" still have an old locale, while this
         // "resultUser" has updated user settings
-        languageHasBeenSuccessfullySetup(updatedUser.settings.locale)
+        languageHasBeenSuccessfullySetup(updatedUser.settings.locale),
+        getFullMenuKeyboard(chatId, updatedUser.settings?.locale)
     );
 };

server/src/bots/telegram/botResponse/startResponse.ts

@@ -1,4 +1,4 @@
-import { getHelpProposalInlineKeyboard } from '../services/keyboard';
+import { getFullMenuKeyboard } from '../services/keyboard';
 import { greetUser } from '../../../messages/userMessage';
 import {
     CallBackQueryHandlerWithCommandArgument,
@@ -30,6 +30,6 @@ export const startResponse: CallBackQueryHandlerWithCommandArgument = async ({
     return bot.sendMessage(
         chatId,
         greetUser(locale, user),
-        getHelpProposalInlineKeyboard(locale)
+        getFullMenuKeyboard(chatId, locale)
     );
 };

server/src/bots/telegram/botResponse/trendResponse.ts

@@ -64,10 +64,10 @@ export const trendsByCountryResponse: CallBackQueryHandlerWithCommandArgument =
 
     let model = enrichWithTitle(
         Transform(periodSituation),
-        getLocalizedMessages(user.settings.locale, frequencyName) +
-            getLocalizedMessages(user.settings.locale, 'trends for') +
+        getLocalizedMessages(user.settings?.locale, frequencyName) +
+            getLocalizedMessages(user.settings?.locale, 'trends for') +
             capitalize(
-                getLocalizedMessages(user.settings.locale, requestedCountry)
+                getLocalizedMessages(user.settings?.locale, requestedCountry)
             )
     );
     if (frequency === Frequency.Weekly) {

server/src/bots/telegram/index.ts

@@ -1,6 +1,6 @@
 import {
-    countriesByContinentResponse,
-    countriesResponse,
+    countriesTableByContinentResponse,
+    worldByContinentOverallResponse,
 } from './botResponse/countriesResponse';
 import {
     showCountryByFlag,
@@ -81,7 +81,7 @@ export async function runTelegramBot(
             ],
             withSingleParameterAfterCommand(
                 messageHandlerRegistry,
-                countriesResponse
+                worldByContinentOverallResponse
             )
         )
         .registerMessageHandler(
@@ -184,7 +184,10 @@ export async function runTelegramBot(
         )
         // Settings
         .registerMessageHandler(
-            [UserSettingsRegExps.Language],
+            [
+                ...localizeOnLocales(availableLanguages, UserMessages.Language),
+                UserSettingsRegExps.Language,
+            ],
             withSingleParameterAfterCommand(
                 messageHandlerRegistry,
                 settingsLanguageResponse
@@ -200,7 +203,7 @@ export async function runTelegramBot(
     for (const continent of Object.keys(Continents)) {
         messageHandlerRegistry.registerMessageHandler(
             [continent],
-            countriesByContinentResponse(continent)
+            countriesTableByContinentResponse(continent)
         );
     }
     getAvailableCountries().then((countries: Array<Country>) => {

server/src/bots/telegram/models/index.ts

@@ -20,4 +20,5 @@ export type CallBackQueryHandlerWithCommandArgument<
 > = (parameters: P) => Promise<T>;
 
 export const TELEGRAM_PREFIX: string = 'telegram';
+export const COUNTRIES_ROW_ITEMS_NUMBER: number = 4;
 export const UNSUBSCRIPTIONS_ROW_ITEMS_NUMBER: number = 3;

server/src/bots/telegram/services/keyboard.ts

@@ -11,9 +11,14 @@ import {
     UserSettingsRegExps,
 } from '../../../models/constants';
 import { InlineKeyboard, ReplyKeyboard } from 'node-telegram-keyboard-wrapper';
-import { UNSUBSCRIPTIONS_ROW_ITEMS_NUMBER } from '../models';
+import {
+    COUNTRIES_ROW_ITEMS_NUMBER,
+    UNSUBSCRIPTIONS_ROW_ITEMS_NUMBER,
+} from '../models';
 import * as TelegramBot from 'node-telegram-bot-api';
 import { getLocalizedMessages } from '../../../services/domain/localization.service';
+import { Country } from '../../../models/country.models';
+import { flag } from 'country-emoji';
 
 export const getFullMenuKeyboard = (
     chatId: number,
@@ -30,14 +35,14 @@ export const getFullMenuKeyboard = (
 
     rk.addRow(
         getLocalizedMessages(locale, UserMessages.CountriesData),
-        getLocalizedMessages(locale, UserMessages.AvailableCountries)
+        getLocalizedMessages(locale, UserMessages.SubscriptionManager)
     )
         .addRow(
             getLocalizedMessages(locale, UserMessages.Assistant),
             getLocalizedMessages(locale, UserMessages.GetAdviceHowToBehave)
         )
         .addRow(
-            getLocalizedMessages(locale, UserMessages.SubscriptionManager),
+            getLocalizedMessages(locale, UserMessages.Language),
             getLocalizedMessages(locale, UserMessages.Help)
         );
 
@@ -177,6 +182,104 @@ export const getLocalizationInlineKeyboard = (
     return ik.build();
 };
 
+export const getContinentCountriesCheckOutOfferMessageInlineKeyboard = (
+    locale: string,
+    continent: string
+): Array<Array<TelegramBot.InlineKeyboardButton>> => {
+    const inlineKeyboard = [];
+
+    inlineKeyboard.push([
+        {
+            text: getLocalizedMessages(locale, 'Get all continents'),
+            callback_data: UserRegExps.CountriesData,
+        },
+        {
+            text: getLocalizedMessages(locale, [
+                [`Check %s countries out`, continent],
+            ]).join(''),
+            callback_data: `${UserRegExps.CountriesData} ${continent}`,
+        },
+    ]);
+
+    return inlineKeyboard;
+};
+
+export const getCountriesInlineKeyboard = (
+    countries: Array<Country>
+): TelegramBot.SendMessageOptions => {
+    const ik = new InlineKeyboard();
+
+    let i: number = 0;
+    while (i < countries.length) {
+        const rows = [];
+        let rowItem: number = 0;
+        while (!!countries[i] && rowItem < COUNTRIES_ROW_ITEMS_NUMBER) {
+            const country: Country = countries[i];
+            rows.push({
+                text: `${flag(country.name) ?? ''}${country.iso3}`,
+                callback_data: `${UserRegExps.CountryData} ${country.name}`,
+            });
+            i += 1;
+            rowItem += 1;
+        }
+        ik.addRow(...rows);
+    }
+
+    return ik.build();
+};
+
+export const getFullClickableFeaturesInlineKeyBoard = (
+    locale: string
+): TelegramBot.SendMessageOptions => {
+    const ik = new InlineKeyboard();
+
+    ik.addRow(
+        {
+            text: getLocalizedMessages(locale, UserMessages.CountriesData),
+            callback_data: UserRegExps.CountryData,
+        },
+        {
+            text: getLocalizedMessages(locale, UserMessages.AvailableCountries),
+            callback_data: UserRegExps.AvailableCountries,
+        }
+    )
+        .addRow(
+            {
+                text: getLocalizedMessages(locale, UserMessages.Assistant),
+                callback_data: UserRegExps.Assistant,
+            },
+            {
+                text: getLocalizedMessages(
+                    locale,
+                    UserMessages.GetAdviceHowToBehave
+                ),
+                callback_data: UserRegExps.Advice,
+            }
+        )
+        .addRow(
+            {
+                text: getLocalizedMessages(locale, UserMessages.Existing),
+                callback_data: UserRegExps.Subscribe,
+            },
+            {
+                text: getLocalizedMessages(locale, UserMessages.Unsubscribe),
+                callback_data: UserRegExps.Unsubscribe,
+            }
+        )
+        .addRow(
+            {
+                text: getLocalizedMessages(locale, 'Choose language'),
+                callback_data: UserSettingsRegExps.Language,
+            },
+            {
+                text: getLocalizedMessages(locale, UserMessages.Help),
+                callback_data: UserRegExps.Help,
+            }
+        );
+
+    return ik.build();
+};
+
 const getCloseInlineKeyboardRow = (
     locale: string
 ): TelegramBot.InlineKeyboardButton => {

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

@@ -30,6 +30,7 @@ export const withTwoArgumentsAfterCommand = (
             return handlerFn.call(context, {
                 bot,
                 message,
+                user,
                 chatId,
                 commandParameter:
                     (arg1 && arg1.toLowerCase()) || commandParameter,