Question

我已经开始使用此module

为电报编写机器人逻辑

我可以像这样创建简单的问答逻辑：

bot.onText(/\/start/, function(msg, match){
  bot.sendMessage(msg.chat.id, "Hello this is great bot");
});

当用户输入/start时，他会收到此消息。

我想创建像bot和用户之间的链式对话。就像用户类型/buy bot会显示购买选项一样，在用户输入他想要购买的东西后，机器人将显示所选产品的类型等等。

如何在用户和机器人之间创建链式对话？如何使机器人记住以前选择的命令并在时间重置它们？我需要保留在自己的数据库中吗？

Answer 1

你可以用不同的方式做到这一点。

您可以存储＆＃34;州＆＃34;用户在你自己
您可以使用多个可以自行运行的命令，但只是让用户感觉被引导
您可以使用Bot API的ForceReply

好的。因此对于1.我说你有一些好处。实际上，当用户处于正常状态时，您可以引导用户并限制对某些命令的访问。所以，让我们说他想要购买爆米花，但是他在你要求通过检查保存的用户状态来禁止该命令。

对于2.，您始终允许用户使用/buy和/buy_popcorn以及/buy_shoe。但根据你的答案，你只需给他一些特定的选择。

User: /buy

What do you want to buy? /shoes or /food :Bot

User: /food

How about some Popcorn? Use /buy_popcorn :Bot

User: /buy_shoe

Alright. Shoes added to cart :Bot

这是允许的，但用户必须手动编写/buy_shoe

3.可能的方式是使用ForceReply。用户将自动收到answer to消息。因此，当他使用/buy_shoe时，他将回答机器人发送的最后一条消息。您还将在api的消息中收到用户回复的消息。您可以检查用户回答的消息是否是该命令的正确前置条件/正确消息，然后限制或允许该命令。

User: /buy

What do you want to buy? /shoes or /food :Bot

User: [Answer to: What do you...] /food

How about some Popcorn? Use /buy_popcorn :Bot

User: [Answer to: How about some...] /buy_shoe

Sorry, but you're currently in the Food Store :Bot

我想，归结为个人偏好。但所有这些都有利有弊，你必须决定是否要在没有先决条件的情况下允许特定命令。

此列表可能不完整。可能还有其他方式，我没有想到。但这三种方式我都知道。

Answer 2

我也遇到了这个问题，我需要我的机器人根据他对用户的最后回答来回答问题，并且由于很难找到可以将我引向解决方案的想法（在 Java ），为了将来的Java Google员工，我将在这里分享我的知识。我正在将telegrambots library与Spring Boot / Data一起使用。

正如Loki指出的那样，实现此流程的最佳方法是将状态保存在数据库中。为此，使用消息的唯一聊天ID将聊天与其他聊天区分开。

以下是Java实现的相关部分（该逻辑几乎适用于任何语言）：

保存与系统用户有关的电报聊天信息的实体。

@Entity
@Table(name = "user_bot")
public class UserBot implements Serializable {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Integer id;

    @Column(name = "chat_id", unique = true, nullable = false, length = 255)
    private String chatId;

    @Column(name = "bot_verification_code", length = 6)
    private String botVerificationCode;

    @Enumerated
    @Column(name = "last_bot_state", columnDefinition = "SMALLINT DEFAULT NULL")
    private BotState lastBotState;

    @Column(columnDefinition = "TINYINT(1)")
    private boolean verified;

    @JoinColumn(name = "user_id", referencedColumnName = "id")
    @ManyToOne(fetch = FetchType.EAGER)
    private User user;
}

代表所有可能的漫游器响应（状态）的枚举。

public enum BotState {
    // Respostas do bot que representam estados
    AUTH_STEP_1("Muito bem. Qual é o seu e-mail no sistema?"), AUTH_STEP_2("Enviei um código para o seu e-mail. Por favor, digite-o aqui."),
    NO_STATE("");

    private final String state;

    private BotState(String state) {
        this.state = state;
    }

    @Override
    public String toString() {
        return this.state;
    }
}

接收消息并做出相应响应的服务。

@Service
public class TelegramBotService extends TelegramLongPollingBot {

    @Autowired
    private CodeUtils codeUtils;

    @Autowired
    private UserBotRepository userBotRepository;

    @Autowired
    private UserRepository userRepository;

    @Value("${telegram.bot.username}")
    private String botUsername;

    @Value("${telegram.bot.token}")
    private String botToken;

    @PostConstruct
    public void registerBot() {
        TelegramBotsApi botsApi = new TelegramBotsApi();
        try {
            botsApi.registerBot(this);
        } catch (TelegramApiException e) {
            e.printStackTrace();
        }
    }

    @Override
    public void onUpdateReceived(Update update) {
        if (update.hasMessage() && update.getMessage().hasText()) {
            String receivedMessage = update.getMessage().getText();
            SendMessage sendMessage = null;

            // TODO: futuramente, tratar casos onde um usuário chama um comando sem ainda estar autenticado
            switch (receivedMessage) {
                case "/autenticar":
                    sendMessage = handleAuthentication(update);
                    break;
                default:
                    // Quando nenhum comando atender, será um texto a ser checado de acordo com o estado anterior
                    sendMessage = checkState(update);
            }

            try {
                execute(sendMessage);
            } catch (TelegramApiException e) {
                codeUtils.log(e.getMessage(), this);
            }
        }
    }

    private SendMessage handleAuthentication(Update update) {
        SendMessage sendMessage = new SendMessage()
                .setChatId(update.getMessage().getChatId())
                .setText(BotState.AUTH_STEP_1.toString());

        UserBot userBot = userBotRepository.findByChatId(update.getMessage().getChatId().toString());

        if (userBot == null) {
            userBot = new UserBot();
            userBot.setChatId(update.getMessage().getChatId().toString());
            userBot.setLastBotState(BotState.AUTH_STEP_1);
        } else if (userBot.isVerified()) {
            // Um texto simples enviado no sendMessage indica o fim de um fluxo
            sendMessage.setText("Este aparelho já está autenticado no sistema.");
            userBot.setLastBotState(null);
        }

        userBotRepository.save(userBot);
        return sendMessage;
    }

    // Checa o estado anterior do bot em relação ao chatId recebido
    private SendMessage checkState(Update update) {
        UserBot userBot = userBotRepository.findByChatId(update.getMessage().getChatId().toString());
        SendMessage sendMessage = null;

        if (userBot == null || userBot.getLastBotState() == null)
            return sendDefaultMessage(update);

        switch (Optional.ofNullable(userBot.getLastBotState()).orElse(BotState.NO_STATE)) {
            case AUTH_STEP_1:
                sendMessage = sendCode(update);
                break;
            case AUTH_STEP_2:
                sendMessage = validateCode(update);
                break;
            default:
                sendMessage = sendDefaultMessage(update);
        }

        return sendMessage;
    }

    // Grava o código no banco e envia para o e-mail do usuário
    private SendMessage sendCode(Update update) {
        User user = userRepository.findByEmail(update.getMessage().getText().toLowerCase());
        SendMessage sendMessage = new SendMessage(update.getMessage().getChatId(), "");

        if (user == null)
            sendMessage.setText("Não encontrei nenhum usuário no sistema com este e-mail :(");
        else {
            UserBot userBot = userBotRepository.findByChatId(update.getMessage().getChatId().toString());

            String verificationCode = Integer.toString(new Random().nextInt(899999) + 100000);
            String text = "Este é um e-mail automático de verificação de identidade. Informe este código para o bot do Telegram: " + verificationCode;
            codeUtils.sendEmail(new String[]{user.getEmail()}, "CCR Laudos - Código de Verificação", text);

            // Associa a conversação ao usuário, mas a validade depende da flag verified
            userBot.setUser(user);
            userBot.setBotVerificationCode(verificationCode);
            userBot.setLastBotState(BotState.AUTH_STEP_2);
            userBotRepository.save(userBot);

            sendMessage.setText(BotState.AUTH_STEP_2.toString());
        }

        return sendMessage;
    }

    // Checa se o código informado foi o mesmo passado por e-mail para o usuário a fim de autenticá-lo
    private SendMessage validateCode(Update update) {
        UserBot userBot = userBotRepository.findByChatId(update.getMessage().getChatId().toString());
        SendMessage sendMessage = new SendMessage(update.getMessage().getChatId(), "");

        if (update.getMessage().getText().equals(userBot.getBotVerificationCode())) {
            userBot.setVerified(true);
            sendMessage.setText("O aparelho foi autenticado com sucesso. Você passará a receber notificações do sistema.");
        } else {
            userBot.setUser(null);
            sendMessage.setText("Código inválido.");
        }

        userBotRepository.save(userBot);
        return sendMessage;
    }

    private SendMessage sendDefaultMessage(Update update) {
        String markdownMessage = "Não entendi \ud83e\udd14 \n"
                + "Que tal tentar um comando digitando */* ?";
        return new SendMessage(update.getMessage().getChatId(), markdownMessage).setParseMode(ParseMode.MARKDOWN);
    }

    @Override
    public String getBotUsername() {
        return this.botUsername;
    }

    @Override
    public String getBotToken() {
        return this.botToken;
    }
}

实现的流程是：

1-用户发送/ authenticate。

2-系统对设备一无所知，因此请存储聊天ID和最后状态。 最后一个状态将是对用户的响应。系统会询问用户的电子邮件。

3-用户发送电子邮件。

4-无法将文本识别为命令，因此系统检查相对于此聊天ID的最后状态。如果存在先前的状态，则使用传入的文本作为该状态方法的参数。系统将代码发送到用户的电子邮件并要求输入。

5-用户发送代码。

6-如果代码正确，系统会再次检查以前的状态并验证用户身份。

就是这样！希望对别人有帮助。

Node Telegram bot api，在用户之间进行链接对话

2 个答案: