PART 1 Aloha! In the previous article, we created a simple bot that welcomed us to any event. We've already written thousands of lines of code, and it's time to add more complex functionality to our bot. Today we will try to write a simple bot so that in our free time we can hone our knowledge of Java Core before interviews (surprisingly, I have not found a single working bot of this kind). To do this we will do the following:
- connect an external Postgres database to Heroku;
- Let's write our first scripts to initialize and populate the database;
- let's connect Spring Boot Data JPA to work with the database;
- We implement various scenarios of bot behavior.
- register on Heroku ;
- Go to our dashboard -> New -> Create new app and create a new application;
- We go into the newly created application, we are intimidated by the many buttons, but we concentrate on the “Installed add-ons” panel - next to it there is a Configure Add-ons button, we click it;
- Enter “Heroku Postgres” into the search, select the “Hobby Dev - Free” plan -> Submit Order Form;
- Open the newly obtained database -> Settings -> View Credentials. This tab will contain our keys for accessing the database. We remember their location - we will need them to connect the database, like DataSource in IDEA.
- Lombok is a library thanks to which we will significantly reduce the amount of different code. With it we can automatically create constructors, setters, getters and much more.
- Spring Data JPA is a framework for working with databases (although it sounds too simple). The description of the capabilities of Spring Data JPA would amount to a series of articles, and the dependency we specified also entails Hibernate and much more, so let’s skip the details and just try to write something using Spring JPA today.
- PostgreSQL - we pull the library to get a driver that will work with our database.
DROP TABLE IF EXISTS java_quiz;
DROP TABLE IF EXISTS users;
CREATE SEQUENCE global_seq START WITH 100000;
CREATE TABLE users
(
id INTEGER PRIMARY KEY DEFAULT nextval('global_seq'),
chat_id INTEGER UNIQUE NOT NULL,
name VARCHAR NOT NULL,
score INTEGER DEFAULT 0 NOT NULL,
high_score INTEGER DEFAULT 0 NOT NULL,
bot_state VARCHAR NOT NULL
);
CREATE TABLE java_quiz
(
id INTEGER PRIMARY KEY DEFAULT nextval('global_seq'),
question VARCHAR NOT NULL,
answer_correct VARCHAR NOT NULL,
option1 VARCHAR NOT NULL,
option2 VARCHAR NOT NULL,
option3 VARCHAR NOT NULL
);
What does our script do? The first two lines erase tables, if present, to recreate them. The third line creates a sequence that will be used to create unique id entries in our database. Next we create two tables: for users and for questions. The user will have a unique id, telegram chat id, name, number of points (current and maximum), as well as the current status of the bot. Questions will also have a unique id, as well as fields responsible for the question and answer options for it. We can execute the resulting script by right-clicking on it and selecting "Execute SQL Script". Particular attention should be paid to the “Cmd-Line interface” item - here we will need freshly installed PostgreSQL. When configuring this field, select "New Cmd-Line interface" and specify the path to psql.exe. As a result, the settings should look something like this: We execute the script and if we haven’t made a mistake anywhere, the result of our work will be as follows: <h3>Create a model</h3>Now it’s time to return to writing Java code. To shorten the article, I will omit the description of the annotations used to write the classes so that you can familiarize yourself with them. Let's create a model package in which we will have three classes:
- AbstractBaseEntity is a class that describes any object that can have an id (this class is a strong simplification of what you might see in an internship):
package com.whiskels.telegram.model; import lombok.Getter; import lombok.Setter; import javax.persistence.*; // Аннотация, которая говорит нам, что это суперкласс для всех Entity // https://vladmihalcea.com/how-to-inherit-properties-from-a-base-class-entity-using-mappedsuperclass-with-jpa-and-hibernate/ @MappedSuperclass // http://stackoverflow.com/questions/594597/hibernate-annotations-which-is-better-field-or-property-access @Access(AccessType.FIELD) // Аннотации Lombok для автогенерации сеттеров и геттеров на все поля @Getter @Setter public abstract class AbstractBaseEntity { // Аннотации, описывающие механизм генерации id - разберитесь в documentации каждой! @Id @SequenceGenerator(name = "global_seq", sequenceName = "global_seq", allocationSize = 1, initialValue = START_SEQ) @GeneratedValue(strategy = GenerationType.SEQUENCE, generator = "global_seq") // See https://hibernate.atlassian.net/browse/HHH-3718 and https://hibernate.atlassian.net/browse/HHH-12034 // Proxy initialization when accessing its identifier managed now by JPA_PROXY_COMPLIANCE setting protected Integer id; protected AbstractBaseEntity() { } }
- User :
package com.whiskels.telegram.model; import com.whiskels.telegram.bot.State; import lombok.AllArgsConstructor; import lombok.Getter; import lombok.NoArgsConstructor; import lombok.Setter; import org.hibernate.annotations.BatchSize; import javax.persistence.*; import javax.validation.constraints.NotBlank; import javax.validation.constraints.NotNull; import java.util.Set; import static javax.persistence.FetchType.EAGER; @Entity @Table(name = "users", uniqueConstraints = {@UniqueConstraint(columnNames = "chat_id", name = "users_unique_chatid_idx")}) @Getter @Setter @NoArgsConstructor @AllArgsConstructor public class User extends AbstractBaseEntity { @Column(name = "chat_id", unique = true, nullable = false) @NotNull private Integer chatId; @Column(name = "name", unique = true, nullable = false) @NotBlank private String name; @Column(name = "score", nullable = false) @NotNull private Integer score; @Column(name = "high_score", nullable = false) @NotNull private Integer highScore; @Column(name = "bot_state", nullable = false) @NotBlank private State botState; // Конструктор нужен для создания нового пользователя (а может и нет? :)) public User(int chatId) { this.chatId = chatId; this.name = String.valueOf(chatId); this.score = 0; this.highScore = 0; this.botState = State.START; } }
- Question class :
package com.whiskels.telegram.model; import lombok.AllArgsConstructor; import lombok.Getter; import lombok.NoArgsConstructor; import lombok.Setter; import javax.persistence.Column; import javax.persistence.Entity; import javax.persistence.Table; import javax.validation.constraints.NotBlank; @Entity @Table(name = "java_quiz") @Getter @Setter @NoArgsConstructor @AllArgsConstructor public class Question extends AbstractBaseEntity { @Column(name = "question", nullable = false) @NotBlank private String question; @Column(name = "answer_correct", nullable = false) @NotBlank private String correctAnswer; @Column(name = "option2", nullable = false) @NotBlank private String optionOne; @Column(name = "option1", nullable = false) @NotBlank private String optionTwo; @Column(name = "option3", nullable = false) @NotBlank private String optionThree; @Override public String toString() { return "Question{" + "question='" + question + '\'' + ", correctAnswer='" + correctAnswer + '\'' + ", optionOne='" + optionOne + '\'' + ", optionTwo='" + optionTwo + '\'' + ", optionThree='" + optionThree + '\'' + '}'; } }
- JpaUserRepository:
package com.whiskels.telegram.repository; import com.whiskels.telegram.model.User; import org.springframework.data.jpa.repository.JpaRepository; import org.springframework.stereotype.Repository; import org.springframework.transaction.annotation.Transactional; import java.util.Optional; @Repository @Transactional(readOnly = true) public interface JpaUserRepository extends JpaRepository<user, integer=""> { // По названию метода Spring сам поймет, что мы хотим получить пользователя по переданному chatId Optional<user> getByChatId(int chatId); } </user></user,>
- JpaQuestionRepository:
package com.whiskels.telegram.repository; import com.whiskels.telegram.model.Question; import org.springframework.data.jpa.repository.JpaRepository; import org.springframework.data.jpa.repository.Query; @Repository @Transactional(readOnly = true) public interface JpaQuestionRepository extends JpaRepository<question, integer=""> { // А здесь мы написали SQL Query, которая будет выбирать 1 случайный вопрос из таблицы вопросов @Query(nativeQuery = true, value = "SELECT * FROM java_quiz ORDER BY random() LIMIT 1") Question getRandomQuestion(); } </question,>
package com.whiskels.telegram.bot;
public enum State {
NONE,
START,
ENTER_NAME,
PLAYING_QUIZ,
}
Next, we will create a bot/handler package in which we will declare the handler interface:
package com.whiskels.telegram.bot.handler;
import com.whiskels.telegram.bot.State;
import com.whiskels.telegram.model.User;
import org.telegram.telegrambots.meta.api.methods.PartialBotApiMethod;
import java.io.Serializable;
import java.util.List;
public interface Handler {
// основной метод, который будет обрабатывать действия пользователя
List<partialbotapimethod<? extends="" serializable="">> handle(User user, String message);
// метод, который позволяет узнать, можем ли мы обработать текущий State у пользователя
State operatedBotState();
// метод, который позволяет узнать, Howие команды CallBackQuery мы можем обработать в этом классе
List<string> operatedCallBackQuery();
}
</string></partialbotapimethod<?>
We will create the handlers a little later, but for now let's delegate event processing to the new UpdateReceiver class , which we will create in the root of the bot package: ATTENTION! Here and further there will be methods that are displayed as List> handle(args); in reality they look like this, but the code formatter broke them:
package com.whiskels.telegram.bot;
import com.whiskels.telegram.bot.handler.Handler;
import com.whiskels.telegram.model.User;
import com.whiskels.telegram.repository.JpaUserRepository;
import org.springframework.stereotype.Component;
import org.telegram.telegrambots.meta.api.methods.PartialBotApiMethod;
import org.telegram.telegrambots.meta.api.objects.CallbackQuery;
import org.telegram.telegrambots.meta.api.objects.Message;
import org.telegram.telegrambots.meta.api.objects.Update;
import java.io.Serializable;
import java.util.Collections;
import java.util.List;
@Component
public class UpdateReceiver {
// Храним доступные хендлеры в списке (подсмотрел у Miroha)
private final List<handler> handlers;
// Имеем доступ в базу пользователей
private final JpaUserRepository userRepository;
public UpdateReceiver(List<handler> handlers, JpaUserRepository userRepository) {
this.handlers = handlers;
this.userRepository = userRepository;
}
// Обрабатываем полученный Update
public List<partialbotapimethod<? extends="" serializable="">> handle(Update update) {
// try-catch, чтобы при несуществующей команде просто возвращать пустой список
try {
// Проверяем, если Update - сообщение с текстом
if (isMessageWithText(update)) {
// Получаем Message из Update
final Message message = update.getMessage();
// Получаем айди чата с пользователем
final int chatId = message.getFrom().getId();
// Просим у репозитория пользователя. Если такого пользователя нет - создаем нового и возвращаем его.
// Как раз на случай нового пользователя мы и сделали конструктор с одним параметром в классе User
final User user = userRepository.getByChatId(chatId)
.orElseGet(() -> userRepository.save(new User(chatId)));
// Ищем нужный обработчик и возвращаем результат его работы
return getHandlerByState(user.getBotState()).handle(user, message.getText());
} else if (update.hasCallbackQuery()) {
final CallbackQuery callbackQuery = update.getCallbackQuery();
final int chatId = callbackQuery.getFrom().getId();
final User user = userRepository.getByChatId(chatId)
.orElseGet(() -> userRepository.save(new User(chatId)));
return getHandlerByCallBackQuery(callbackQuery.getData()).handle(user, callbackQuery.getData());
}
throw new UnsupportedOperationException();
} catch (UnsupportedOperationException e) {
return Collections.emptyList();
}
}
private Handler getHandlerByState(State state) {
return handlers.stream()
.filter(h -> h.operatedBotState() != null)
.filter(h -> h.operatedBotState().equals(state))
.findAny()
.orElseThrow(UnsupportedOperationException::new);
}
private Handler getHandlerByCallBackQuery(String query) {
return handlers.stream()
.filter(h -> h.operatedCallBackQuery().stream()
.anyMatch(query::startsWith))
.findAny()
.orElseThrow(UnsupportedOperationException::new);
}
private boolean isMessageWithText(Update update) {
return !update.hasCallbackQuery() && update.hasMessage() && update.getMessage().hasText();
}
}
</partialbotapimethod<?></handler></handler>
And we delegate processing to it in the Bot class:
package com.whiskels.telegram.bot;
import lombok.Getter;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
import org.telegram.telegrambots.bots.TelegramLongPollingBot;
import org.telegram.telegrambots.meta.api.methods.PartialBotApiMethod;
import org.telegram.telegrambots.meta.api.methods.send.SendMessage;
import org.telegram.telegrambots.meta.api.objects.Update;
import org.telegram.telegrambots.meta.exceptions.TelegramApiException;
import java.io.Serializable;
import java.util.List;
@Slf4j
@Component
public class Bot extends TelegramLongPollingBot {
@Value("${bot.name}")
@Getter
private String botUsername;
@Value("${bot.token}")
@Getter
private String botToken;
private final UpdateReceiver updateReceiver;
public Bot(UpdateReceiver updateReceiver) {
this.updateReceiver = updateReceiver;
}
@Override
public void onUpdateReceived(Update update) {
List<partialbotapimethod<? extends="" serializable="">> messagesToSend = updateReceiver.handle(update);
if (messagesToSend != null && !messagesToSend.isEmpty()) {
messagesToSend.forEach(response -> {
if (response instanceof SendMessage) {
executeWithExceptionCheck((SendMessage) response);
}
});
}
}
public void executeWithExceptionCheck(SendMessage sendMessage) {
try {
execute(sendMessage);
} catch (TelegramApiException e) {
log.error("oops");
}
}
}
</partialbotapimethod<?>
Now our bot delegates event processing to the UpdateReceiver class , but we don’t have any handlers yet. Let's create them! DISCLAIMER! I really wanted to share the possibilities of writing such a bot, so further code (as in principle the UpdateReceiver code) can be very well refactored using various patterns. But we are learning and our goal is a minimally viable bot, so as another homework assignment, you can refactor everything you saw :) Create a util package, and in it - the TelegramUtil class :
package com.whiskels.telegram.util;
import com.whiskels.telegram.model.User;
import org.telegram.telegrambots.meta.api.methods.send.SendMessage;
import org.telegram.telegrambots.meta.api.objects.replykeyboard.buttons.InlineKeyboardButton;
public class TelegramUtil {
public static SendMessage createMessageTemplate(User user) {
return createMessageTemplate(String.valueOf(user.getChatId()));
}
// Создаем шаблон SendMessage с включенным Markdown
public static SendMessage createMessageTemplate(String chatId) {
return new SendMessage()
.setChatId(chatId)
.enableMarkdown(true);
}
// Создаем кнопку
public static InlineKeyboardButton createInlineKeyboardButton(String text, String command) {
return new InlineKeyboardButton()
.setText(text)
.setCallbackData(command);
}
}
We will write four handlers: HelpHandler, QuizHandler, RegistrationHandler, StartHandler. StartHandler:
package com.whiskels.telegram.bot.handler;
import com.whiskels.telegram.bot.State;
import com.whiskels.telegram.model.User;
import com.whiskels.telegram.repository.JpaUserRepository;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
import org.telegram.telegrambots.meta.api.methods.PartialBotApiMethod;
import org.telegram.telegrambots.meta.api.methods.send.SendMessage;
import java.io.Serializable;
import java.util.Collections;
import java.util.List;
import static com.whiskels.telegram.util.TelegramUtil.createMessageTemplate;
@Component
public class StartHandler implements Handler {
@Value("${bot.name}")
private String botUsername;
private final JpaUserRepository userRepository;
public StartHandler(JpaUserRepository userRepository) {
this.userRepository = userRepository;
}
@Override
public List<partialbotapimethod<? extends="" serializable="">> handle(User user, String message) {
// Приветствуем пользователя
SendMessage welcomeMessage = createMessageTemplate(user)
.setText(String.format(
"Hola! I'm *%s*%nI am here to help you learn Java", botUsername
));
// Просим назваться
SendMessage registrationMessage = createMessageTemplate(user)
.setText("In order to start our journey tell me your name");
// Меняем пользователю статус на - "ожидание ввода имени"
user.setBotState(State.ENTER_NAME);
userRepository.save(user);
return List.of(welcomeMessage, registrationMessage);
}
@Override
public State operatedBotState() {
return State.START;
}
@Override
public List<string> operatedCallBackQuery() {
return Collections.emptyList();
}
}
</string></partialbotapimethod<?>
RegistrationHandler:
package com.whiskels.telegram.bot.handler;
import com.whiskels.telegram.bot.State;
import com.whiskels.telegram.model.User;
import com.whiskels.telegram.repository.JpaUserRepository;
import org.springframework.stereotype.Component;
import org.telegram.telegrambots.meta.api.methods.PartialBotApiMethod;
import org.telegram.telegrambots.meta.api.objects.replykeyboard.InlineKeyboardMarkup;
import org.telegram.telegrambots.meta.api.objects.replykeyboard.buttons.InlineKeyboardButton;
import java.io.Serializable;
import java.util.List;
import static com.whiskels.telegram.bot.handler.QuizHandler.QUIZ_START;
import static com.whiskels.telegram.util.TelegramUtil.createInlineKeyboardButton;
import static com.whiskels.telegram.util.TelegramUtil.createMessageTemplate;
@Component
public class RegistrationHandler implements Handler {
//Храним поддерживаемые CallBackQuery в виде констант
public static final String NAME_ACCEPT = "/enter_name_accept";
public static final String NAME_CHANGE = "/enter_name";
public static final String NAME_CHANGE_CANCEL = "/enter_name_cancel";
private final JpaUserRepository userRepository;
public RegistrationHandler(JpaUserRepository userRepository) {
this.userRepository = userRepository;
}
@Override
public List<partialbotapimethod<? extends="" serializable="">> handle(User user, String message) {
// Проверяем тип полученного события
if (message.equalsIgnoreCase(NAME_ACCEPT) || message.equalsIgnoreCase(NAME_CHANGE_CANCEL)) {
return accept(user);
} else if (message.equalsIgnoreCase(NAME_CHANGE)) {
return changeName(user);
}
return checkName(user, message);
}
private List<partialbotapimethod<? extends="" serializable="">> accept(User user) {
// Если пользователь принял Name - меняем статус и сохраняем
user.setBotState(State.NONE);
userRepository.save(user);
// Создаем кнопку для начала игры
InlineKeyboardMarkup inlineKeyboardMarkup = new InlineKeyboardMarkup();
List<inlinekeyboardbutton> inlineKeyboardButtonsRowOne = List.of(
createInlineKeyboardButton("Start quiz", QUIZ_START));
inlineKeyboardMarkup.setKeyboard(List.of(inlineKeyboardButtonsRowOne));
return List.of(createMessageTemplate(user).setText(String.format(
"Your name is saved as: %s", user.getName()))
.setReplyMarkup(inlineKeyboardMarkup));
}
private List<partialbotapimethod<? extends="" serializable="">> checkName(User user, String message) {
// При проверке имени мы превентивно сохраняем пользователю новое Name в базе
// идея для рефакторинга - добавить временное хранение имени
user.setName(message);
userRepository.save(user);
// Doing кнопку для применения изменений
InlineKeyboardMarkup inlineKeyboardMarkup = new InlineKeyboardMarkup();
List<inlinekeyboardbutton> inlineKeyboardButtonsRowOne = List.of(
createInlineKeyboardButton("Accept", NAME_ACCEPT));
inlineKeyboardMarkup.setKeyboard(List.of(inlineKeyboardButtonsRowOne));
return List.of(createMessageTemplate(user)
.setText(String.format("You have entered: %s%nIf this is correct - press the button", user.getName()))
.setReplyMarkup(inlineKeyboardMarkup));
}
private List<partialbotapimethod<? extends="" serializable="">> changeName(User user) {
// При requestе изменения имени мы меняем State
user.setBotState(State.ENTER_NAME);
userRepository.save(user);
// Создаем кнопку для отмены операции
InlineKeyboardMarkup inlineKeyboardMarkup = new InlineKeyboardMarkup();
List<inlinekeyboardbutton> inlineKeyboardButtonsRowOne = List.of(
createInlineKeyboardButton("Cancel", NAME_CHANGE_CANCEL));
inlineKeyboardMarkup.setKeyboard(List.of(inlineKeyboardButtonsRowOne));
return List.of(createMessageTemplate(user).setText(String.format(
"Your current name is: %s%nEnter new name or press the button to continue", user.getName()))
.setReplyMarkup(inlineKeyboardMarkup));
}
@Override
public State operatedBotState() {
return State.ENTER_NAME;
}
@Override
public List<string> operatedCallBackQuery() {
return List.of(NAME_ACCEPT, NAME_CHANGE, NAME_CHANGE_CANCEL);
}
}
</string></inlinekeyboardbutton></partialbotapimethod<?></inlinekeyboardbutton></partialbotapimethod<?></inlinekeyboardbutton></partialbotapimethod<?></partialbotapimethod<?>
Help Handler:
package com.whiskels.telegram.bot.handler;
import com.whiskels.telegram.bot.State;
import com.whiskels.telegram.model.User;
import org.springframework.stereotype.Component;
import org.telegram.telegrambots.meta.api.methods.PartialBotApiMethod;
import org.telegram.telegrambots.meta.api.methods.send.SendMessage;
import org.telegram.telegrambots.meta.api.objects.replykeyboard.InlineKeyboardMarkup;
import org.telegram.telegrambots.meta.api.objects.replykeyboard.buttons.InlineKeyboardButton;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import static com.whiskels.telegram.bot.handler.RegistrationHandler.NAME_CHANGE;
import static com.whiskels.telegram.util.TelegramUtil.createInlineKeyboardButton;
import static com.whiskels.telegram.util.TelegramUtil.createMessageTemplate;
@Component
public class HelpHandler implements Handler {
@Override
public List<partialbotapimethod<? extends="" serializable="">> handle(User user, String message) {
// Создаем кнопку для смены имени
InlineKeyboardMarkup inlineKeyboardMarkup = new InlineKeyboardMarkup();
List<inlinekeyboardbutton> inlineKeyboardButtonsRowOne = List.of(
createInlineKeyboardButton("Change name", NAME_CHANGE));
inlineKeyboardMarkup.setKeyboard(List.of(inlineKeyboardButtonsRowOne));
return List.of(createMessageTemplate(user).setText(String.format("" +
"You've asked for help %s? Here it comes!", user.getName()))
.setReplyMarkup(inlineKeyboardMarkup));
}
@Override
public State operatedBotState() {
return State.NONE;
}
@Override
public List<string> operatedCallBackQuery() {
return Collections.emptyList();
}
}
</string></inlinekeyboardbutton></partialbotapimethod<?>
QuizHandler (the worst
GO TO FULL VERSION