Разработка TELEGRAM-бота на JAVA для генерации и считывания QR-кодов25.11.2021 08:02

package ru.dsci.qrvisor.bot;

import lombok.Data;
import org.telegram.telegrambots.meta.TelegramBotsApi;

import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;

@Data
public class BotSettings {

    public static final String FILE_NAME = "config.properties";
    private static BotSettings instance;
    private Properties properties;
    private String token;
    private String userName;
    private TelegramBotsApi telegramBotsApi;

    public static BotSettings getInstance() {
        if (instance == null)
            instance = new BotSettings();
        return instance;
    }

    {
        try {
            properties = new Properties();
            try (InputStream inputStream = getClass().getClassLoader().getResourceAsStream(FILE_NAME)) {
                properties.load(inputStream);
            } catch (IOException e) {
                throw new IOException(String.format("Error loading properties file '%s'", FILE_NAME));
            }
            token = properties.getProperty("token");
            if (token == null) {
                throw new RuntimeException("Token value is null");
            }
            userName = properties.getProperty("username");
            if (userName == null) {
                throw new RuntimeException("UserName value is null");
            }
        } catch (RuntimeException | IOException e) {
            throw new RuntimeException("Bot initialization error: " + e.getMessage());
        }
    }
}

package ru.dsci.qrvisor.bot;

import com.google.zxing.WriterException;
import org.json.JSONObject;
import org.telegram.telegrambots.meta.api.methods.send.SendPhoto;
import org.telegram.telegrambots.meta.api.objects.InputFile;
import ru.dsci.qrvisor.bot.commands.CommandHelp;
import ru.dsci.qrvisor.bot.commands.CommandStart;
import ru.dsci.qrvisor.core.exceptions.UserException;
import lombok.extern.slf4j.Slf4j;
import org.telegram.telegrambots.extensions.bots.commandbot.TelegramLongPollingCommandBot;
import org.telegram.telegrambots.extensions.bots.commandbot.commands.IBotCommand;
import org.telegram.telegrambots.meta.TelegramBotsApi;
import org.telegram.telegrambots.meta.api.methods.send.SendMessage;
import org.telegram.telegrambots.meta.api.objects.PhotoSize;
import org.telegram.telegrambots.meta.api.objects.Update;
import org.telegram.telegrambots.meta.exceptions.TelegramApiException;
import org.telegram.telegrambots.updatesreceivers.DefaultBotSession;
import ru.dsci.qrvisor.qr.QRTools;

import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;

@Slf4j
public class BotProcessor extends TelegramLongPollingCommandBot {

    private final static int TEXT_LIMIT = 512;
    private final static BotSettings botSettings = BotSettings.getInstance();
    private static BotProcessor instance;
    private final TelegramBotsApi telegramBotsApi;
    private List registeredCommands = new ArrayList<>();

    private MessageType getMessageType(Update update) throws UserException {
        MessageType messageType = null;
        try {
            if (update.getMessage().getPhoto() != null)
                messageType = MessageType.IMAGE;
            else if (update.getMessage().getText() != null)
                messageType = (update.getMessage().getText().matches("^/[\\w]*$")) ?
                        MessageType.COMMAND :
                        MessageType.TEXT;
            if (messageType == null)
                throw new IllegalArgumentException(update.toString());
            return messageType;
        } catch (RuntimeException e) {
            log.error(String.format("Invalid message type: %s", e.getMessage()));
            throw new UserException("Неподдерживаемый тип сообщения");
        }
    }

    public void sendMessage(Long chatId, String message) {
        try {
            SendMessage sendMessage = SendMessage
                    .builder()
                    .chatId(chatId.toString())
                    .text(message)
                    .build();
            execute(sendMessage);
        } catch (TelegramApiException e) {
            log.error(String.format("Sending message error: %s", e.getMessage()));
        }
    }

    public void sendImage(Long chatId, String path) throws UserException {
        try {
            SendPhoto photo = new SendPhoto();
            photo.setPhoto(new InputFile(new File(path)));
            photo.setChatId(chatId.toString());
            execute(photo);
        } catch (TelegramApiException e) {
            log.error(String.format("Sending image error: %s", e.getMessage()));
            throw new UserException("Ошибка отправки изображения");
        }
    }

    public void sendQRImage(Long chatId, String path) throws UserException {
        sendImage(chatId, path);
        File file = new File(path);
        if (!file.delete()) {
            log.error(String.format("File '%s' removing error", path));
        }
    }

    private void processText(Update update) throws TelegramApiException, IOException, WriterException, UserException {
        String text = update.getMessage().getText();
        logMessage(
                update.getMessage().getChatId(),
                update.getMessage().getFrom().getId(),
                true,
                text);
        if (text.length() > TEXT_LIMIT) {
            log.error(String.format("Message exceeds maximum length of %d", TEXT_LIMIT));
            throw new UserException(String.format("Сообщение превышает максимальную длину %d символов", TEXT_LIMIT));
        }
        String imageUrl = QRTools.encodeText(text);
        logMessage(update.getMessage().getChatId(), update.getMessage().getFrom().getId(), false, "$image");
        sendQRImage(update.getMessage().getChatId(), imageUrl);
    }

    private void processImage(Update update) throws TelegramApiException, IOException, UserException {
        logMessage(update.getMessage().getChatId(), update.getMessage().getFrom().getId(), true, "$image");
        List photoSizes = update.getMessage().getPhoto();
        String fileUrl = getFileUrl(update.getMessage().getPhoto().get(photoSizes.size() - 1).getFileId());
        String text = QRTools.getTextFromQR(fileUrl);
        logMessage(update.getMessage().getChatId(), update.getMessage().getFrom().getId(), false, text);
        sendMessage(update.getMessage().getChatId(), text);
    }

    private JSONObject getFileRequest(String fileId) throws IOException {
        String fileUrl = String.format("https://api.telegram.org/bot%s/getFile?file_id=%s",
                botSettings.getToken(),
                fileId);
        return IOTools.readJsonFromUrl(fileUrl);
    }

    private String getFileUrl(String fileId) throws IOException {
        JSONObject jsonObject = getFileRequest(fileId);
        return String.format("https://api.telegram.org/file/bot%s/%s",
                botSettings.getToken(),
                jsonObject.get("file_path"));
    }

    @Override
    public String getBotUsername() {
        return botSettings.getUserName();
    }

    @Override
    protected void processInvalidCommandUpdate(Update update) {
        String command = update.getMessage().getText().substring(1);
        sendMessage(
                update.getMessage().getChatId()
                , String.format("Некорректная команда [%s], доступные команды: %s"
                        , command
                        , registeredCommands.toString()));
    }

    @Override
    public void processNonCommandUpdate(Update update) {
        if (update.hasMessage()) {
            try {
                MessageType messageType = getMessageType(update);
                switch (messageType) {
                    case COMMAND:
                        processInvalidCommandUpdate(update);
                        break;
                    case IMAGE:
                        processImage(update);
                        break;
                    case TEXT:
                        processText(update);
                        break;
                }
            } catch (UserException e) {
                sendMessage(update.getMessage().getChatId(), e.getMessage());
            } catch (TelegramApiException | RuntimeException | IOException | WriterException e) {
                log.error(String.format("Received message processing error: %s", e.getMessage()));
                sendMessage(update.getMessage().getChatId(), "Ошибка обработки сообщения");
            }
        }
    }

    @Override
    public String getBotToken() {
        return botSettings.getToken();
    }

    @Override
    public void onRegister() {
        super.onRegister();
    }

    private void logMessage(Long chatId, Long userId, boolean input, String text) {
        if (text.length() > TEXT_LIMIT)
            text = text.substring(0, TEXT_LIMIT);
        log.info(String.format("CHAT [%d] MESSAGE %s %d: %s", chatId, input ? "FROM" : "TO", userId, text));
    }

    private void setRegisteredCommands() {
        registeredCommands = getRegisteredCommands()
                .stream()
                .map(IBotCommand::getCommandIdentifier)
                .collect(Collectors.toList());
    }

    private void registerCommands() {
        registerCommands();
        register(new CommandStart());
        register(new CommandHelp());
        setRegisteredCommands();
    }

    public void registerBot() {
        try {
            telegramBotsApi.registerBot(this);
        } catch (TelegramApiException e) {
            throw new RuntimeException("Telegram API initialization error: " + e.getMessage());
        }
    }

    {
        try {
            telegramBotsApi = new TelegramBotsApi(DefaultBotSession.class);
            registerBot();
            registerCommands();
        } catch (TelegramApiException e) {
            throw new RuntimeException("Telegram Bot initialization error: " + e.getMessage());
        }
    }

    public static BotProcessor getInstance() {
        if (instance == null)
            instance = new BotProcessor();
        return instance;
    }

    public BotProcessor() {
        super();
    }
}

package ru.dsci.qrvisor.bot.commands;

import lombok.extern.slf4j.Slf4j;
import org.telegram.telegrambots.extensions.bots.commandbot.commands.IBotCommand;
import org.telegram.telegrambots.meta.api.methods.send.SendMessage;
import org.telegram.telegrambots.meta.api.objects.Message;
import org.telegram.telegrambots.meta.bots.AbsSender;
import org.telegram.telegrambots.meta.exceptions.TelegramApiException;

import java.util.Arrays;

@Slf4j
public abstract class Command implements IBotCommand {

    private final String commandIdentifier;
    private final String description;

    public Command(String commandIdentifier, String description) {
        this.commandIdentifier = commandIdentifier;
        this.description = description;
    }

    @Override
    public String getCommandIdentifier() {
        return commandIdentifier;
    }

    @Override
    public String getDescription() {
        return description;
    }

    @Override
    public void processMessage(AbsSender absSender, Message message, String[] strings) {
        log.debug(String.format(String.format("COMMAND: %s(%s)", message.getText(), Arrays.toString(strings))));
        try {
            SendMessage sendMessage = SendMessage
                    .builder()
                    .chatId(message.getChatId().toString())
                    .text(message.getText())
                    .build();
            absSender.execute(sendMessage);
        } catch (TelegramApiException e) {
            log.error(String.format("Command message processing error: %s", e.getMessage(), e));
        }
    }
}

package ru.dsci.qrvisor.bot.commands;

import org.telegram.telegrambots.meta.api.objects.Message;
import org.telegram.telegrambots.meta.bots.AbsSender;

public class CommandStart extends Command {

    @Override
    public void processMessage(AbsSender absSender, Message message, String[] strings) {
        message.setText("Добро пожаловать! \n"
                + "Вас приветствует бот @QRVisorBot, у меня простые функции: чтение и генерация QR-кодов. \n"
                + "Начнём?"
        );
        super.processMessage(absSender, message, null);
    }

    public CommandStart() {
        super("start", "Запуск бота");
    }

package ru.dsci.qrvisor.bot.commands;

import org.telegram.telegrambots.meta.api.objects.Message;
import org.telegram.telegrambots.meta.bots.AbsSender;

public class CommandHelp extends Command {

    @Override
    public void processMessage(AbsSender absSender, Message message, String[] strings) {
        message.setText("Функции чат-бота: \n" +
                "- считывание QR-кода: для считывания QR-кода сфотографируйте код и отправьте изображение в чат \n" +
                "- генерация QR-кода: для генерации QR-кода отправьте текст или ссылку в чат");
        super.processMessage(absSender, message, strings);
    }

    public CommandHelp() {
        super("help", "Справка \\help \n");
    }

}

package ru.dsci.qrvisor;

import ru.dsci.qrvisor.bot.BotProcessor;
import lombok.extern.slf4j.Slf4j;

@Slf4j
public class Main {

    public static void main(String[] args) {
        try {
            BotProcessor botProcessor = BotProcessor.getInstance();
            log.info("Telegram bot started");
        } catch (Throwable e) {
            log.error(e.getMessage(), e);
        }
    }
}

package ru.dsci.qrvisor.qr;

import com.google.zxing.*;
import com.google.zxing.client.j2se.BufferedImageLuminanceSource;
import com.google.zxing.client.j2se.MatrixToImageWriter;
import com.google.zxing.common.BitMatrix;
import com.google.zxing.common.HybridBinarizer;
import com.google.zxing.qrcode.QRCodeWriter;
import lombok.extern.slf4j.Slf4j;

import javax.imageio.ImageIO;
import java.io.IOException;
import java.net.MalformedURLException;
import java.net.URL;
import java.nio.file.FileSystems;
import java.nio.file.Path;
import java.util.*;

@Slf4j
public class QRTools {

    private static final String FILE_FORMAT = "png";
    public static final String CHARSET = "UTF-8";
    private static final QRSIze DEFAULT_VERSION = QRSIze.MEDIUM;
    private static final HashMap qrSizes;

    private static int getQRSize(QRSIze QRSIze) {
        return qrSizes.get(QRSIze);
    }

    private static BinaryBitmap getBitmapFromUrl(String url) throws IOException {
        BinaryBitmap binaryBitmap;
        try {
            binaryBitmap = new BinaryBitmap(new HybridBinarizer(
                    new BufferedImageLuminanceSource(ImageIO.read(new URL(url)))));
        } catch (IOException e) {
            log.error(String.format("{QRTools.getBitmapFromUrl}: %s", e.getMessage()));
            throw new IOException(String.format("Unable to decrypt QR-code: %s", e.getMessage()));
        }
        return binaryBitmap;
    }

    private static Result decodeBitmap(BinaryBitmap binaryBitmap) {
        Result result;
        try {
            result = new MultiFormatReader().decode(binaryBitmap);
        } catch (NotFoundException e) {
            throw new IllegalArgumentException(String.format("Image does not contain QR-code: %s", e.getMessage()));
        }
        return result;
    }

    public static String encodeText(String text, int width, int height)
            throws WriterException, IOException {
        QRCodeWriter qrCodeWriter = new QRCodeWriter();
        Hashtable hashtable = new Hashtable();
        hashtable.put(EncodeHintType.CHARACTER_SET, CHARSET);
        BitMatrix bitMatrix = qrCodeWriter.encode(text, BarcodeFormat.QR_CODE, width, height, hashtable);
        Path path = FileSystems.getDefault().getPath(String.format("./images/%s.%s", UUID.randomUUID(), FILE_FORMAT));
        MatrixToImageWriter.writeToPath(bitMatrix, "PNG", path);
        return path.toAbsolutePath().toString();
    }

    public static String encodeText(String text, QRSIze QRSIze)
            throws WriterException, IOException {
        int size = getQRSize(QRSIze);
        return encodeText(text, size, size);
    }

    public static String encodeText(String text)
            throws WriterException, IOException {
        return encodeText(text, DEFAULT_VERSION);
    }

    public static String getTextFromQR(String url) throws IOException {
        Result result;
        try {
            result = decodeBitmap(getBitmapFromUrl(url));
        } catch (RuntimeException | MalformedURLException e) {
            log.debug(String.format("decodeQR: %s", e.getMessage()));
            throw new IOException(String.format("Unable to decrypt QR-code: %s", e.getMessage()));
        }
        return result.getText();
    }

    static {
        qrSizes = new HashMap<>(Map.ofEntries(
                new AbstractMap.SimpleEntry<>(QRSIze.SMALL, 256),
                new AbstractMap.SimpleEntry<>(QRSIze.MEDIUM, 512),
                new AbstractMap.SimpleEntry<>(QRSIze.LARGE, 1024))
        );
    }
}

package ru.dsci.qrvisor.core.exceptions;

public class UserException extends Exception {
    public UserException(String message) {
        super(message);
    }
}