В этой статье я хочу познакомить с новой библиотекой Urban Bot, которая адаптирует React для написания чат-ботов. Ниже я расскажу, зачем эта библиотека появилась на свет, какие дает преимущества и как написать вашего первого чат-бота.

Чат-бот это чаще всего отдельный чат в мессенджере, в котором вы общаетесь не с человеком, а с программой. Он может присылать сообщения в виде текста, изображений, кнопок и многих других UI элементов и реагировать на сообщения от пользователей. Современные чат-боты это полноценные UI приложения внутри мессенджеров.

В отличии от большинства чат-бот библиотек, которые чаще всего просто оборачивают http запросы в функции с готовыми аргументами и предоставляют подписки вида bot.on('message', callback), иногда позволяя передавать контекст между вызовами, Urban Bot предлагает совершенно иной подход к разработке чат-ботов через декларативное программирование и компонентный подход. Живой пример, написанный на Urban Bot, вы можете попробовать в Telegram, cсылка на чат-бот, и посмотреть код на GitHub.

Как мы заметили выше, чат-боты это полноценные UI приложения. А какой язык в 2020 и какая библиотека наиболее подходит для разработки UI приложений? Правильно, JavaScript и React. Такая интеграция позволяет легко и непринужденно строить чат-боты любой сложности без единого знания об API мессенджеров. Далее я расскажу, как создавать простые компоненты и на их основе строить сложных чат-ботов, работать с навигацией, создавать диалоги любой вложенности, писать одно приложение и запускать в любых мессенджерах, и многое другое.

Отправка сообщений

Так выглядит самый простой пример на Urban Bot. Для отправки текстового сообщения нам нужно создать функцию и вернуть из него готовый компонент Text с текстом внутри, который мы хотим отправить. Когда компонент отрендериться, все пользователи чат-бота получат сообщение "Hello, world!".

import React from 'react';import { Text } from '@urban-bot/core';function App() {    return (        <Text>           Hello, world!        </Text>    );}

Изображение можно отправить так:

import React from 'react';import { Image } from '@urban-bot/core';function App() {    const imageByURL =  'https://some-link.com/image.jpg';    return <Image file={imageByURL} />;}

Urban Bot имеет готовый набор компонентов, для каждого вида сообщений, для файлов File, для кнопок ButtonGroup и много других, подробнее можно взглянуть здесь. В каждый из них можно передать определенный набор пропсов, например, имитировать будто бот печатает сообщение 1 секунду <Text simulateTyping={1000}>.

Получение сообщений

Мы рассмотрели как посылать сообщения, давайте разберемся как подписываться на сообщения от пользователей. За подписки в Urban Bot отвечают React Hooks.

Чтобы подписаться на текстовые сообщения, мы можем использовать хук useText.

import React from 'react';import { Text, useText } from '@urban-bot/core';function App() {    useText(({ text }) => {        console.log(`Пользователь отправил сообщение ${text}`);    });    return (        <Text>            Hello, world!        </Text>    );}

Urban Bot предоставляет готовы набор хуков для разных типов сообщений. Например, useImage, если пользователь отправил изображение, useFile и т.д. Полный список здесь. В каждый хук также приходит мета информация, кто отправил сообщение и т.д.

Эхо бот

Теперь, зная базовые концепции, мы можем соединить получение и отправку сообщения. Напишем простой компонент, который после получения сообщения отправит его пользователю обратно.

В этом компоненте мы впервые добавим работу с переменными через React хук useState. Этот хук возвращает переменную и функцию, чтобы ее изменять. React.useState нужен, чтобы изменение переменной приводило к ререндеру и, соответсвенно, отправке нового сообщения. Мы определим начальное значение переменной text как "Привет" и передадим в компонент Text. Также мы подпишемся на сообщения от пользователей с помощью хука useText, и будем изменять text через функцию setText. После вызова setText React перерендерит компонент Echo с новым значением, и пользователь получит новое сообщение с тем что он сам отправил боту.

import React from 'react';import { Text, useText } from '@urban-bot/core';function Echo() {    const [text, setText] = React.useState('Привет!');    useText(({ text }) => {        setText(text);    });    return (        <Text>            {text}        </Text>    );}

Кнопки

Давайте также напишем пример с кнопками, сделаем простейший счетчик. Для этого нам понадобятся компоненты ButtonGroup и Button. Каждой кнопке мы определим свой обработчик, который будет менять count на +1 или -1 и будем передавать результат в ButtonGroup в проп title. Мы установим проп isNewMessageEveryRender как false, чтобы при последующих ререндерах отправлялось не новое сообщение с новыми кнопками, а просто изменялось начальное сообщение.

import React from 'react';import { ButtonGroup, Button } from '@urban-bot/core';function Counter() {    const [count, setCount] = React.useState(0);    const increment = () => setCount(count + 1);    const decrement = () => setCount(count - 1);    return (        <ButtonGroup title={count} isNewMessageEveryRender={false}>            <Button onClick={increment}>+1</Button>            <Button onClick={decrement}>-1</Button>        </ButtonGroup>    );}

Навигация

Мы написали два простых компонента эхо и счетчик. Давайте представим, что мы хотим чтобы они были у нас в одном чат-боте, но работали независимо. Для этого мы можем подключить компонент Router и разделить компоненты по разным путям. Пути это обычные сообщения от пользователей.

Теперь, когда пользователь напишет "/echo" отрендериться компонент Echo, когда "/counter" управление перейдет в Counter. Роуты также могут принимать path как regexp.

import React from 'react';import { Router, Route } from '@urban-bot/core';import { Echo } from './Echo';import { Counter } from './Counter';function App() {    return (        <Router>            <Route path="/echo">                <Echo />            </Route>            <Route path="/counter">                <Counter />            </Route>        </Router>    );}

Визуальный пример, чтобы увидеть как будет работать код.

Если вы почувствовали концепцию, то уже поняли, что можно создавать десятки, сотни компонентов, комбинировать их вместе, либо разделять роутером, делиться компонентами между разными чат-ботами и строить действительно сложные SPA внутри мессенджеров.

Форматирование текста

Urban Bot позволяет стилизовать сообщения через привычные HTML теги. Писать жирным <b>, курсивом <i>, зачеркнутым <s>, переносить строки <br /> и так далее, полный список здесь.

const someCode = `function sum2() {    return 2 + 2;}if (sum2() !== 4) {    console.log('WTF');}`;<Text>    Usual text    <br />    <b>Bold text</b>    <br />    <i>Italic text</i>    <br />    <u>Underscore text</u>    <br />    <s>Strikethrough text</s>    <br />    <q>quote</q>    <br />    <b>        Bold and <s>Strikethrough text</s>    </b>    <br />    <code >Code 2 + 2</code >    <br />    <pre>{someCode}</pre>    <br />    <a href="http://personeltest.ru/aways/github.com/urban-bot/urban-bot">External link</a></Text>

Диалоги

Чат-боты могут вести диалоги с пользователем, что-то спрашивать, реагировать на сообщения в зависимости от ответа пользователя. В Urban Bot встроен компонент Dialog, который позволяет легко создавать диалоги любой сложности.

Пример плоского диалога. Бот задаст первый вопрос, после ответа задаст второй, потом третий, потом запустит callback onFinish с готовыми ответами. На каждом шаге можно обрабатывать ответ пользователя через callback onNext.

import React from 'react';import { Dialog, DialogStep, Text } from '@urban-bot/core';function FlatDialogExample() {    return (        <Dialog onFinish={(answers) => console.log(answers)}>            <DialogStep                content={<Text>Привет, как тебя зовут?</Text>}                 id="name"                onNext={(name) => console.log(name)}            >                <DialogStep                    content={<Text>Cколько тебе лет?</Text>}                    id="age"                >                    <DialogStep                         content={<Text>Из какого ты города?</Text>}                        id="city"                    />                </DialogStep>            </DialogStep>        </Dialog>    );}

Можно получать на следующем шаге прошлый ответ через паттерн render-props .

function FlatDialogExample() {    return (        <Dialog>            <DialogStep content={<Text>Привет, как тебя зовут?</Text>}>                {(name) => (                    <DialogStep                         content={<Text>{`${name}, cколько тебе лет?`}</Text>}                    />                )}            </DialogStep>        </Dialog>    );}

Можно добавить валидацию на каждый шаг.

function FlatDialogExample() {    return (        <Dialog onFinish={(answers) => console.log(answers)}>            <DialogStep                content={<Text>Привет, как тебя зовут?</Text>}                id="name"                validation={{                     isValid: (answer) => answer !== 'Самуэль',                     errorText: 'Самуэль заблокирован.'                 }}            >                // ...            </DialogStep>        </Dialog>    );}

Также возможно построение более сложных диалогов, когда бот отвечает определенным образом в зависимости от ответа пользователя. Для предопределенных ответов можно использовать кнопки.

import React from 'react';import { Dialog, DialogStep, Text, ButtonGroup, Button } from '@urban-bot/core';function TreeDialogExample() {    return (        <Dialog>            <DialogStep                content={                    <ButtonGroup title="Привет, что вы хотите купить?">                        <Button id="hat">Футболка</Button>                        <Button id="glasses">Очки</Button>                    </ButtonGroup>                }            >                <DialogStep                    match="hat"                    content={                        <ButtonGroup title="Футболка какого размера?">                            <Button id="m">S</Button>                            <Button id="s">M</Button>                            <Button id="l">L</Button>                        </ButtonGroup>                    }                />                <DialogStep                    match="glasses"                    content={                        <ButtonGroup title="Очки какого цвета?">                            <Button id="black">Черный</Button>                            <Button id="white">Белый</Button>                        </ButtonGroup>                    }                />            </DialogStep>        </Dialog>    );}

Состояние

Что вы можете использовать для управления состоянием? Все то же что и в любом React приложении. Можете использовать React useState и передавать состояние ниже по дереву компонентов через пропсы или React Context. Можно использовать библиотеки для управления состоянием: Redux (пример), MobX (пример), Apollo и любые другие, которые обычно используют вместе с React, вы можете даже переиспользовать готовые части из готовых React Web или React Native приложений, так как Urban Bot использует тот же чистый React, который работает в миллионах приложений.

Сессия

Urban Bot запускается на сервере, соответсвенно, все логика от всех чатов и пользователей обслуживается на одном железе, что кардинально отличается от стандартных React приложений, которые запускаются на стороне каждого клиента. Urban Bot решает эту проблему на своей стороне и отображает приложение уникальным для каждого пользователя, так что, если вы уже писали на React веб или мобильные приложения, вы не почувствуете разницу.

В любом примере на Urban Bot уже вшита работа с сессией. Например, в примере ниже у каждого пользователя, кто зайдет в персональный чат-бот, будет его собственный счетчик.

function Counter() {    const [count, setCount] = React.useState(0);    const increment = () => setCount(count + 1);    const decrement = () => setCount(count - 1);    return (        <ButtonGroup title={count} isNewMessageEveryRender={false}>            <Button onClick={increment}>+1</Button>            <Button onClick={decrement}>-1</Button>        </ButtonGroup>    );}

Если нам понадобится глобальный счетчик, то к этому примеру можно сделать хук, который будет содержать уже общую информацию.

function Counter() {    const [count, setCount] = useGlobalCount();   // ...}

Также, в любом месте приложения мы можем получить данные о конкретном чате, какой пользователь написал, с каким никнеймом и т.д. Если чат-бот персональный, то chat и from будут совпадать.

import React from 'react';import { Text, useText, useBotContext } from '@urban-bot/core';function UserId() {    const { chat } = useBotContext();    useText(({ from }) => console.log(`Пришло сообщение от ${from.username}`));   return <Text>Чат id {chat.id}</Text>;}

Типизация

Urban Bot написан на TypeScript, соответсвенно проект полностью типизирован, и если вы пишете на TypeScript, вам будет очень удобно.

Запуск в мессенджерах

Большой плюс Urban Bot, что он не привязан ни к одному мессенджеру. Есть основной пакет @urban-bot/core, который позволяет создавать абстрактных чат-ботов, а уже их подключать к определенным мессенджерам. В данный момент есть поддержка Telegram, Slack, Facebook. В дальнейшем, мы планируем добавлять любые мессенджеры, где есть чат-боты и открытое API. Если вам интересно, и вы хотите писать Urban Bot приложения для других мессенджеров, скажем Viber, Discord или у вас есть свой мессенджер то пишите к нам в группу https://t.me/urbanbotjs, одной просьбы будет достаточно, чтобы появилось большая мотивация реализовать ваш функционал.

Теперь перейдем к практике. Выше мы создавали компоненты и приложение, но не запускали его. Для запуска нам нужно выбрать мессенджер или мессенджеры, в которых мы хотим запустить наше приложение.

Скажем, у нас есть готовое приложение App и мы хотим его запустить его в Telegram. Для этого нам понадобится класс UrbanBotTelegram из пакет @urban-bot/telegram. Функция render из @urban-bot/core подобная ReactDOM.render и компонент Root. Мы создаем экземпляр UrbanBotTelegram и передаем туда бот токен из Telegram, также можно передать isPolling, чтобы не настраивать вебхук, и бот работал локально. Готовый экземпляр мы передаем в компонент Root, и оборачиваем наше готовое приложение и, соответсвенно, передаем все в функцию render, которая запустит все процессы.

Более подробная инструкция с видео как разрабатывать локально и деплоить Telegram бота можно прочитать в инструкции.

import React from 'react';import { render, Root } from '@urban-bot/core';import { UrbanBotTelegram } from '@urban-bot/telegram';import { App } from './App';const urbanBotTelegram = new UrbanBotTelegram({    token: 'telegramToken',    isPolling: true,});render(    <Root bot={urbanBotTelegram}>        <App />    </Root>);

Если нам нужно запустить два и более мессенджера, просто используем пакеты других мессенджеров, передаем туда нужные данные и делаем по аналогии с Telegram.

// ...import { UrbanBotSlack } from '@urban-bot/slack';// ...render(    <Root bot={urbanBotTelegram}>        <App />    </Root>);const urbanBotSlack = new UrbanBotSlack({    signingSecret: 'slackSigningSecret',    token: 'slackToken',});render(    <Root bot={urbanBotSlack}>        <App />    </Root>);

Прямой вызов API

С помощью Urban Bot вы можете создавать чат-ботов просто описывая их через компоненты. А что если вам будет нужно вручную вызвать API? Каждый экземпляр UrbanBot* содержит в себе API клиент для активного мессенджера. Рассмотрим пример для Telegram.

Мы можем получить bot с помощью хука useBotContext. bot содержит client и type c типом мессенджера. client будет представлять собой экземпляр библиотеки node-telegram-bot-api . В любом месте приложения можно получить client и вызвать любой метод на ваше усмотрение, скажем блокировать пользователя, если он написал нецензурное сообщение.

import React from 'react';import { useText, useBotContext } from '@urban-bot/core';function SomeComponent() {    const { bot } = useBotContext();    useText(({ text, chat, from }) => {        if (text.includes('бл***')) {            bot.client.kickChatMember(chat.id, from.id);        }    });    // ...}

В каждом мессенджере уникальный API. Если вы разрабатываете несколько мессенджеров одновременно, можно отделять функционал сравнивая bot.type.

import { useBotContext } from '@urban-bot/core';import { UrbanBotTelegram } from '@urban-bot/telegram';import { UrbanBotSlack } from '@urban-bot/slack';function SomeComponent() {    const { bot } = useBotContext();    if (bot.type === UrbanBotTelegram.type) {        // telegram api        bot.client.kickChatMember(/* ... */);    }    if (bot.type === UrbanBotSlack.type) {        // slack api        bot.client.conversations.kick(/* ... */);    }    // ...}

Как попробовать?

У Urban Bot есть стартер, который позволит вам начать разрабатывать чат-ботов за минуту, сделан по аналогии с create-rect-app. Все что вам нужно, чтобы попробовать Urban Bot это выполнить команду в терминале для

TypeScript

npx create-urban-bot my-app

JavaScript

npx create-urban-bot my-app --template js

Команда склонирует шаблон приложения с нужными зависимостями и скриптами на ваш компьютер, и вам останется только открыть проект, передать ваши токены в .env файл и расскоментировать мессенджеры, которые вы хотите разрабатывать. Видео инструкция.

Итого

Несмотря на то что Urban Bot запустился только недавно, на мой взгляд это библиотека с огромным потенциалом. Только представьте, если у вас есть базовые знания React, вы можете написать чат-бот любой сложности на все возможные платформы, создавать и использовать библиотеки с готовым набором компонентов на манер ui-kit, переиспользовать код между вашими другими UI приложеними на React, будь то web или mobile.

Если вы уже разрабатывали чат-ботов, попробуйте Urban Bot, вы почувствуете как библиотека делает за вас кучу работы. Если никогда не разрабатывали, но имеете представление о React, то напишете вашего первого чат-бота за 5 минут. Если вам понравилась идея и хотите, чтобы проект развивался дальше, вступайте в нашу группу в Telegram, ставьте звезду на гитхабе, будем рады любому фидбеку.

Полезные ссылки

Сайт
Github
Группа в Telegram
Наглядный чат-бот в Telegram, с открытым кодом.
Как создать Todo List чат-бот в Telegram с помощью React.js

Рефлексия

Reflection vs Introspection

if (obj instanceof Cat) {   Cat cat = (Cat) obj;   cat.meow();}

Некоторые возможности рефлексии

Object obj = new Cat();    // а куда кошка пропала?

Object obj = Class.forName("complete.classpath.MyCat").newInstance();

Method m = obj.getClass().getDeclaredMethod("meow");m.invoke(obj);

import java.lang.reflect.Method;import java.lang.Class;public class Cat {    public void meow() {        System.out.println("Meow");    }        public static void main(String[] args) throws Exception {        Object obj = Class.forName("Cat").newInstance();         Method m = obj.getClass().getDeclaredMethod("meow");         m.invoke(obj);    }}

Вопрос #1
Почему в invoke методе в примере сверху мы должны передавать экземпляр объекта?

Аннотации

public abstract class Animal {    abstract void doSomething();}public class Cat extends Animal {    @Override    public void doSomething() {        System.out.println("Meow");    }}

Типы аннотаций

@Target(ElementType.METHOD)@Retention(RetentionPolicy.SOURCE)public @interface Override {}

• RetentionPolicy.CLASS
• RetentionPolicy.RUNTIME
• RetentionPolicy.SOURCE

SuperCat

abstract class Cat {    abstract void meow();}public class Home {    private class Tom extends Cat {        @Override        void meow() {            System.out.println("Tom-style meow!"); // <---        }    }        private class Alex extends Cat {        @Override        void meow() {            System.out.println("Alex-style meow!"); // <---        }    }}

@Target(ElementType.TYPE)     // чтобы использовать для класса@Retention(RetentionPolicy.RUNTIME)  // хотим чтобы наша аннотация дожила до рантайма@interface SuperCat {}// ...    @SuperCat   // <---    private class Alex extends Cat {        @Override        void meow() {            System.out.println("Alex-style meow!");        }    }// ...

Set<class<?>> classes = SuperCat.class.getAnnotatedClasses();

ClassPath

Надеюсь, вы с ними знакомы, а если нет, то спешите изучить это, так как это одна из фундаментальных вещей.

public static void main(String[] args) throws ClassNotFoundException {    String packageName = "com.apploidxxx.examples";    ClassLoader classLoader = Home.class.getClassLoader();        String packagePath = packageName.replace('.', '/');    URL urls = classLoader.getResource(packagePath);        File folder = new File(urls.getPath());    File[] classes = folder.listFiles();        for (File aClass : classes) {        int index = aClass.getName().indexOf(".");        String className = aClass.getName().substring(0, index);        String classNamePath = packageName + "." + className;        Class<?> repoClass = Class.forName(classNamePath);            Annotation[] annotations = repoClass.getAnnotations();        for (Annotation annotation : annotations) {            if (annotation.annotationType() == SuperCat.class) {                System.out.println(                  "Detected SuperCat!!! It is " + repoClass.getName()                );            }        }        }}

Class<?> repoClass = Class.forName(classNamePath);

// ...// пакет в котором мы сейчас находимсяString packageName = "com.apploidxxx.examples";// Загрузчик классов, чтобы получить наши классы из байт-кодаClassLoader classLoader = Home.class.getClassLoader();// com.apploidxxx.examples -> com/apploidxxx/examplesString packagePath = packageName.replace('.', '/');URL urls = classLoader.getResource(packagePath);File folder = new File(urls.getPath());// Наши классы в виде файловFile[] classes = folder.listFiles();// ...

com   apploidxxx       examples               Cat.class               Home$Alex.class               Home$Tom.class               Home.class               Main.class               SuperCat.class

for (File aClass : classes) {    // имя файла, на самом деле, Home.class, Home$Alex.class и тд    // поэтому нам нужно избавиться от .class и получить путь к файлу    // как к объекту внутри Java    int index = aClass.getName().indexOf(".");    String className = aClass.getName().substring(0, index);    String classNamePath = packageName + "." + className;    // classNamePath = com.apploidxxx.examples.Home    Class<?> repoClass = Class.forName(classNamePath);}

Annotation[] annotations = repoClass.getAnnotations();for (Annotation annotation : annotations) {    if (annotation.annotationType() == SuperCat.class) {        System.out.println(          "Detected SuperCat!!! It is " + repoClass.getName()        );    }}output: Detected SuperCat!!! It is com.apploidxxx.examples.Home$Alex

Рефлексируем

• Во-первых, кошкам надо где-то жить, поэтому им нужен дом. В нашем случае они не могут существовать без дома.
• Во-вторых, создадим список суперкотов.

List<cat> superCats = new ArrayList<>();final Home home = new Home();    // дом, где будут жить наши котики

for (Annotation annotation : annotations) {    if (annotation.annotationType() == SuperCat.class) {        Object obj = repoClass          .getDeclaredConstructor(Home.class)          .newInstance(home);        superCats.add((Cat) obj);    }}

Вопрос #2
Что будет, если мы пометим @SuperCat класс, который не наследуется от Cat?

Вопрос #3
Почему нам нужен конструктор, который принимает тип аргумента Home?

package com.apploidxxx.examples;import java.io.File;import java.lang.annotation.*;import java.lang.reflect.InvocationTargetException;import java.net.URL;import java.util.ArrayList;import java.util.List;@Target(ElementType.TYPE)@Retention(RetentionPolicy.RUNTIME)@interface SuperCat {}abstract class Cat {    abstract void meow();}public class Home {    public class Tom extends Cat {        @Override        void meow() {            System.out.println("Tom-style meow!");        }    }        @SuperCat    public class Alex extends Cat {        @Override        void meow() {            System.out.println("Alex-style meow!");        }    }        public static void main(String[] args) throws Exception {            String packageName = "com.apploidxxx.examples";        ClassLoader classLoader = Home.class.getClassLoader();            String packagePath = packageName.replace('.', '/');        URL urls = classLoader.getResource(packagePath);            File folder = new File(urls.getPath());        File[] classes = folder.listFiles();            List<Cat> superCats = new ArrayList<>();        final Home home = new Home();            for (File aClass : classes) {            int index = aClass.getName().indexOf(".");            String className = aClass.getName().substring(0, index);            String classNamePath = packageName + "." + className;            Class<?> repoClass = Class.forName(classNamePath);            Annotation[] annotations = repoClass.getAnnotations();            for (Annotation annotation : annotations) {                if (annotation.annotationType() == SuperCat.class) {                    Object obj = repoClass                      .getDeclaredConstructor(Home.class)                      .newInstance(home);                    superCats.add((Cat) obj);                }            }        }            superCats.forEach(Cat::meow);    }}output: Alex-style meow!

Способы работы с аннотациями

Прямо в байт-код

Reflections

package com.apploidxxx.examples;import org.reflections.Reflections;import java.lang.reflect.InvocationTargetException;import java.util.Optional;import java.util.Set;public class ExampleReflections {    private static final Home HOME = new Home();    public static void main(String[] args) {            Reflections reflections = new Reflections("com.apploidxxx.examples");            Set<Class<?>> superCats = reflections          .getTypesAnnotatedWith(SuperCat.class);            for (Class<?> clazz : superCats) {            toCat(clazz).ifPresent(Cat::meow);        }    }        private static Optional<Cat> toCat(Class<?> clazz) {        try {            return Optional.of((Cat) clazz                               .getDeclaredConstructor(Home.class)                               .newInstance(HOME)                              );        } catch (InstantiationException |                  IllegalAccessException |                  InvocationTargetException |                  NoSuchMethodException e)         {            e.printStackTrace();            return Optional.empty();        }    }}

spring-context

@Command(value = "hello", aliases = {"привет", "йоу"})public class Hello implements Executable {    public BotResponse execute(Message message) throws Exception {        return BotResponseFactoryUtil.createResponse("hello-hello",                                                      message.peerId);    }}

Практическое применение аннотаций в создании Телеграм-бота

Reflections

@Handler("/hello")public class HelloHandler implements RequestHandler {    private static final Logger log = LoggerFactory      .getLogger(HelloHandler.class);        @Override    public SendMessage execute(Message message) {        log.info("Executing message from : " + message.getText());        return SendMessage.builder()                .text("Yaks")                .chatId(String.valueOf(message.getChatId()))                .build();    }}@Retention(RetentionPolicy.RUNTIME)public @interface Handler {    String value();}

@Retention(RetentionPolicy.RUNTIME)public @interface Log {    String value() default ".*";    // regex    ExecutionTime[] executionTime() default ExecutionTime.BEFORE;}default` означает, что значение будет применено, если не будет указан `value@Logpublic class LogHandler implements RequestLogger {    private static final Logger log = LoggerFactory      .getLogger(LogHandler.class);        @Override    public void execute(Message message) {        log.info("Just log a received message : " + message.getText());    }}

@Log(value = "/hello")public class HelloLogHandler implements RequestLogger {    public static final Logger log = LoggerFactory      .getLogger(HelloLogHandler.class);    @Override    public void execute(Message message) {        log.info("Received special hello command!");    }}

@Log(executionTime = ExecutionTime.AFTER)public class AfterLogHandler implements RequestLogger {    private static final Logger log = LoggerFactory      .getLogger(AfterLogHandler.class);        @Override    public void executeAfter(Message message, SendMessage sendMessage) {        log.info("Bot response >> " + sendMessage.getText());    }}

@Log(executionTime = {ExecutionTime.AFTER, ExecutionTime.BEFORE})public class AfterAndBeforeLogger implements RequestLogger {    private static final Logger log = LoggerFactory      .getLogger(AfterAndBeforeLogger.class);    @Override    public void execute(Message message) {        log.info("Before execute");    }        @Override    public void executeAfter(Message message, SendMessage sendMessage) {        log.info("After execute");    }}

Set<Class<?>> annotatedCommands =   reflections.getTypesAnnotatedWith(Handler.class);final Map<String, RequestHandler> commandsMap = new HashMap<>();final Class<RequestHandler> requiredInterface = RequestHandler.class;for (Class<?> clazz : annotatedCommands) {    if (LoaderUtils.isImplementedInterface(clazz, requiredInterface)) {        for (Constructor<?> c : clazz.getDeclaredConstructors()) {            //noinspection unchecked            Constructor<RequestHandler> castedConstructor =               (Constructor<RequestHandler>) c;            commandsMap.put(extractCommandName(clazz),                             OBJECT_CREATOR.instantiateClass(castedConstructor));        }    } else {        log.warn("Command didn't implemented: "                  + requiredInterface.getCanonicalName());        }}// ...private static String extractCommandName(Class<?> clazz) {    Handler handler = clazz.getAnnotation(Handler.class);    if (handler == null) {        throw new           IllegalArgumentException(            "Passed class without Handler annotation"            );    } else {        return handler.value();    }}

Set<Class<?>> annotatedLoggers = reflections.getTypesAnnotatedWith(Log.class);final Map<String, Set<RequestLogger>> commandsMap = new HashMap<>();final Class<RequestLogger> requiredInterface = RequestLogger.class;for (Class<?> clazz : annotatedLoggers) {    if (LoaderUtils.isImplementedInterface(clazz, requiredInterface)) {        for (Constructor<?> c : clazz.getDeclaredConstructors()) {            //noinspection unchecked            Constructor<RequestLogger> castedConstructor =               (Constructor<RequestLogger>) c;            String name = extractCommandName(clazz);            commandsMap.computeIfAbsent(name, n -> new HashSet<>());            commandsMap              .get(extractCommandName(clazz))              .add(OBJECT_CREATOR.instantiateClass(castedConstructor));        }        } else {        log.warn("Command didn't implemented: "                  + requiredInterface.getCanonicalName());    }}

public final class CommandService {    private static final Map<String, RequestHandler> commandsMap       = new HashMap<>();    private static final Map<String, Set<RequestLogger>> loggersMap       = new HashMap<>();        private CommandService() {    }        public static synchronized void init() {        initCommands();        initLoggers();    }        private static void initCommands() {        commandsMap.putAll(CommandLoader.readCommands());    }        private static void initLoggers() {        loggersMap.putAll(LogLoader.loadLoggers());    }        public static RequestHandler serve(String message) {        for (Map.Entry<String, RequestHandler> entry : commandsMap.entrySet()) {            if (entry.getKey().equals(message)) {                return entry.getValue();            }        }            return msg -> SendMessage.builder()                .text("Команда не найдена")                .chatId(String.valueOf(msg.getChatId()))                .build();    }        public static Set<RequestLogger> findLoggers(      String message,       ExecutionTime executionTime    ) {        final Set<RequestLogger> matchedLoggers = new HashSet<>();        for (Map.Entry<String, Set<RequestLogger>> entry:loggersMap.entrySet()) {            for (RequestLogger logger : entry.getValue()) {                    if (containsExecutionTime(                  extractExecutionTimes(logger), executionTime                ))                 {                    if (message.matches(entry.getKey()))                        matchedLoggers.add(logger);                }            }            }            return matchedLoggers;    }        private static ExecutionTime[] extractExecutionTimes(RequestLogger logger) {        return logger.getClass().getAnnotation(Log.class).executionTime();    }        private static boolean containsExecutionTime(      ExecutionTime[] times,      ExecutionTime executionTime    ) {        for (ExecutionTime et : times) {            if (et == executionTime) return true;        }            return false;    }}public class DefaultBot extends TelegramLongPollingBot {    private static final Logger log = LoggerFactory.getLogger(DefaultBot.class);    public DefaultBot() {        CommandService.init();        log.info("Bot initialized!");    }        @Override    public String getBotUsername() {        return System.getenv("BOT_NAME");    }        @Override    public String getBotToken() {        return System.getenv("BOT_TOKEN");    }        @Override    public void onUpdateReceived(Update update) {        try {            Message message = update.getMessage();            if (message != null && message.hasText()) {                // run "before" loggers                CommandService                  .findLoggers(message.getText(), ExecutionTime.BEFORE)                  .forEach(logger -> logger.execute(message));                    // command execution                SendMessage response;                this.execute(response = CommandService                             .serve(message.getText())                             .execute(message));                    // run "after" loggers                CommandService                  .findLoggers(message.getText(), ExecutionTime.AFTER)                  .forEach(logger -> logger.executeAfter(message, response));                }        } catch (Exception e) {            e.printStackTrace();        }    }}

Спринговый бот

• Работа через аннотации не нарушает общей концепции работы спринг-контейнера.
• Мы можем не создавать команды сами, а получить их из контейнера, пометив наши команды как бины.
• Получаем отличный DI от спринга.

Реализация

@Servicepublic class ObjectLoader {    private final ApplicationContext applicationContext;    public ObjectLoader(ApplicationContext applicationContext) {        this.applicationContext = applicationContext;    }        public Collection<Object> loadObjectsWithAnnotation(      Class<? extends Annotation> annotation    ) {        return applicationContext.getBeansWithAnnotation(annotation).values();    }}

public Map<String, RequestHandler> readCommands() {    final Map<String, RequestHandler> commandsMap = new HashMap<>();        for (Object obj : objectLoader.loadObjectsWithAnnotation(Handler.class)) {        if (obj instanceof RequestHandler) {            RequestHandler handler = (RequestHandler) obj;            commandsMap.put(extractCommandName(handler.getClass()), handler);        }    }        return commandsMap;}

Подведём итоги

• Reflections.
• Spring-Context (без Spring).
• ApplicationContext из Spring.

1. Подумайте, нужен ли вам Spring. Он даёт мощный IoC контейнер и возможности экосистемы, но за всё приходится платить. Обычно я рассуждаю так: если нужны база данных и быстрый старт, то Spring Boot вам нужен. Если же бот достаточно прост, то можно обойтись и без него.
2. Если же вам не нужны сложные зависимости, то смело используйте Reflections.

PreparedStatement stmt = connection.prepareStatement("UPDATE alias SET aliases=?::jsonb WHERE vkid=?");stmt.setString(1, aliases.toJSON());stmt.setInt(2, vkid);stmt.execute();

• Профессия Java-разработчик

Преимущества и недостатки

• Низкая комиссия (0.8% суммарно за автопополнение и автовыплату)
• Отсутствие минимальной суммы (точнее, минимальная сумма составляет 0.01)
• Доступность нескольких валют (фиатных и крипто)
• Возможность подключения неограниченного количества проектов на один профиль

• Слабая распространенность ресурса (хотя это скорее всего исправимо)
• Отсутствие английского интерфейса (кошелек рассчитан на русскоязычную аудиторию и соответственно распространенные в СНГ платежные системы)
• Недостаточно автоматизированные переводы средств в сам кошелек (на данный момент доступно автоматическое пополнение кошелька только через Яндек.Деньги и Visa/MasterCard. Для других платежных систем доступно полуавтоматическое пополнение, из-за чего присутствует время ожидания)

Подключение автоплатежей

• Баланс чтоб просматривать баланс и видеть, что он изменился
• Пополнить
• Вывести

Создаем платежный счёт

1. Перейдите в бота t.me/TeleWalletAbot
2. Запустите его
3. Нажмите кнопку Прием платежей в главном меню
4. Под появившимся сообщением нажмите кнопку Открыть платежный счёт
5. Выберите валюту счёта
6. Появится сообщение Счёт успешно создан

Настройка счёта ap110741100
Баланс: 0 RUB

Название магазина: Не задано
API ключ: eHW2IQZQYjlJjgQ
URL для уведомлений: Не задан
URL перехода после успешного платежа: Не задан
URL перехода после неудачи(отказа): Не задан
Плательщик комиссии при выплате: Магазин
Удалить счёт (/delapsch_100Re6)

С помощью кнопок под этим сообщением отредактируйте необходимые параметры

Создаем файл настроек

<?php  $dblocation = "localhost";  $dbname = "имя базы данных mysql";    $dbuser = "пользователь базы данных mysql";  $dbpasswd = "пароль к бд mysql";  /* Подключение к серверу MySQL */   $link = mysqli_connect($dblocation,$dbuser,$dbpasswd,$dbname);         if(!$link)  exit("<P>Невозможно установить соединение с сервером БД.</P>" );   mysqli_query($link,"SET NAMES 'utf8'");  //апи-ключ и счёт TeleWalletAbot  $tlwkey = "eHW2IQZQYjlJjgQ";  $tlwacc = "ap110741100";?>

<?php      include('vendor/autoload.php');  //подключение библиотек, загруженных через composer    //классы для работы с Telegram bot api    use Telegram\Bot\Api;     use Telegram\Bot\Commands\Command;    use Telegram\Bot\Keyboard\Keyboard;    // -----------------------------------------    require_once "commands.php"; //скрипт, где мы реализуем основную логику    require_once "config.php"; //файл настроек    require_once "TeleWallet.php"; /*SDK Telewallet  https://github.com/tlwadmin/TeleWalletSDK/blob/main/TeleWallet.php  */    $telegram = new Api("токен, полученный от Telegram");    $result = $telegram -> getWebhookUpdates(); //получаем обновления    $chat_id = $result["message"]["chat"]["id"];    $text = $result["message"]["text"];    $callback_query = $result['callback_query'];        $data = $callback_query['data'];     $chat_id_in = $callback_query['message']['chat']['id'];     $uname = $result["message"]["from"]["username"]; if($chat_id>0 && $text){ //блок обработки основных команд$sm=['chat_id' => $chat_id, 'text' => $text];$ans_arr=getAnsw($text,$chat_id,$uname);    for($i=0;$i<count($ans_arr);$i++){$ans=$ans_arr[$i];$reply = $ans['text'];$sm=[ 'chat_id' => $chat_id, 'text' => $reply, 'caption'=>$reply];if(array_key_exists('inline_keyboard',$ans)) {$keyboard=$ans['inline_keyboard'];$replyMarkup = json_encode($keyboard);    $sm['reply_markup'] =$replyMarkup;}       else if(array_key_exists('keyboard',$ans)){$keyboard=$ans['keyboard'];$reply_markup = $telegram->replyKeyboardMarkup([ 'keyboard' => $keyboard, 'resize_keyboard' => true, 'one_time_keyboard' => false ]);$sm['reply_markup']=$reply_markup;}$telegram->sendMessage($sm);}            }    if($data){  //блок обработки инлайн-команд$ans_arr=getAnsw($data,$chat_id_in);for($i=0;$i<count($ans_arr);$i++){$ans=$ans_arr[$i];$reply = $ans['text'];$sm=[ 'chat_id' => $chat_id_in, 'text' => $reply, 'caption'=>$reply];if(array_key_exists('inline_keyboard',$ans)) {$keyboard=$ans['inline_keyboard'];$replyMarkup = json_encode($keyboard);    $sm['reply_markup'] =$replyMarkup;}       else if(array_key_exists('keyboard',$ans)){$keyboard=$ans['keyboard'];$reply_markup = $telegram->replyKeyboardMarkup([ 'keyboard' => $keyboard, 'resize_keyboard' => true, 'one_time_keyboard' => false ]);$sm['reply_markup']=$reply_markup;}$telegram->sendMessage($sm);}}    ?>

<?phpfunction getAnsw($command,$chat_id, $name=""){global $link;global $telegram;global  $tlwkey;    global$tlwacc;$r=mysqli_query($link,"select * from users where id='$chat_id'");$ud=mysqli_fetch_assoc($r); //данные о пользователеif($command=="/start") {//добавим в бд если нетif(!$ud) mysqli_query($link,"INSERT INTO `users`(`id`,`name`) values('$chat_id','$name')");$res['text']="Привет. Я бот, позволяющий протестировать пополнение и выплату через TeleWallet";$res['keyboard']=[["Баланс","Пополнить","Выплата"]];return [$res];}if($command=="Баланс") {$res['text']="Ваш баланс: {$ud['balance']} руб";return [$res];}if($command=="Пополнить") {$res['text']="Выберите сумму, на которую хотите пополнить счёт";$res['inline_keyboard']['inline_keyboard']=[[['text'=>'1 руб','callback_data'=>'popoln_1'],['text'=>'5 руб','callback_data'=>'popoln_5'],['text'=>'10 руб','callback_data'=>'popoln_10']]];return [$res];}if($command=="Выплата") {$res['text']="Сколько вы хотите вывести?";$res['inline_keyboard']['inline_keyboard']=[[['text'=>'1 руб','callback_data'=>'vivod_1'],['text'=>'5 руб','callback_data'=>'vivod_5'],['text'=>'10 руб','callback_data'=>'vivod_10']]];addCmd("vivod_",$chat_id);return [$res];}$tlw = new TeleWallet($tlwkey,$tlwacc);if(strpos($command,'popoln_')!==false) {$arr = explode("_",$command);mysqli_query($link,"INSERT INTO `donate`( `user_id`, `sum`) values('$chat_id','{$arr[1]}')");$payId = mysqli_insert_id($link);$resp = $tlw->getСheque($arr[1],$payId);$res['text']="Вы выбрали пополнение на {$arr[1]} руб. Пополнение доступно через TeleWallet. Для продолжения нажмите кнопку под этим сообщением";$res['inline_keyboard']['inline_keyboard']=[[["text"=>"Пополнить","url"=>$resp['url']]]];return [$res];}       if(strpos($command,'setnumber_')!==false) { //пользователь задает номер счета$arr = explode("_",$command);mysqli_query($link,"UPDATE `users` SET `outnumber`='{$arr[1]}' where `id`='$chat_id'");$res['text']="Номер счёта обновлен.";return [$res];}if(strpos($command,'vivod_')!==false) {$arr = explode("_",$command);if($ud['balance']<$arr[1]) $res['text']="недостаточно средств на балансе";else {if(empty($ud['outnumber']))$res['text']="У вас не задан номер счета TeleWallet для вывода. Отправьте боту setnumber_(номер ваше счета) (без скобок), чтоб задать номер счёта";else {$resp = $tlw->sendOutpay($arr[1],$ud['outnumber']);if($resp['error']==0) { //выплата удалась$res['text']="На указанный Вами номер счета выведено {$arr[1]} руб";mysqli_query($link,"UPDATE `users` SET `balance`=`balance`-{$arr[1]} where `id`='$chat_id'");}else if($resp['error']==4 || $resp['error']==5) { //выплата удалась$res['text']="Вы указали неправильный номер счёта";}else $res['text']="Выплата не удалась. Код ошибки: {$resp['error']}. Обратитесь к администратору проекта";}}return [$res];}}?>

$resp = $tlw->getСheque($arr[1],$payId);

Проверка факта оплаты

<?phpinclude('vendor/autoload.php'); use Telegram\Bot\Api; use Telegram\Bot\Commands\Command;use Telegram\Bot\Keyboard\Keyboard;    require_once "config.php";require_once "TeleWallet.php";$telegram = new Api("ключ апи вашего бота, полученный от ботфазер");$tlw = new TeleWallet($tlwkey,$tlwacc);$ri = mysqli_query($link,"SELECT * FROM `donate` WHERE `id`={$_POST['payId']}");$pay_info = mysqli_fetch_assoc($ri);if($tlw->testPayIn($_POST) && $pay_info['sum']==$_POST['sum']) {echo "YES";mysqli_query($link,"UPDATE `users` SET `balance`=`balance`+{$pay_info['sum']} where `id`={$pay_info['user_id']}");       mysqli_query($link,"UPDATE `users` SET `balance`=`balance`+{$pay_info['sum']} where `id`={$_POST['payId']}");try {$telegram->sendMessage(["text"=>"Ваш баланс пополнен на {$pay_info['sum']} руб","chat_id"=>$pay_info['user_id']]);}catch(Exception $e) {}}else echo "NO";?>

Для кого написано

Предыстория

Что в статье есть, чего нет

• создание бекенда не-инлайн бота на Java 11 с использованием Telegram Bot Api 5.0;
• обработка команд вида /dosomething;
• обработка текстовых сообщений, не являющихся командами (т.е. не начинающихся с "/");
• отправку пользователю текстовых сообщений и файлов;
• деплой и запуск бота на heroku.

• использование функций ботов, не перечисленных выше (например, создание клавиатур я их сначала добавил, но в итоге они мне просто не пригодились);
• создание списка заданий;
• работу с Word-документом;
• обеспечивающие функции логирование, тесты и т.п.;
• общение с BotFather (создание бота, получение его токена и формирование списка команд подробно и понятно описано во многих источниках, вот первый попавшийся мануал).

Бизнес-функции бота

• выдавать пользователю справочную текстовую информацию в ответ на команды /start, /help и /settings;
• обрабатывать и запоминать пользовательские настройки, направленные текстовым сообщением заданного формата. Настроек три минимальное + максимальное число, используемые в заданиях, и количество страниц выгружаемого файла;
• оповещать пользователя о несоблюдении им формата сообщения;
• формировать Word-файл с заданиями на сложение, вычитание или вперемешку в ответ на команды /plus, /minus и /plusminus с использованием дефолтных или установленных пользователем настроек.

Общий порядок действий

• разобраться с зависимостями;
• создать класс бота и реализовать обработку текстовых сообщений пользователя, не являющихся командами;
• создать классы команд;
• прописать запуск приложения;
• задеплоить на heroku.

Зависимости

    <groupId>***</groupId>    <artifactId>***</artifactId>    <version>1.0-SNAPSHOT</version>    <name>***</name>    <description>***</description>    <packaging>jar</packaging>    <properties>        <java.version>11</java.version>        <maven.compiler.source>${java.version}</maven.compiler.source>        <maven.compiler.target>${java.version}</maven.compiler.target>        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>        <org.projectlombok.version>1.18.16</org.projectlombok.version>        <apache.poi.version>4.1.2</apache.poi.version>        <telegram.version>5.0.1</telegram.version>    </properties>    <dependencies>        <!-- Telegram API -->        <dependency>            <groupId>org.telegram</groupId>            <artifactId>telegrambots</artifactId>            <version>${telegram.version}</version>        </dependency>        <dependency>            <groupId>org.telegram</groupId>            <artifactId>telegrambotsextensions</artifactId>            <version>${telegram.version}</version>        </dependency>        <!-- Lombok -->        <dependency>            <groupId>org.projectlombok</groupId>            <artifactId>lombok</artifactId>            <version>${org.projectlombok.version}</version>            <scope>compile</scope>        </dependency>    </dependencies>    <build>        <finalName>${project.artifactId}</finalName>        <plugins>            <plugin>                <groupId>org.apache.maven.plugins</groupId>                <artifactId>maven-compiler-plugin</artifactId>                <version>3.8.1</version>                <configuration>                    <release>${java.version}</release>                    <annotationProcessorPaths>                        <path>                            <groupId>org.projectlombok</groupId>                            <artifactId>lombok</artifactId>                            <version>${org.projectlombok.version}</version>                        </path>                    </annotationProcessorPaths>                </configuration>            </plugin>            <plugin>                <groupId>org.apache.maven.plugins</groupId>                <artifactId>maven-dependency-plugin</artifactId>                <version>3.1.2</version>                <executions>                    <execution>                        <id>copy-dependencies</id>                        <phase>package</phase>                        <goals>                            <goal>copy-dependencies</goal>                        </goals>                    </execution>                </executions>            </plugin>            <plugin>                <groupId>org.apache.maven.plugins</groupId>                <artifactId>maven-surefire-plugin</artifactId>                <version>3.0.0-M5</version>            </plugin>        </plugins>    </build>

Класс бота и обработка текстовых сообщений

import lombok.Getter;import org.telegram.telegrambots.extensions.bots.commandbot.TelegramLongPollingCommandBot;import org.telegram.telegrambots.meta.api.methods.send.SendMessage;import org.telegram.telegrambots.meta.api.objects.Message;import org.telegram.telegrambots.meta.api.objects.Update;import org.telegram.telegrambots.meta.api.objects.User;import org.telegram.telegrambots.meta.exceptions.TelegramApiException;import ru.taksebe.telegram.mentalCalculation.telegram.commands.operations.MinusCommand;import ru.taksebe.telegram.mentalCalculation.telegram.commands.operations.PlusCommand;import ru.taksebe.telegram.mentalCalculation.telegram.commands.operations.PlusMinusCommand;import ru.taksebe.telegram.mentalCalculation.telegram.commands.service.HelpCommand;import ru.taksebe.telegram.mentalCalculation.telegram.commands.service.SettingsCommand;import ru.taksebe.telegram.mentalCalculation.telegram.commands.service.StartCommand;import ru.taksebe.telegram.mentalCalculation.telegram.nonCommand.NonCommand;import ru.taksebe.telegram.mentalCalculation.telegram.nonCommand.Settings;import java.util.HashMap;import java.util.Map;public final class Bot extends TelegramLongPollingCommandBot {    private final String BOT_NAME;    private final String BOT_TOKEN;    //Класс для обработки сообщений, не являющихся командой    private final NonCommand nonCommand;    /**     * Настройки файла для разных пользователей. Ключ - уникальный id чата     */    @Getter    private static Map<Long, Settings> userSettings;    public Bot(String botName, String botToken) {        super();        this.BOT_NAME = botName;        this.BOT_TOKEN = botToken;        //создаём вспомогательный класс для работы с сообщениями, не являющимися командами        this.nonCommand = new NonCommand();        //регистрируем команды        register(new StartCommand("start", "Старт"));        register(new PlusCommand("plus", "Сложение"));        register(new MinusCommand("minus", "Вычитание"));        register(new PlusMinusCommand("plusminus", "Сложение и вычитание"));        register(new HelpCommand("help","Помощь"));        register(new SettingsCommand("settings", "Мои настройки"));        userSettings = new HashMap<>();    }    @Override    public String getBotToken() {        return BOT_TOKEN;    }    @Override    public String getBotUsername() {        return BOT_NAME;    }    /**     * Ответ на запрос, не являющийся командой     */    @Override    public void processNonCommandUpdate(Update update) {        Message msg = update.getMessage();        Long chatId = msg.getChatId();        String userName = getUserName(msg);        String answer = nonCommand.nonCommandExecute(chatId, userName, msg.getText());        setAnswer(chatId, userName, answer);    }    /**     * Формирование имени пользователя     * @param msg сообщение     */    private String getUserName(Message msg) {        User user = msg.getFrom();        String userName = user.getUserName();        return (userName != null) ? userName : String.format("%s %s", user.getLastName(), user.getFirstName());    }    /**     * Отправка ответа     * @param chatId id чата     * @param userName имя пользователя     * @param text текст ответа     */    private void setAnswer(Long chatId, String userName, String text) {        SendMessage answer = new SendMessage();        answer.setText(text);        answer.setChatId(chatId.toString());        try {            execute(answer);        } catch (TelegramApiException e) {            //логируем сбой Telegram Bot API, используя userName        }    }}

import ru.taksebe.telegram.mentalCalculation.exceptions.IllegalSettingsException;import ru.taksebe.telegram.mentalCalculation.telegram.Bot;/** * Обработка сообщения, не являющегося командой (т.е. обычного текста не начинающегося с "/") */public class NonCommand {    public String nonCommandExecute(Long chatId, String userName, String text) {        Settings settings;        String answer;        try {            //создаём настройки из сообщения пользователя            settings = createSettings(text);            //добавляем настройки в мапу, чтобы потом их использовать для этого пользователя при генерации файла            saveUserSettings(chatId, settings);            answer = "Настройки обновлены. Вы всегда можете их посмотреть с помощью /settings";            //логируем событие, используя userName        } catch (IllegalSettingsException e) {            answer = e.getMessage() +                    "\n\n Настройки не были изменены. Вы всегда можете их посмотреть с помощью /settings";            //логируем событие, используя userName        } catch (Exception e) {            answer = "Простите, я не понимаю Вас. Возможно, Вам поможет /help";            //логируем событие, используя userName        }        return answer;    }    /**     * Создание настроек из полученного пользователем сообщения     * @param text текст сообщения     * @throws IllegalArgumentException пробрасывается, если сообщение пользователя не соответствует формату     */    private Settings createSettings(String text) throws IllegalArgumentException {        //отсекаем файлы, стикеры, гифки и прочий мусор        if (text == null) {            throw new IllegalArgumentException("Сообщение не является текстом");        }        //создаём из сообщения пользователя 3 числа-настройки (min, max, listCount) либо пробрасываем исключение о несоответствии сообщения требуемому формату        return new Settings(min, max, listCount);    }    /**     * Добавление настроек пользователя в мапу, чтобы потом их использовать для этого пользователя при генерации файла     * Если настройки совпадают с дефолтными, они не сохраняются, чтобы впустую не раздувать мапу     * @param chatId id чата     * @param settings настройки     */    private void saveUserSettings(Long chatId, Settings settings) {        if (!settings.equals(Settings.getDefaultSettings())) {            Bot.getUserSettings().put(chatId, settings);        }    }}

Классы команд

• Сервисные возвращают справочную информацию;
• Основные формируют файл с заданиями.

import org.telegram.telegrambots.extensions.bots.commandbot.commands.BotCommand;import org.telegram.telegrambots.meta.api.methods.send.SendMessage;import org.telegram.telegrambots.meta.bots.AbsSender;import org.telegram.telegrambots.meta.exceptions.TelegramApiException;/** * Суперкласс для сервисных команд */abstract class ServiceCommand extends BotCommand {    ServiceCommand(String identifier, String description) {        super(identifier, description);    }    /**     * Отправка ответа пользователю     */    void sendAnswer(AbsSender absSender, Long chatId, String commandName, String userName, String text) {        SendMessage message = new SendMessage();        //включаем поддержку режима разметки, чтобы управлять отображением текста и добавлять эмодзи        message.enableMarkdown(true);        message.setChatId(chatId.toString());        message.setText(text);        try {            absSender.execute(message);        } catch (TelegramApiException e) {            //логируем сбой Telegram Bot API, используя commandName и userName        }    }}

import org.telegram.telegrambots.meta.api.objects.Chat;import org.telegram.telegrambots.meta.api.objects.User;import org.telegram.telegrambots.meta.bots.AbsSender;/** * Команда "Старт" */public class StartCommand extends ServiceCommand {    public StartCommand(String identifier, String description) {        super(identifier, description);    }    @Override    public void execute(AbsSender absSender, User user, Chat chat, String[] strings) {        //формируем имя пользователя - поскольку userName может быть не заполнено, для этого случая используем имя и фамилию пользователя        String userName = (user.getUserName() != null) ? user.getUserName() :                String.format("%s %s", user.getLastName(), user.getFirstName());        //обращаемся к методу суперкласса для отправки пользователю ответа        sendAnswer(absSender, chat.getId(), this.getCommandIdentifier(), userName,                "Давайте начнём! Если Вам нужна помощь, нажмите /help");    }}

import org.telegram.telegrambots.extensions.bots.commandbot.commands.BotCommand;import org.telegram.telegrambots.meta.api.methods.send.SendDocument;import org.telegram.telegrambots.meta.api.methods.send.SendMessage;import org.telegram.telegrambots.meta.api.objects.InputFile;import org.telegram.telegrambots.meta.bots.AbsSender;import org.telegram.telegrambots.meta.exceptions.TelegramApiException;import ru.taksebe.telegram.mentalCalculation.calculation.Calculator;import ru.taksebe.telegram.mentalCalculation.calculation.PlusMinusService;import ru.taksebe.telegram.mentalCalculation.enums.OperationEnum;import ru.taksebe.telegram.mentalCalculation.fileProcessor.WordFileProcessorImpl;import ru.taksebe.telegram.mentalCalculation.telegram.Settings;import java.io.FileInputStream;import java.io.IOException;import java.util.List;/** * Суперкласс для команд создания заданий с различными операциями */abstract class OperationCommand extends BotCommand {    private PlusMinusService service;    OperationCommand(String identifier, String description) {        super(identifier, description);        this.service = new PlusMinusService(new WordFileProcessorImpl(), new Calculator());    }    /**     * Отправка ответа пользователю     */    void sendAnswer(AbsSender absSender, Long chatId, List<OperationEnum> operations, String description, String commandName, String userName) {        try {            absSender.execute(createDocument(chatId, operations, description));        } catch (IOException | IllegalArgumentException e) {            sendError(absSender, chatId, commandName, userName);            e.printStackTrace();        } catch (TelegramApiException e) {            //логируем сбой Telegram Bot API, используя commandName и userName        }    }    /**     * Создание документа для отправки пользователю     * @param chatId id чата     * @param operations список типов операций (сложение и/или вычитание)     * @param fileName имя, которое нужно присвоить файлу     */    private SendDocument createDocument(Long chatId, List<OperationEnum> operations, String fileName) throws IOException {        FileInputStream stream = service.getPlusMinusFile(operations, Bot.getUserSettings(chatId));        SendDocument document = new SendDocument();        document.setChatId(chatId.toString());        document.setDocument(new InputFile(stream, String.format("%s.docx", fileName)));        return document;    }    /**     * Отправка пользователю сообщения об ошибке     */    private void sendError(AbsSender absSender, Long chatId, String commandName, String userName) {        try {            absSender.execute(new SendMessage(chatId.toString(), "Похоже, я сломался. Попробуйте позже"));        } catch (TelegramApiException e) {            //логируем сбой Telegram Bot API, используя commandName и userName        }    }}

import org.telegram.telegrambots.meta.api.objects.Chat;import org.telegram.telegrambots.meta.api.objects.User;import org.telegram.telegrambots.meta.bots.AbsSender;import ru.taksebe.telegram.mentalCalculation.enums.OperationEnum;/** * Команда получение файла с заданиями на сложение и вычитание */public class PlusMinusCommand extends OperationCommand {    public PlusMinusCommand(String identifier, String description) {        super(identifier, description);    }    @Override    public void execute(AbsSender absSender, User user, Chat chat, String[] strings) {        //формируем имя пользователя - поскольку userName может быть не заполнено, для этого случая используем имя и фамилию пользователя        String userName = (user.getUserName() != null) ? user.getUserName() :                String.format("%s %s", user.getLastName(), user.getFirstName());        //обращаемся к методу суперкласса для формирования файла на сложение и вычитание (за это отвечает метод getPlusMinus() перечисления OperationEnum) и отправки его пользователю        sendAnswer(absSender, chat.getId(), OperationEnum.getPlusMinus(), this.getDescription(), this.getCommandIdentifier(), userName);    }}

Приложение

import org.telegram.telegrambots.meta.TelegramBotsApi;import org.telegram.telegrambots.meta.exceptions.TelegramApiException;import org.telegram.telegrambots.updatesreceivers.DefaultBotSession;import ru.taksebe.telegram.mentalCalculation.telegram.Bot;import java.util.Map;public class MentalCalculationApplication {    private static final Map<String, String> getenv = System.getenv();    public static void main(String[] args) {        try {            TelegramBotsApi botsApi = new TelegramBotsApi(DefaultBotSession.class);            botsApi.registerBot(new Bot(getenv.get("BOT_NAME"), getenv.get("BOT_TOKEN")));        } catch (TelegramApiException e) {            e.printStackTrace();        }    }}

Деплой на heroku

1. Регистрируемся на heroku и идём в консоль;
2. mvn clean install;
3. heroku login после выполнения потребуется нажать любую клавишу и залогиниться в открывшемся окне браузера;
4. heroku create <имя приложения> создаём приложение на heroku;
5. git push heroku master пушим в репозиторий heroku;
6. heroku config:set BOT_NAME=<имя бота> добавляем имя бота в переменные окружения;
7. heroku config:set BOT_TOKEN=<токен бота> добавляем токен бота в переменные окружения;
8. heroku config:get BOT_NAME (аналогично BOT_TOKEN) убеждаемся, что переменные окружения установлены верно;
9. heroku ps:scale worker=1 устанавливаем количество контейнеров (dynos) для типа процесса worker (ранее мы выбрали этот тип в Procfile), при этом происходит рестарт приложения;
10. В интерфейсе управления приложением в личном кабинете на heroku переходим к логам (прячутся под кнопкой More в правом верхнем углу) и убеждаемся, что приложение запущено;
11. Тестируем бота через Telegram.

Вместо заключения

Почему Telegram

Бот для покупателей

Бот доставки

1. Курьер отмечается в чате с ботом, что готов к работе.
2. Получает от бота уведомление, что появился новый заказ, который надо доставить.
3. Видит свободные для доставки заказы на карте, прикидывает, какие сейчас удобнее и быстрее всего доставить.
4. Получает возможность построить маршрут в навигаторе для поездки, а также может связаться с покупателем по номеру телефона.
5. Когда доставляет заказ покупателю (или возвращает в магазин по какой-то причине), то отписывается в чат боту. Бот меняет статус заказа.

Другие внутренние боты

В предыдущей публикации мы разобрались как создать бота, инициализировали экземпляр класса Bot и ознакомились с методами отправки сообщений с его помощью.

В этой статье я продолжаю данную тему, поэтому приступать к чтению данной статьи я рекомендую только после прочтения первой части.

В этот раз мы разберёмся как оживить нашего бота и добавим ему поддержку команд, а также познакомимся с классом Updater.

В ходе статьи мы напишем нескольких простых ботов, последний будет по заданной дате и коду страны определять является ли день в данной стране выходным или рабочим согласно производственного календаря. Но, как и прежде цель статьи ознакомить вас с интерфейсом пакета telegram.bot для решения ваших собственных задач.

Все статьи из серии "Пишем telegram бота на языке R"

1. Создаём бота, и отправляем с его помощью сообщения в telegram
2. Добавляем боту поддержку команд и фильтры сообщений

Содержание

1. Класс Updater
2. Handlers обработчики
3. Добавляем первую команду боту, обработчик команд
4. Обработчик текстовых сообщений и фильтры
5. Добавление команд с параметрами
6. Запускаем бота в фоновом режиме
7. Заключение

Класс Updater

Updater это класс, который упрощает вам разработку телеграм бота, и использует под капотом класс Dispetcher. Назначение класса Updater заключается в том, что бы получить обновления от бота (в предыдущей статье мы использовали для этой цели метод getUpdates()), и передать их далее в Dispetcher.

В свою очередь Dispetcher содержит в себе созданные вами обработчики, т.е. объекты класса Handler.

Handlers обработчики

С помощью обработчиков вы добавляете в Dispetcher реакции бота на различные события. На момент написания статьи в telegram.bot добавлены следующие типы обработчиков:

• MessageHandler Обработчик сообщений
• CommandHandler Обработчик команд
• CallbackQueryHandler Обработчик данных отправляемых из Inline клавиатур
• ErrorHandler Обработчик ошибок при запросе обновлений от бота

Добавляем первую команду боту, обработчик команд

Если вы никогда ранее не использовали ботов, и не в курсе, что такое команда, то команды боту необходимо отправлять с помощью прямого слеша / в качестве префикса.

Начнём мы с простых команд, т.е. научим нашего бота здороваться по команде /hi.

library(telegram.bot)# создаём экземпляр класса Updaterupdater <- Updater('ТОКЕН ВАШЕГО БОТА')# Пишем метод для приветсвияsay_hello <- function(bot, update) {  # Имя пользователя с которым надо поздароваться  user_name <- update$message$from$first_name  # Отправка приветственного сообщения  bot$sendMessage(update$message$chat_id,                   text = paste0("Моё почтение, ", user_name, "!"),                   parse_mode = "Markdown")}# создаём обработчик hi_hendler <- CommandHandler('hi', say_hello)# добаляем обработчик в диспетчерupdater <- updater + hi_hendler# запускаем ботаupdater$start_polling()

Запустите приведённый выше пример кода, предварительно заменив 'ТОКЕН ВАШЕГО БОТА' на реальный токен, который вы получили при создании бота через BotFather (о создании бота я рассказывал в первой статье).

Метод start_polling() класса Updater, который используется в конце кода, запускает бесконечный цикл запроса и обработки обновлений от бота.

Теперь откроем телеграм, и напишем нашему боту первую команду /hi.

Теперь наш бот понимает команду /hi, и умеет с нами здороваться.

Схематически процесс построения такого простейшего бота можно изобразить следующим образом.

1. Создаём экземпляр класса Updater;
2. Создаём методы, т.е. функции которые будет выполнять наш бот. В примере кода это функция say_hello(). Функции, которые вами будут использоваться как методы бота должны иметь два обязательных аргумента bot и update, и один необязательный args. Аргумент bot, это и есть ваш бот, с его помощью вы можете отвечать на сообщения, отправлять сообщения, или использовать любые другие доступные боту методы. Аргумент update это то, что бот получил от пользователя, по сути, то что в первой статье мы получали методом getUpdates(). Аргумент args позволяет вам обрабатывать дополнительные данные отправленные пользователем вместе с командой, к этой теме мы ещё вернёмся немного позже;
3. Создаём обработчики, т.е. связываем какие-то действия пользователя с созданными на прошлом шаге методами. По сути обработчик это триггер, событие которое вызывает какую-то функцию бота. В нашем примере таким триггером является отправка команды /hi, и реализуется командой hi_hendler <- CommandHandler('hi', say_hello). Первый аргумент функции CommandHandler() позволяет вам задать команду, в нашем случае hi, на которую будет реагировать бот. Второй аргумент позволяет указать метод бота, мы будем вызывать метод say_hello, который будет выполняться если пользователь вызвал указанную в первом аргументе команду;
4. Далее добавляем созданный обработчик в диспетчер нашего экземпляра класса Updater. Добавлять обработчики можно несколькими способами, в примере выше я использовал простейший, с помощью знака +, т.е. updater <- updater + hi_hendler. То же самое можно сделать с помощью метода add_handler(), который относится к классу Dispatcher, найти этот метод можно так: updater$dispatcher$add_handler();
5. Запускаем бота с помощью команды start_polling().

Обработчик текстовых сообщений и фильтры

Как отправлять боту команды мы разобрались, но иногда нам требуется, что бы бот реагировал не только на команды, но и на какие-то обычные, текстовые сообщения. Для этого необходимо использовать обработчики сообщений MessageHandler.

Обычный MessageHandler будет реагировать на абсолютно все входящие сообщения. Поэтому зачастую обработчики сообщений используются вместе с фильтрами. Давайте научим бота здороваться не только по команде /hi, но и всегда, когда в сообщении отправленном боту встречается одно из следующих слов: привет, здравствуй, салют, хай, бонжур.

Пока мы не будем писать какие-то новые методы, т.к. у нас уже есть метод с помощью которого бот с нами здоровается. От нас требуется только создать нужный фильтр и обработчик сообщений.

library(telegram.bot)# создаём экземпляр класса Updaterupdater <- Updater('ТОКЕН ВАШЕГО БОТА')# Пишем метод для приветсвия## команда приветвияsay_hello <- function(bot, update) {  # Имя пользователя с которым надо поздароваться  user_name <- update$message$from$first_name  # Отправляем приветсвенное сообщение  bot$sendMessage(update$message$chat_id,                   text = paste0("Моё почтение, ", user_name, "!"),                  parse_mode = "Markdown",                  reply_to_message_id = update$message$message_id)}# создаём фильтрыMessageFilters$hi <- BaseFilter(function(message) {  # проверяем, встречается ли в тексте сообщения слова: привет, здравствуй, салют, хай, бонжур  grepl(x           = message$text,         pattern     = 'привет|здравствуй|салют|хай|бонжур',        ignore.case = TRUE)  })# создаём обработчик hi_hendler <- CommandHandler('hi', say_hello) # обработчик команды hihi_txt_hnd <- MessageHandler(say_hello, filters = MessageFilters$hi)# добаляем обработчики в диспетчерupdater <- updater +              hi_hendler +             hi_txt_hnd# запускаем ботаupdater$start_polling()

Запустите приведённый выше пример кода, предварительно заменив 'ТОКЕН ВАШЕГО БОТА' на реальный токен, который вы получили при создании бота через BotFather (о создании бота я рассказывал в первой статье).

Теперь попробуем отправить боту несколько сообщений, в которых будут встречаться перечисленные ранее слова приветствия:

Итак, в первую очередь мы научили бота не просто здороваться, а отвечать на приветствие. Сделали мы это с помощью аргумента reply_to_message_id, который доступен в методе sendMessage(), в который необходимо передать id сообщения на которое требуется ответить. Получить id сообщения можно вот так: update$message$message_id.

Но главное, что мы сделали добавили боту фильтр с помощью функции BaseFilter():

# создаём фильтрыMessageFilters$hi <- BaseFilter(   # анонимная фильтрующая функция  function(message) {    # проверяем, встречается ли в тексте сообщения слова приветствия    grepl(x           = message$text,           pattern     = 'привет|здравствуй|салют|хай|бонжур',          ignore.case = TRUE)  })

Как вы могли заметить, фильтры необходимо добавлять в объект MessageFilters, в котором изначально уже есть небольшой набор готовых фильтров. В нашем примере в объект MessageFilters мы добавили элемент hi, это новый фильтр.

В функцию BaseFilter() вам необходимо передать фильтрующую функцию. По сути, фильтр это просто функция, которая получает экземпляр сообщения и возвращает TRUE или FALSE. В нашем примере, мы написали простейшую функцию, которая с помощью базовой функции grepl() проверяет текст сообщения, и если он соответствует регулярному выражению привет|здравствуй|салют|хай|бонжур возвращает TRUE.

Далее мы создаём обработчик сообщений hi_txt_hnd <- MessageHandler(say_hello, filters = MessageFilters$hi). Первый аргумент функции MessageHandler() метод, который будет вызывать обработчик, а второй аргумент это фильтр по которому он будет вызываться. В нашем случае это созданный нами фильтр MessageFilters$hi.

Ну и в итоге, мы добавляем в диспетчер созданный только, что обработчик hi_txt_hnd.

updater <- updater +              hi_hendler +             hi_txt_hnd

Как я уже писал выше, в пакете telegram.bot и объекте MessageFilters уже есть набор встроенных фильтров, которые вы можете использовать:

• all Все сообщения
• text Текстовые сообщения
• command Команды, т.е. сообщения которые начинаются на /
• reply Сообщения, которые являются ответом на другое сообщение
• audio Сообщения в которых содержится аудио файл
• document Сообщения с отправленным документом
• photo Сообщения с отправленными изображениями
• sticker Сообщения с отправленным стикером
• video Сообщения с видео
• voice Голосовые сообщения
• contact Сообщения в которых содержится контант телеграм пользователя
• location Сообщения с геолокацией
• venue Пересылаемые сообщения
• game Игры

Если вы хотите совместить некоторые фильтры в одном обработчике просто используйте знак | в качестве логического ИЛИ, и знак & в качестве логического И. Например, если вы хотите что бы бот вызывал один и тот же метод когда он получает видео, изображение или документ используйте следующий пример создания обработчика сообщений:

handler <- MessageHandler(callback,   MessageFilters$video | MessageFilters$photo | MessageFilters$document)

Добавление команд с параметрами

Мы уже знаем, что такое команды, как их создавать и как заставить бота выполнить нужную команду. Но в некоторых случаях помимо названия команды, нам необходимо передать некоторые данные для её выполнения.

Ниже пример бота, который по заданной дате и стране возвращает вам тип дня из производственного календаря.

Приведённый ниже бот использует API производственного календаря isdayoff.ru.

library(telegram.bot)# создаём экземпляр класса Updaterupdater <- Updater('1165649194:AAFkDqIzQ6Wq5GV0YU7PmEZcv1gmWIFIB_8')# Пишем метод для приветсвия## команда приветвияcheck_date <- function(bot, update, args) {  # входящие данные  day     <- args[1]  # дата  country <- args[2]  # страна  # проверка введённых параметров  if ( !grepl('\\d{4}-\\d{2}-\\d{2}', day) ) {    # Send Custom Keyboard    bot$sendMessage(update$message$chat_id,                     text = paste0(day, " - некорреткная дата, введите дату в формате ГГГГ-ММ-ДД"),                    parse_mode = "Markdown")  } else {    day <- as.Date(day)    # переводим в формат POSIXtl    y <- format(day, "%Y")    m <- format(day, "%m")    d <- format(day, "%d")  }  # страна для проверки  ## проверяем задана ли страна  ## если не задана устанавливаем ru  if ( ! country %in% c('ru', 'ua', 'by', 'kz', 'us') ) {    # Send Custom Keyboard    bot$sendMessage(update$message$chat_id,                     text = paste0(country, " - некорретктный код страны, возможнные значения: ru, by, kz, ua, us. Запрошены данные по России."),                    parse_mode = "Markdown")    country <- 'ru'  }  # запрос данных из API  # компоновка HTTP запроса  url <- paste0("https://isdayoff.ru/api/getdata?",                "year=",  y, "&",                "month=", m, "&",                "day=",   d, "&",                "cc=",    country, "&",                "pre=1&",                "covid=1")  # получаем ответ  res <- readLines(url)  # интрепретация ответа  out <- switch(res,                 "0"   = "Рабочий день",                "1"   = "Нерабочий день",                "2"   = "Сокращённый рабочий день",                "4"   = "covid-19",                "100" = "Ошибка в дате",                "101" = "Данные не найдены",                "199" = "Ошибка сервиса")  # отправляем сообщение  bot$sendMessage(update$message$chat_id,                   text = paste0(day, " - ", out),                  parse_mode = "Markdown")}# создаём обработчик date_hendler <- CommandHandler('check_date', check_date, pass_args = TRUE)# добаляем обработчик в диспетчерupdater <- updater + date_hendler# запускаем ботаupdater$start_polling()

Запустите приведённый выше пример кода, предварительно заменив 'ТОКЕН ВАШЕГО БОТА' на реальный токен, который вы получили при создании бота через BotFather (о создании бота я рассказывал в первой статье).

Мы создали бота, который в арсенале имеет всего один метод check_date, данный метод вызывается одноимённой командой.

Но, помимо имени команды, данный метод ждёт от вас введения двух параметров, код страны и дату. Далее бот проверяется, является ли заданный день в указанной стране выходным, сокращённым или рабочим согласно официального производственного календаря.

Что бы создаваемый нами метод принимал дополнительные параметры вместе с командой, используйте аргумент pass_args = TRUE в функции CommandHandler(), и при создании метода, помимо обязательных аргументов bot, update создайте опциональный args. Созданный таким образом метод будет принимать параметры, которые вы передаёте боту после названия команды. Параметры необходимо между собой разделять пробелом, в метод они поступят в виде текстового вектора.

Давайте запустим, и протестируем нашего бота.

Запускаем бота в фоновом режиме

Последний шаг который нам осталось выполнить запустить бота в фоновом режиме.

Для этого следуйте по описанному ниже алгоритму:

1. Сохраните код бота в файл с расширением R. При работе в RStudio это делается через меню File, командой Save As....
2. Добавьте путь к папке bin, которая в свою очередь находится в папке в которую вы установили язык R в переменную Path, инструкция тут.
3. Создайте обычный текстовый файл, в котором пропишите 1 строку: R CMD BATCH C:\Users\Alsey\Documents\my_bot.R. Вместо C:\Users\Alsey\Documents\my_bot.R пропишите путь к своему скрипту бота. При этом важно, что бы в пути не встречалась кириллица и пробелы, т.к. это может вызвать проблемы при запуске бота. Сохраните его, и замените его расширение с txt на bat.
4. Откройте планировщик заданий Windows, есть множество способов это сделать, например откройте любую папку и в адресс введите %windir%\system32\taskschd.msc /s. Другие способы запуска можно найти тут.
5. В верхнем правом меню планировщика нажмите "Создать задачу...".
6. На вкладке "Общие" задайте произвольное имя вашей задаче, и переключатель перевидите в состояние "Выполнять для всех пользователей".
7. Перейдите на вкладку "Действия", нажмите "Создать". В поле "Программа или сценарий" нажмите "Обзор", найдите созданный на втором шаге bat файл, и нажмите ОК.
8. Жмём ОК, при необходимости вводим пароль от вашей учётной записи операционной системы.
9. Находим в планировщике созданную задачу, выделяем и в нижнем правом углу жмём кнопку "Выполнить".

Наш бот запущен в фоновом режиме, и будет работать до тех пор, пока вы не остановите задачу, или не выключите ваш ПК или сервер на котором его запустили.

Заключение

В этой статье мы разобрались как написать полноценного бота, который не только умеет отправлять сообщения, но и реагировать на входящие сообщения и команды. Полученных знананий уже достаточно для решения большинства ваших задач.

В следующей статье речь пойдёт о том, как добавить боту клавиатуру, для более удобной работы.

В предыдущих статьях мы достаточно подробно разобрали тему ботостроения, от отправки первого сообщения до программирования логического диалога с ботом.

Это последняя статья из данной серии, в которой мы разберёмся с тем, как управлять правами использования отдельных методов бота на различных уровнях.

Все статьи из серии "Пишем telegram бота на языке R"

1. Создаём бота, и отправляем с его помощью сообщения в telegram
2. Добавляем боту поддержку команд и фильтры сообщений
3. Как добавить боту поддержку клавиатуры
4. Построение последовательного, логического диалога с ботом
5. Управление правами пользователей бота

Содержание

Если вы интересуетесь анализом данных возможно вам будут интересны мои telegram и youtube каналы. Большая часть контента которых посвящены языку R.

1. Введение
2. Ограничиваем права пользователя с помощью фильтров сообщений
   2.1. Ограничиваем права на уровне имени пользователя
   2.2. Ограничиваем права на уровне чата
3. Ограничиваем права пользователя внутри кода методов
   3.1. Ограничиваем права на уровне имени пользователя
   3.2. Ограничиваем права на уровне чата
4. Заключение

Введение

Ваш бот может выполнять совершенно любые задачи, и автоматизировать как некоторые внутренние процессы, так и наладить коммуникации с клиентами.

Т.е. бот может использоваться в многопользовательском режиме. При этом, вам может понадобиться разграничить права на использование бота. Например, некоторые пользователи смогут использовать абсолютно все возможности бота, а некоторым вы предоставите ограниченные права.

Ограничить права можно не только на уровне пользователя, но и на уровне отдельных чатов.

Мы создадим простейшего бота, у которого в арсенале будет всего 2 метода:

• say_hello команда приветствия
• what_time команда, по которой бот сообщает текущую дату и время

library(telegram.bot)# создаём экземпляр класса Updaterupdater <- Updater('ТОКЕН ВАШЕГО БОТА')# Пишем метод для приветсвия## команда приветствияsay_hello <- function(bot, update) {  # Имя пользователя с которым надо поздароваться  user_name <- update$message$from$first_name  # Отправка сообщения  bot$sendMessage(update$message$chat_id,                   text = paste0("Моё почтение, ", user_name, "!"),                  parse_mode = "Markdown",                  reply_to_message_id = update$message$message_id)}## команда по которой бот возвращает системную дату и времяwhat_time <- function(bot, update) {  # Запрашиваем текущее время  cur_time <- as.character(Sys.time())  # Отправка сообщения  bot$sendMessage(update$message$chat_id,                   text = paste0("Текущее время, ", cur_time),                                parse_mode = "Markdown",                                reply_to_message_id = update$message$message_id)}# обработчикиh_hello <- CommandHandler('say_hello', say_hello)h_time  <- CommandHandler('what_time', what_time)# добавляем обработчики в диспетчерupdater <- updater + h_hello + h_time# запускаем бота updater$start_polling()

Запустите приведённый выше пример кода, предварительно заменив 'ТОКЕН ВАШЕГО БОТА' на реальный токен, который вы получили при создании бота через BotFather (о создании бота я рассказывал в первой статье).

В статье мы разберёмся с тем, как разными способами, и на разных уровнях ограничить использование методов этого бота.

Ограничиваем права пользователя с помощью фильтров сообщений

Из предыдущих публикаций мы уже разобрались с тем, что такое фильтры сообщений. Но ранее мы использовали их в основном для, того, что бы вызывать какие-то методы бота через обычное сообщение, а не команду и для прослушиваний сообщений в определённом состоянии чата.

В этот раз мы научимся с помощью фильтров ограничивать возможности по использованию методов бота, на разных уровнях.

Ограничиваем права на уровне имени пользователя

Для создания собственных фильтров вам необходимо с помощью функции BaseFilter() добавить новый элемент в объект MessageFilters. Более подробно об этом я рассказывал во второй статье из данной серии.

В анонимную функцию, которую вы прописываете внутри BaseFilter() передаётся всего один аргумент message. Это сообщение которое вы, или другой пользователей отправляет боту, со всеми его метаданными. Данный объект имеет следующую структуру:

$message_id[1] 1174$from$from$id[1] 194336771$from$is_bot[1] FALSE$from$first_name[1] "Alexey"$from$last_name[1] "Seleznev"$from$username[1] "AlexeySeleznev"$from$language_code[1] "ru"$chat$chat$id[1] 194336771$chat$first_name[1] "Alexey"$chat$last_name[1] "Seleznev"$chat$username[1] "AlexeySeleznev"$chat$type[1] "private"$date[1] 1601295189$text[1] "отправленный пользователем текст"$chat_id[1] 194336771$from_user[1] 194336771

Соответственно вы можете разделять права пользователей бота, и его методов используя любую, отправляемую с сообщением информацию. Для того, что бы ограничить круг пользователей которые могут использовать методы вашего бота достаточно создать фильтр:

## список пользователей, с полными правамиMessageFilters$admins <- BaseFilter(  function(message) {    # проверяем от кого отправлено сообщение    message$from$username %in% c('AlexeySeleznev', 'user1', 'user2') })

Где c('AlexeySeleznev', 'user1', 'user2') вектор, с именами пользователей, которые могут использовать все функции бота. Далее этот фильтр мы используем при создании обработчиков.

## фильтр для вызова команды say_helloMessageFilters$say_hello <- BaseFilter(  function(message) {    # проверяем от кого отправлено сообщение    message$text == '/say_hallo'  })## фильтр для вызова команды what_timeMessageFilters$what_time <- BaseFilter(  function(message) {    # проверяем от кого отправлено сообщение    message$text == '/what_time'  })# обработчикиh_hello <- MessageHandler(say_hello, MessageFilters$admins & MessageFilters$say_hello)h_time  <- MessageHandler(what_time, MessageFilters$admins & MessageFilters$what_time)

Теперь нашего бота могут использовать пользователи с логинами AlexeySeleznev, user1, user2. На сообщения отправленные боту другими пользователями он никак не будет реагировать.

Изменённый код нашего бота на данный момент выглядит вот так:

library(telegram.bot)# создаём экземпляр класса Updaterupdater <- Updater('ТОКЕН ВАШЕГО БОТА')# Пишем метод для приветсвия## команда приветствияsay_hello <- function(bot, update) {  # Имя пользователя с которым надо поздароваться  user_name <- update$message$from$first_name  # Отправка сообщения  bot$sendMessage(update$message$chat_id,                   text = paste0("Моё почтение, ", user_name, "!"),                  parse_mode = "Markdown",                  reply_to_message_id = update$message$message_id)}## команда по которой бот возвращает системную дату и времяwhat_time <- function(bot, update) {  # Запрашиваем текущее время  cur_time <- as.character(Sys.time())  # Отправка сообщения  bot$sendMessage(update$message$chat_id,                   text = paste0("Текущее время, ", cur_time),                                parse_mode = "Markdown",                                reply_to_message_id = update$message$message_id)}# фильтры## список пользователей, с полными правамиMessageFilters$admins <- BaseFilter(  function(message) {    # проверяем от кого отправлено сообщение    message$from$username %in% c('AlexeySeleznev', 'user1', 'user2') })## фильтр для вызова команды say_helloMessageFilters$say_hello <- BaseFilter(  function(message) {    # проверяем от кого отправлено сообщение    message$text == '/say_hallo'  })## фильтр для вызова команды what_timeMessageFilters$what_time <- BaseFilter(  function(message) {    # проверяем от кого отправлено сообщение    message$text == '/what_time'  })# обработчикиh_hello <- MessageHandler(say_hello, MessageFilters$admins & MessageFilters$say_hello)h_time  <- MessageHandler(what_time, MessageFilters$admins & MessageFilters$what_time)# добавляем обработчики в диспетчерupdater <- updater + h_hello + h_time# запускаем бота updater$start_polling()

Ограничиваем права на уровне чата

Тем же способом мы можем создать фильтр не только по списку пользователей, но и по конкретному чату. Для этого достаточно создать ещё один фильтр:

## список чатов в которых разрешено использовать ботаMessageFilters$chats <- BaseFilter(  function(message) {    # проверяем от кого отправлено сообщение    message$chat_id %in% c(194336771, 0, 1)  })## фильтр для вызова команды say_helloMessageFilters$say_hello <- BaseFilter(  function(message) {    # проверяем от кого отправлено сообщение    message$text == '/say_hallo'  })## фильтр для вызова команды what_timeMessageFilters$what_time <- BaseFilter(  function(message) {    # проверяем от кого отправлено сообщение    message$text == '/what_time'  })# обработчикиh_hello <- MessageHandler(say_hello, MessageFilters$admins & MessageFilters$chats & MessageFilters$say_hello)h_time  <- MessageHandler(what_time, MessageFilters$admins & MessageFilters$chats & MessageFilters$what_time)

Ограничиваем права пользователя внутри кода методов

Так же вы можете ограничить использование методов не прибегая к созданию дополнительных фильтров, а прописав все условия внутри каждого метода.

Ограничиваем права на уровне имени пользователя

Давайте создадим функцию, которая будет принимать данные для проверки имени пользователя.

# функция для проверки прав пользователяbot_check_usernames <-   function(admins, username) {   username %in% admins }

В аргумент admins далее нам надо передавать список пользователей, которым разрешено использовать данный метод, а в аргумент username имя пользователя, которого надо проверить в списке.

Далее в каждый метод, который мы хотим защитить с помощью конструкции IF добавляем проверку, разрешено пользователю использовать данный метод или нет. В случае если у пользователя нет таких прав бот будет сообщать об этом в чате.

Давайте, для примера, я исключу себя из списка пользователей, которым разрешено использовать метод what_time.

library(telegram.bot)# создаём экземпляр класса Updaterupdater <- Updater('ТОКЕН ВАШЕГО БОТА')# Пишем метод для приветсвия## команда приветствияsay_hello <- function(bot, update) {  # Имя пользователя с которым надо поздароваться  user_name <- update$message$from$username  # проверяем разрешено ли использовать данному пользователю этот метод  if ( bot_check_usernames(c('AlexeySeleznev', 'user1', 'user2'), user_name) ) {    # Отправка сообщения    bot$sendMessage(update$message$chat_id,                     text = paste0("Моё почтение, ", user_name, "!"),                    parse_mode = "Markdown",                    reply_to_message_id = update$message$message_id)  } else {    # Отправка сообщения    bot$sendMessage(update$message$chat_id,                     text = paste0("У вас нет прав для использования этого метода!"),                    parse_mode = "Markdown",                    reply_to_message_id = update$message$message_id)  }}## команда по которой бот возвращает системную дату и времяwhat_time <- function(bot, update) {  # проверяем разрешено ли использовать данному пользователю этот метод  if ( bot_check_usernames(c('user1', 'user2'), update$message$from$username) ) {    # Запрашиваем текущее время    cur_time <- as.character(Sys.time())    # Отправка сообщения о том что у пользователя не достаточно прав    bot$sendMessage(update$message$chat_id,                     text = paste0("Текущее время, ", cur_time),                                  parse_mode = "Markdown",                                  reply_to_message_id = update$message$message_id)  } else {    # Отправка сообщения о том что у пользователя не достаточно прав    bot$sendMessage(update$message$chat_id,                     text = paste0("У вас нет прав для использования этого метода!"),                    parse_mode = "Markdown",                    reply_to_message_id = update$message$message_id)  }}# обработчикиh_hello <- CommandHandler('say_hello', say_hello)h_time  <- CommandHandler('what_time', what_time)# добавляем обработчики в диспетчерupdater <- updater + h_hello + h_time# запускаем бота updater$start_polling()

Результат будет следующим:

Теперь бот не просто игнорирует сообщения от обычных пользователей, а сообщает им, что у них недостаточно прав использовать какой либо метод.

Ограничиваем права на уровне чата

Думаю у вас уже не возникнет трудностей при доработке ваших методов, таким образом, что бы их можно было использовать только в определённых чатах, тем не менее приведу пример.

Напишем функцию, которая будет проверять входит ли текущий чат в список разрешенных.

bot_check_chat_id <-   function(allowed_chats, current_chat) {     current_chat %in% allowed_chats }

Далее используем эту функции внутри наших методов:

library(telegram.bot)# создаём экземпляр класса Updaterupdater <- Updater('ТОКЕН ВАШЕГО БОТА')# Пишем метод для приветсвия## команда приветствияsay_hello <- function(bot, update) {  # Имя пользователя с которым надо поздароваться  user_name <- update$message$from$username  # проверяем разрешено ли использовать данному пользователю этот метод  if ( bot_check_usernames(c('AlexeySeleznev', 'user1', 'user2'), user_name)        &       bot_check_chat_id(c(194336771, 1, 2), update$message$chat_id)) {    # Отправка сообщения    bot$sendMessage(update$message$chat_id,                     text = paste0("Моё почтение, ", user_name, "!"),                    parse_mode = "Markdown",                    reply_to_message_id = update$message$message_id)  } else {    # Отправка сообщения    bot$sendMessage(update$message$chat_id,                     text = paste0("У вас нет прав для использования этого метода!"),                    parse_mode = "Markdown",                    reply_to_message_id = update$message$message_id)  }}## команда по которой бот возвращает системную дату и времяwhat_time <- function(bot, update) {  # проверяем разрешено ли использовать данному пользователю этот метод  if ( bot_check_usernames(c('AlexeySeleznev', 'user1', 'user2'), update$message$from$username)       &       bot_check_chat_id(c(194336771, 1, 2), update$message$chat_id)) {    # Запрашиваем текущее время    cur_time <- as.character(Sys.time())    # Отправка сообщения о том что у пользователя не достаточно прав    bot$sendMessage(update$message$chat_id,                     text = paste0("Текущее время, ", cur_time),                                  parse_mode = "Markdown",                                  reply_to_message_id = update$message$message_id)  } else {    # Отправка сообщения о том что у пользователя не достаточно прав    bot$sendMessage(update$message$chat_id,                     text = paste0("У вас нет прав для использования этого метода!"),                    parse_mode = "Markdown",                    reply_to_message_id = update$message$message_id)  }}# обработчикиh_hello <- CommandHandler('say_hello', say_hello)h_time  <- CommandHandler('what_time', what_time)# добавляем обработчики в диспетчерupdater <- updater + h_hello + h_time# запускаем бота updater$start_polling()

Заключение

На этом серия статей о построении telegram ботов завершается. Я старался структурировать и подавать материал достаточно сжато, убрав всю воду, но при этом сделать так, что бы материал был вам понятен. Очень надеюсь на то, что мне это удалось.

Успехов вам в ботостроении. В комментариях можете написать примеры ваших ботов, и как вы их на практике используете.

Привет Хабр!

Мы с моим приятелем и занимаемся разработкой и поддержкой решений на MS SQL.

Одной из наших проблем при работе с MS SQL было то, что без MS SQL Management Studio невозможно что-то сделать или проверить. А значит всегда нужен под рукой компьютер и VPN в сеть клиента (или что посложнее). Нас это не устраивало мы не всегда сидим перед монитором, а ситуации ингода требуют оперативности, особенно когда дело касается высоких нагрузок в real-time системах. Поэтому мы решили сделать телеграм-бота SQL. (Поискали готовые варианты на Github, но, увы, не нашли того, что нам подошло бы).

Штука оказалась удобной. Вот что она умеет:

1. Для работы нужен только SQL сервер от 2016 и выше (никаких доп. сервисов поднимать не надо)
2. Можно явно привязать своего бота к своему чату (как, есть в инструкции в репозитории). Т.е. никто кроме вас с вашим сервером общаться не сможет.
3. Бот умеет выполнять SQL запросы и структурировано показывать результат:
   
4. Бот умеет выполнять быстрые команды (их можно сконфигурировать самостоятельно) и выводить результат:
   
5. Бот умеет показывать прогресс бар для долгих процессов (например backup/restore)
   
6. Дополнительно:
   a. В комплект с ботом идет простая система мониторинга состояния MS SQL Server
   b. Бот берет из системы мониторинга критическую статистику и публикует в чат

Мы выложили исходники и инструкции по установке на github в открытый доступ.

Если кому-то этот инструмент окажется полезным будем рады. И, конечно, искренне благодарны за обратную связь, контакты есть в репозитории.

П.С.
Хочу выразить благодарносить t0rr, одному из мейнтейнеров aiogram за консультацию и вдохновение на начальном этапе создания