OneMessageBot

https://github.com/zoommax/onemessagebot
Admin
OneMessageBot is a Java framework for creating Telegram bots that operate in a single-window mode...
Tokens:13,810
Snippets:90
Trust Score:7
Update:10 months ago
Show doc for...
Tokens:
Raw
### Run the Bot (Java)

Source: https://github.com/zoommax/onemessagebot/blob/master/one-message-bot-docs/docs/quickstart.md

Demonstrates how to start the OneMessageBot application. It assumes that bot settings have already been configured and built. The bot runs in a separate thread.

```java
package test.cl;

import space.zoommax.BotApp;

public class Main {
    public static void main(String[] args) {
        //BotSettings botSettings = BotSettings.builder()
        // ...
        // .build();

        new Thread(new BotApp(botSettings)).start();
    }
}
```

--------------------------------

### Configure Bot Settings (Java)

Source: https://github.com/zoommax/onemessagebot/blob/master/one-message-bot-docs/docs/quickstart.md

Example of configuring bot settings using the BotSettings builder. This includes essential parameters like bot token, database type, and language settings. The database connection details are optional.

```java
package test.cl;

import space.zoommax.BotSettings;
import space.zoommax.utils.db.DbType;

import java.io.IOException;

public class Main {
    public static void main(String[] args) throws IOException {
        BotSettings botSettings = BotSettings.builder()
                .botToken("XXXX:yyyyyy")
                .dbType(DbType.SQLITE)
                .buttonsRows(5)
                .dbName("TestBotApp")
                .languageDirPath("translations")
                .defaultLanguage("my_default_lang")
                .dbConnection(null)
                .dbUrl("jdbc:sqlite:./")
                .dbUser("")
                .dbPassword("")
                .build();
    }
}
```

--------------------------------

### Add OneMessageBot Dependency

Source: https://github.com/zoommax/onemessagebot/blob/master/one-message-bot-docs/docs/quickstart.md

Instructions for adding the OneMessageBot library to your project using Maven or Gradle build tools.

```xml
<dependency>
    <groupId>space.zoommax</groupId>
    <artifactId>OneMessageBot</artifactId>
    <version>2.1.4.8</version>
</dependency>
```

```groovy
implementation 'space.zoommax:OneMessageBot:2.1.4.8'
```

--------------------------------

### Initialize and Start Telegram Bot with Custom Settings

Source: https://context7.com/zoommax/onemessagebot/llms.txt

This Java snippet demonstrates how to initialize and start a OneMessageBot instance. It configures essential bot settings such as the bot token, default language, database type and connection details, and button row count. The bot is then started in a separate thread.

```java
import space.zoommax.BotApp;
import space.zoommax.BotSettings;
import space.zoommax.utils.db.DbType;

public class MyBot {
    public static void main(String[] args) {
        // Configure bot settings
        BotSettings settings = BotSettings.builder()
            .botToken("1234567890:ABCdefGHIjklMNOpqrsTUVwxyz")
            .defaultLanguage("default_en_US")
            .languageDirPath("./translations")
            .buttonsRows(4)
            .dbType(DbType.SQLITE)
            .dbName("mybot.db")
            .dbUrl("jdbc:sqlite:./")
            .disableGithubUrl("enabled")
            .build();

        // Initialize and start bot
        BotApp botApp = new BotApp(settings);
        Thread botThread = new Thread(botApp);
        botThread.start();

        System.out.println("Bot started successfully!");
    }
}
```

--------------------------------

### Java Telegram Bot: Handle Messages and Commands

Source: https://github.com/zoommax/onemessagebot/blob/master/one-message-bot-docs/docs/quickstart.md

This Java code defines a Telegram bot's response to various user inputs. It handles standard messages, `/start` commands, and callback queries. The bot can send text messages with custom inline keyboards and process callback data to trigger notifications. Dependencies include the pengrad.telegrambot library and custom utility classes for views and keyboards.

```java
package test.cl;

import com.pengrad.telegrambot.model.PhotoSize;
import com.pengrad.telegrambot.model.Update;
import space.zoommax.BotApp;
import space.zoommax.utils.CreateNotification;
import space.zoommax.utils.ViewMessageImpl;
import space.zoommax.utils.ViewMessageListener;
import space.zoommax.utils.db.NotificationType;
import space.zoommax.utils.keyboard.Keyboard;
import space.zoommax.view.TextMessage;
import space.zoommax.view.ViewMessage;

@ViewMessageListener
public class Start implements ViewMessageImpl {
    @Override
    public ViewMessage onMessage(String message, int messageId, long chatId, String onMessageFlag, Update update) {
        if (onMessageFlag.equals("start")) {
            return TextMessage.builder()
                    .onMessageFlag("start")
                    .text("Hello " + message)
                    .chatId(chatId)
                    .keyboard(Keyboard.builder()
                            .chatId(chatId)
                            .code("{Google;https://google.com}{Yandex;https://ya.ru}\n" +
                                    "{Start;strt}\n" +
                                    "{Google;https://google.com}{Yandex;https://ya.ru}\n" +
                                    "{Start;strt}\n" +
                                    "{Google;https://google.com}{Yandex;https://ya.ru}\n" +
                                    "{Start;strt}\n" +
                                    "{Google;https://google.com}{Yandex;https://ya.ru}\n" +
                                    "{Start;strt}")
                            .build())
                    .build();
        }
        return null;
    }

    @Override
    public ViewMessage onCommand(String command, int messageId, long chatId, Update update) {
        if (command.equals("/start")) {
            if (chatId == 000000) {
                BotApp.setUserLanguage(String.valueOf(chatId), "default_en_US");
            }
            return TextMessage.builder()
                    .onMessageFlag("start")
                    .text("Hello")
                    .chatId(chatId)
                    .keyboard(Keyboard.builder()
                            .chatId(chatId)
                            .code("{Google;https://google.com}{Yandex;https://ya.ru}\n" +
                                    "{Start;strt}")
                            .build())
                    .build();
        }
        return null;
    }

    @Override
    public ViewMessage onPicture(PhotoSize[] photoSize, String caption, int messageId, long chatId, Update update) {
        return null;
    }

    @Override
    public ViewMessage onCallbackQuery(String data, int messageId, long chatId, Update update) {
        if (data.equals("strt")) {
            CreateNotification createNotification = new CreateNotification("Hello callback notify", String.valueOf(chatId), null, NotificationType.FULL, null);
            createNotification.run();
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            return TextMessage.builder()
                    .onMessageFlag("start")
                    .text("Hello callback")
                    .chatId(chatId)
                    .keyboard(Keyboard.builder()
                            .chatId(chatId)
                            .code("{Google;https://google.com}{Yandex;https://ya.ru}\n" +
                                    "{Start;strt}")
                            .build())
                    .build();
        }
        return null;
    }

    @Override
    public ViewMessage onInlineQuery(String query, String queryId, long chatId, Update update) {
        return null;
    }

    @Override
    public ViewMessage onChosenInlineResult(String resultId, long queryId, String chatId, Update update) {
        return null;
    }
}
```

--------------------------------

### Java ViewMessage Listener Implementation

Source: https://github.com/zoommax/onemessagebot/blob/master/one-message-bot-docs/docs/viewmessage/listener.md

This Java code demonstrates how to create a message listener by implementing the ViewMessageImpl interface and adding the @ViewMessageListener annotation. It includes examples of handling text messages, commands, pictures, and callback queries, returning different ViewMessage types for responses.

```java
import space.zoommax.utils.ViewMessageListener;
import space.zoommax.view.TextMessage;

@ViewMessageListener
public class Start implements ViewMessageImpl {

    @Override
    public ViewMessage onMessage(String message, int messageId, long chatId, String onMessageFlag, Update update) {
        return TextMessage.builder()
                .text(message)
                .chatId(chatId)
                .build();
    }

    @Override
    public ViewMessage onCommand(String command, int messageId, long chatId, Update update) {
        return null;
    }

    @Override
    public ViewMessage onPicture(PhotoSize[] photoSize, String caption, int messageId, long chatId, Update update) {
        return null;
    }

    @Override
    public ViewMessage onCallbackQuery(String data, int messageId, long chatId, Update update) {
        return null;
    }

    @Override
    public ViewMessage onInlineQuery(String query, String queryId, long chatId, Update update) {
        return null;
    }

    @Override
    public ViewMessage onChosenInlineResult(String resultId, long queryId, String chatId, Update update) {
        return null;
    }
}
```

--------------------------------

### Maven Dependency for OneMessageBot

Source: https://github.com/zoommax/onemessagebot/blob/master/one-message-bot-docs/docs/index.md

This XML snippet shows how to add the OneMessageBot library to your project using Maven. It specifies the group ID, artifact ID, and version. Ensure you have a compatible Maven setup.

```xml
<dependency>
    <groupId>space.zoommax</groupId>
    <artifactId>OneMessageBot</artifactId>
    <version>2.1.4.8</version>
</dependency>
```

--------------------------------

### Accessing Translations Using LocalizationManager (Java)

Source: https://github.com/zoommax/onemessagebot/blob/master/one-message-bot-docs/docs/localization/localization.md

This Java code snippet shows how to retrieve translated strings from the LocalizationManager. It uses the user's language preference and a specific translation key to get the appropriate text.

```java
import space.zoommax.BotApp;
import space.zoommax.utils.lang.LocalizationManager;

LocalizationManager localizationManager = BotApp.localizationManager;
String botStart = localizationManager.getTranslationForLanguage(UserLanguage.getUserLanguage(chatId), "main.bot_starting");
```

--------------------------------

### Send Video Messages with Captions and Keyboards (Java)

Source: https://context7.com/zoommax/onemessagebot/llms.txt

Illustrates sending video files from a File path or URL, including optional captions and keyboards. Requires `space.zoommax.view.VideoMessage`.

```java
import space.zoommax.view.VideoMessage;
import space.zoommax.utils.keyboard.Keyboard;
import java.io.File;
import java.util.ArrayList;

File videoFile = new File("/path/to/video.mp4");

VideoMessage video = VideoMessage.builder()
    .chatId(123456789L)
    .videoAsFile(videoFile)
    .caption("<b>Tutorial Video</b>\nLearn how to use the bot")
    .keyboard(Keyboard.builder()
        .chatId(123456789L)
        .keyboardButtons(new ArrayList<>()) // Example with an empty keyboard
        .build())
    .build();

BotApp.executor.submit(video);

// Send video from URL
VideoMessage urlVideo = VideoMessage.builder()
    .chatId(123456789L)
    .videoAsUrl("https://example.com/video.mp4")
    .caption("Video from URL")
    .build();

BotApp.executor.submit(urlVideo);
```

--------------------------------

### Build and Send Video Message with URL (Java)

Source: https://github.com/zoommax/onemessagebot/blob/master/one-message-bot-docs/docs/viewmessage/videomessage.md

Demonstrates how to use the VideoMessage builder to construct a video message by providing a video URL. It includes optional parameters like chatId, keyboard, caption, onMessageFlag, and notify. The message is then sent using the run() method.

```java
import space.zoommax.view.VideoMessage;
import java.io.File;

public class example {

    public static void main(String[] args) {
        VideoMessage videoMessage = VideoMessage.builder()
                .chatId(123456789)
                .videoAsUrl("https://example.com/video.mp4")
                /*optional
                .videoAsFile(new File("path/to/video.mp4"))
                .videoAsBytes(new byte[]{1,2,3,4,5})
                 */
                .keyboard(Keyboard.builder()
                        .chatId(123456789)
                        .code("{Google;https://google.ru}{Yandex;https://ya.ru}\n" +
                                "{Start;strt}")
                        .build())
                .caption("Hello")
                .onMessageFlag("start")
                .notify(false)
                .build();

        videoMessage.run();
    }
}
```

--------------------------------

### Build and Send TextMessage in Java

Source: https://github.com/zoommax/onemessagebot/blob/master/one-message-bot-docs/docs/viewmessage/textmessage.md

Demonstrates how to use the TextMessage builder to construct a message with text, a chat ID, a custom keyboard, an onMessageFlag, and notification settings. The message is then sent using the run() method. This requires the TextMessage and Keyboard classes from the space.zoommax.view package.

```java
import space.zoommax.view.TextMessage;
import space.zoommax.view.Keyboard;

public class example {

    public static void main(String[] args) {
        TextMessage textMessage = TextMessage.builder()
                .text("Hello")
                .chatId(123456789)
                .keyboard(Keyboard.builder()
                        .chatId(123456789)
                        .code("{Google;https://google.ru}{Yandex;https://ya.ru}\n" +
                                "{Start;strt}")
                        .build())
                .onMessageFlag("start")
                .notify(false)
                .build();
        textMessage.run();
    }
}
```

--------------------------------

### Create Keyboard from Code String Format

Source: https://context7.com/zoommax/onemessagebot/llms.txt

Shows how to create a keyboard using a compact string format for button definitions. This method automatically determines button types based on action prefixes. It requires the Keyboard utility class. Inputs are a formatted string representing buttons and rows, and the number of rows. Outputs a Keyboard object.

```java
import space.zoommax.utils.keyboard.Keyboard;

// Code format: {ButtonText;action}\n for each row
// Button types determined by action prefix:
// - "http" or "tg" = LINK
// - "mapp" = MINI_APP
// - "pay" = PAY
// - anything else = CALLBACK

String keyboardCode =
    "{Home;home}{Settings;settings}\n"
    +"{Help;help}{About;about}\n"
    +"{Website;https://example.com}\n"
    +"{Web App;mapp https://webapp.com}";

Keyboard keyboard = Keyboard.builder()
    .chatId(123456789L)
    .code(keyboardCode)
    .rows(3)
    .build();

// Use in message
TextMessage message = TextMessage.builder()
    .chatId(123456789L)
    .text("Main menu")
    .keyboard(keyboard)
    .build();

BotApp.executor.submit(message);
```

--------------------------------

### Build and Send Inline Keyboard with Buttons (Java)

Source: https://github.com/zoommax/onemessagebot/blob/master/one-message-bot-docs/docs/viewmessage/inlinekeyboard.md

Demonstrates how to use the InlineKeyboard builder to construct a keyboard with specified buttons and send it to a chat. Requires the InlineKeyboard class from space.zoommax.view. The 'code' parameter defines the buttons and their associated URLs or commands. The keyboard can be sent using the run() method.

```java
import space.zoommax.view.InlineKeyboard;

public class example {

    public static void main(String[] args) {
        InlineKeyboard inlineKeyboard = InlineKeyboard.builder()
                .chatId(123456789)
                .code("{Google;https://google.ru}{Yandex;https://ya.ru}
{Start;strt}")
                .build();

        inlineKeyboard.run();
    }
}
```

--------------------------------

### Create and Send Notifications

Source: https://context7.com/zoommax/onemessagebot/llms.txt

Illustrates how to create and send different types of notifications to users, including alerts and full messages with media. It utilizes the CreateNotification class and specifies notification types and content. Inputs are text, user ID, optional media path, and notification type. Outputs a notification object ready for execution.

```java
import space.zoommax.utils.CreateNotification;
import space.zoommax.utils.db.NotificationType;
import space.zoommax.BotApp;

// Create alert notification (max 200 characters, shown as popup)
CreateNotification alertNotif = new CreateNotification(
    "Your order has been shipped!",
    "123456789",  // Telegram user ID
    "",           // No image
    NotificationType.ALERT,
    ""            // No file type
);
BotApp.executor.submit(alertNotif);

// Create full notification with image (shown as message)
CreateNotification fullNotif = new CreateNotification(
    "<b>Special Offer!</b>\nGet 50% off today",
    "123456789",
    "/path/to/promo.jpg",
    NotificationType.FULL,
    "image"
);
BotApp.executor.submit(fullNotif);

// Create full notification with video
CreateNotification videoNotif = new CreateNotification(
    "Check out our new product video",
    "123456789",
    "/path/to/promo.mp4",
    NotificationType.FULL,
    "video"
);
BotApp.executor.submit(videoNotif);
```

--------------------------------

### Build and Send AudioMessage using Java

Source: https://github.com/zoommax/onemessagebot/blob/master/one-message-bot-docs/docs/viewmessage/audiomessage.md

Demonstrates how to use the AudioMessage builder in Java to create and send an audio message. It shows how to specify the audio source (URL, file, or bytes), add a caption, attach a keyboard, set a message flag, and control notification behavior. The audio message can then be executed using the `run()` method.

```java
import space.zoommax.view.AudioMessage;
import java.io.File;

public class example {

    public static void main(String[] args) {
        AudioMessage audioMessage = AudioMessage.builder()
                .chatId(123456789)
                .audioAsUrl("https://example.com/audio.mp3")
                /*optional
                .audioAsFile(new File("path/to/audio.mp3"))
                .audioAsBytes(new byte[]{1,2,3,4,5})
                 */
                .keyboard(Keyboard.builder()
                        .chatId(123456789)
                        .code("{Google;https://google.ru}{Yandex;https://ya.ru}\n" +
                                "{Start;strt}")
                        .build())
                .caption("Hello")
                .onMessageFlag("start")
                .notify(false)
                .build();

        audioMessage.run();
    }
}
```

--------------------------------

### Configure Database Backends

Source: https://context7.com/zoommax/onemessagebot/llms.txt

Demonstrates the configuration of different database backends for storing bot data, including SQLite (default), MongoDB, and custom JDBC connections. It utilizes the `BotSettings` class with specified `DbType` and connection details.

```java
import space.zoommax.BotSettings;
import space.zoommax.utils.db.DbType;
import java.sql.Connection;
import java.sql.DriverManager;

// SQLite configuration (default)
BotSettings sqliteSettings = BotSettings.builder()
    .botToken("TOKEN")
    .dbType(DbType.SQLITE)
    .dbName("bot.db")
    .dbUrl("jdbc:sqlite:./data/")
    .build();

// MongoDB configuration
BotSettings mongoSettings = BotSettings.builder()
    .botToken("TOKEN")
    .dbType(DbType.MONGODB)
    .dbUrl("mongodb://localhost:27017")
    .dbName("botdb")
    .build();

// Custom JDBC connection
Connection customConnection = DriverManager.getConnection(
    "jdbc:postgresql://localhost:5432/botdb",
    "username",
    "password"
);

BotSettings customSettings = BotSettings.builder()
    .botToken("TOKEN")
    .dbType(DbType.CUSTOM)
    .dbConnection(customConnection)
    .build();
```

--------------------------------

### Build and Send Image Message with PhotoMessage in Java

Source: https://github.com/zoommax/onemessagebot/blob/master/one-message-bot-docs/docs/viewmessage/photomessage.md

Demonstrates how to construct and send an image message using the PhotoMessage builder. It includes setting the chat ID, image source (URL, file, or bytes), an optional keyboard, caption, message flag, and notification setting. The message is then executed using the run() method. Dependencies include space.zoommax.view.PhotoMessage and potentially File and Keyboard classes.

```java
import space.zoommax.view.PhotoMessage;
import java.io.File;
// Assuming Keyboard class is available and imported
// import space.zoommax.view.Keyboard;

public class example {

    public static void main(String[] args) {
        PhotoMessage photoMessage = PhotoMessage.builder()
                .chatId(123456789)
                .photoAsUrl("https://example.com/image.jpg")
                /*optional
                .photoAsFile(new File("path/to/image.jpg"))
                .photoAsBytes(new byte[]{1,2,3,4,5})
                 */
                .keyboard(Keyboard.builder()
                        .chatId(123456789)
                        .code("{Google;https://google.ru}{Yandex;https://ya.ru}\n" +
                                "{Start;strt}")
                        .build())
                .caption("Hello")
                .onMessageFlag("start")
                .notify(false)
                .build();

        photoMessage.run();
    }
}

```

--------------------------------

### Send Photo Messages with Captions and Keyboards (Java)

Source: https://context7.com/zoommax/onemessagebot/llms.txt

Shows how to send photos using a File, URL, or byte array, with optional captions and keyboards. Supports sending multiple photos with corresponding captions. Requires `space.zoommax.view.PhotoMessage`.

```java
import space.zoommax.view.PhotoMessage;
import space.zoommax.utils.keyboard.Keyboard;
import space.zoommax.utils.keyboard.Button;
import space.zoommax.utils.keyboard.ButtonType;
import java.io.File;
import java.util.ArrayList;
import java.util.List;

// Send photo from file
File photoFile = new File("/path/to/photo.jpg");

List<List<Button>> buttons = new ArrayList<>();
List<Button> row = new ArrayList<>();
row.add(new Button("Like", "like_photo", ButtonType.CALLBACK));
row.add(new Button("Share", "share_photo", ButtonType.CALLBACK));
buttons.add(row);

Keyboard keyboard = Keyboard.builder()
    .chatId(123456789L)
    .keyboardButtons(buttons)
    .build();

PhotoMessage photoMsg = PhotoMessage.builder()
    .chatId(123456789L)
    .photoAsFile(photoFile)
    .caption("<b>Beautiful Photo</b>\nThis is a photo caption with HTML formatting")
    .keyboard(keyboard)
    .build();

BotApp.executor.submit(photoMsg);

// Send photo from URL
PhotoMessage urlPhoto = PhotoMessage.builder()
    .chatId(123456789L)
    .photoAsUrl("https://example.com/image.jpg")
    .caption("Photo from URL")
    .build();

BotApp.executor.submit(urlPhoto);

// Send photo from byte array
byte[] imageBytes = loadImageBytes(); // Assume loadImageBytes() is defined elsewhere
PhotoMessage bytesPhoto = PhotoMessage.builder()
    .chatId(123456789L)
    .photoAsBytes(imageBytes)
    .caption("Photo from bytes")
    .build();

BotApp.executor.submit(bytesPhoto);

// Send multiple photos
List<File> photos = new ArrayList<>();
photos.add(new File("/path/photo1.jpg"));
photos.add(new File("/path/photo2.jpg"));
photos.add(new File("/path/photo3.jpg"));

List<String> captions = new ArrayList<>();
captions.add("Photo 1");
captions.add("Photo 2");
captions.add("Photo 3");

PhotoMessage multiPhoto = PhotoMessage.builder()
    .chatId(123456789L)
    .photosAsFiles(photos)
    .captions(captions)
    .keyboard(keyboard)
    .build();

BotApp.executor.submit(multiPhoto);
```

--------------------------------

### Create Telegram Buttons using Button Objects (Java)

Source: https://github.com/zoommax/onemessagebot/blob/master/one-message-bot-docs/docs/keyboard/button.md

Illustrates creating Telegram buttons by instantiating the Button class with separate text and action parameters. The action prefix (mapp, http, tg) dictates whether the button opens a Mini App, a link, or performs a callback.

```java
Button button1 = new Button("I will open a Telegram Mini App", "mapphttp://example.com");
Button button2 = new Button("I will open a link", "http://example.com");
Button button3 = new Button("I will also open a link", "tg://username");
Button button4 = new Button("I will perform a callback action", "any_data");
```

--------------------------------

### Send Audio Messages with Captions (Java)

Source: https://context7.com/zoommax/onemessagebot/llms.txt

Demonstrates sending audio files from a File path with an optional caption. Requires `space.zoommax.view.AudioMessage`.

```java
import space.zoommax.view.AudioMessage;
import java.io.File;

File audioFile = new File("/path/to/audio.mp3");

AudioMessage audio = AudioMessage.builder()
    .chatId(123456789L)
    .audioAsFile(audioFile)
    .caption("<b>Music Track</b>\nArtist - Song Name")
    .build();

BotApp.executor.submit(audio);
```

--------------------------------

### Send Formatted Text Message with Keyboard (Java)

Source: https://context7.com/zoommax/onemessagebot/llms.txt

Demonstrates how to send a text message with HTML formatting and an inline keyboard. Supports callback and link buttons. Requires `space.zoommax.view.TextMessage` and keyboard-related utilities.

```java
import space.zoommax.view.TextMessage;
import space.zoommax.utils.keyboard.Keyboard;
import space.zoommax.utils.keyboard.Button;
import space.zoommax.utils.keyboard.ButtonType;
import java.util.ArrayList;
import java.util.List;

// Create keyboard with multiple buttons
List<List<Button>> buttons = new ArrayList<>();

List<Button> row1 = new ArrayList<>();
row1.add(new Button("Option 1", "opt1", ButtonType.CALLBACK));
row1.add(new Button("Option 2", "opt2", ButtonType.CALLBACK));
buttons.add(row1);

List<Button> row2 = new ArrayList<>();
row2.add(new Button("Website", "https://example.com", ButtonType.LINK));
row2.add(new Button("Web App", "mapp https://webapp.com", ButtonType.MINI_APP));
buttons.add(row2);

Keyboard keyboard = Keyboard.builder()
    .chatId(123456789L)
    .keyboardButtons(buttons)
    .rows(4)
    .build();

// Send text message with keyboard
TextMessage message = TextMessage.builder()
    .chatId(123456789L)
    .text("<b>Bold text</b>\n<i>Italic text</i>\n<code>Code</code>")
    .keyboard(keyboard)
    .onMessageFlag("waitingForInput")
    .notify(false)
    .build();

BotApp.executor.submit(message);
```

--------------------------------

### Send Document Message with Caption and Keyboard

Source: https://context7.com/zoommax/onemessagebot/llms.txt

Demonstrates how to send a document file with a caption and an interactive keyboard. It requires the DocumentMessage class and keyboard utility classes. Inputs include the file path, chat ID, caption text, and keyboard button configurations. Outputs a DocumentMessage object ready for execution.

```java
import space.zoommax.view.DocumentMessage;
import space.zoommax.utils.keyboard.Keyboard;
import space.zoommax.utils.keyboard.Button;
import space.zoommax.utils.keyboard.ButtonType;
import java.io.File;
import java.util.ArrayList;
import java.util.List;

File document = new File("/path/to/document.pdf");

List<List<Button>> buttons = new ArrayList<>();
List<Button> row = new ArrayList<>();
row.add(new Button("Download", "download_doc", ButtonType.CALLBACK));
buttons.add(row);

DocumentMessage docMsg = DocumentMessage.builder()
    .chatId(123456789L)
    .documentAsFile(document)
    .caption("<b>Important Document</b>\nPlease review this file")
    .keyboard(Keyboard.builder()
        .chatId(123456789L)
        .keyboardButtons(buttons)
        .build())
    .build();

BotApp.executor.submit(docMsg);
```

--------------------------------

### Create Keyboard with Button List (Java)

Source: https://github.com/zoommax/onemessagebot/blob/master/one-message-bot-docs/docs/keyboard/keyboard.md

Illustrates constructing a Telegram bot keyboard by providing a list of button rows. Each row is a `List<Button>`, and the entire keyboard is a `List<List<Button>>`. This method offers programmatic control over button creation and arrangement.

```java
import space.zoommax.utils.keyboard.Button;
import space.zoommax.utils.keyboard.Keyboard;

import java.util.List;
import java.util.ArrayList;

List<Button> buttons = new ArrayList<>();
buttons.add(new Button("I will open a link", "http://example.com"));
buttons.add(new Button("I will perform a callback action", "any_data"));

List<Button> buttons2 = new ArrayList<>();
buttons2.add(new Button("I will also open a link", "tg://username"));

List<List<Button>> keyboardButtons = new ArrayList<>();
keyboardButtons.add(buttons);
keyboardButtons.add(buttons2);

Keyboard keyboard = Keyboard.builder()
        .chatId(123456789)
        .keyboardButtons(keyboardButtons)
        .build();
```

--------------------------------

### Manage Multi-Language Support

Source: https://context7.com/zoommax/onemessagebot/llms.txt

Explains how to implement multi-language support using translation files. The LocalizationManager class handles loading and retrieving translations based on language codes and keys. It supports loading from resources and custom directories. Inputs are language codes, translation keys, and optional formatting arguments. Outputs localized strings.

```java
import space.zoommax.utils.lang.LocalizationManager;
import space.zoommax.BotApp;
import java.nio.file.Paths;
import java.io.IOException;

// Translation files: translations/default_en_US.json, translations/default_ru_RU.json
// JSON format:
// {
//   "main": {
//     "welcome": "Welcome to the bot!",
//     "bot_starting": "Bot is starting..."
//   },
//   "keyboard": {
//     "next_button": "Next →",
//     "prev_button": "← Previous"
//   }
// }

LocalizationManager locManager = BotApp.localizationManager;

// Load translations from resources
locManager.loadTranslationsFromResources("/translations");

// Load custom translations from directory
try {
    locManager.loadTranslations(Paths.get("./custom_translations"));
} catch (IOException e) {
    e.printStackTrace();
}

// Get translation for user's language
String welcome = locManager.getTranslationForLanguage("default_en_US", "main.welcome");

// Get translation with formatting
String formatted = locManager.getTranslationForLanguage(
    "default_ru_RU",
    "main.user_greeting",
    "John",
    25
);

// Use in message
TextMessage message = TextMessage.builder()
    .chatId(123456789L)
    .text(locManager.getTranslationForLanguage("default_en_US", "main.welcome"))
    .build();
```

--------------------------------

### Update Inline Keyboard with Java

Source: https://context7.com/zoommax/onemessagebot/llms.txt

This Java code snippet shows how to dynamically update an inline keyboard attached to a message in response to a callback query. It leverages the `InlineKeyboard` and `Keyboard` builders from the `space.zoommax` library. The function `onCallbackQuery` checks the callback data and, if it matches 'show_more', constructs and returns a new keyboard configuration to replace the existing one.

```java
import space.zoommax.view.InlineKeyboard;
import space.zoommax.utils.keyboard.Keyboard;
import space.zoommax.utils.keyboard.Button;
import space.zoommax.utils.keyboard.ButtonType;
import java.util.ArrayList;
import java.util.List;

// Update keyboard in response to callback
@ViewMessageListener
public class KeyboardUpdater {

    public ViewMessage onCallbackQuery(String data, int messageId,
                                      long chatId, Update update) {
        if (data.equals("show_more")) {
            // Create new keyboard with additional options
            List<List<Button>> buttons = new ArrayList<>();
            List<Button> row1 = new ArrayList<>();
            row1.add(new Button("Option A", "opt_a", ButtonType.CALLBACK));
            row1.add(new Button("Option B", "opt_b", ButtonType.CALLBACK));
            buttons.add(row1);

            List<Button> row2 = new ArrayList<>();
            row2.add(new Button("Option C", "opt_c", ButtonType.CALLBACK));
            row2.add(new Button("Hide", "show_less", ButtonType.CALLBACK));
            buttons.add(row2);

            return InlineKeyboard.builder()
                .chatId(chatId)
                .keyboard(Keyboard.builder()
                    .chatId(chatId)
                    .keyboardButtons(buttons)
                    .build())
                .build();
        }
        return null;
    }
}
```

--------------------------------

### Create Keyboard with Formatted Code (Java)

Source: https://github.com/zoommax/onemessagebot/blob/master/one-message-bot-docs/docs/keyboard/keyboard.md

Demonstrates creating a Telegram bot keyboard using a formatted string. The `code` parameter accepts a string where button definitions are enclosed in `{}` and rows are separated by `\n`. Characters outside of `{}` are ignored, allowing for visual separation.

```java
import space.zoommax.utils.keyboard.Keyboard;

Keyboard keyboard = Keyboard.builder()
        .chatId(123456789)
        .code("{I will open a link;http://example.com}\n{I will perform a callback action;any_data}")
        .build();
```

```java
import space.zoommax.utils.keyboard.Keyboard;

Keyboard keyboard = Keyboard.builder()
        .chatId(123456789)
        .code("{I will open a link;http://example.com}{I will perform a callback action;any_data}\n{I will also open a link;tg://username}")
        .build();
```

```java
import space.zoommax.utils.keyboard.Keyboard;

Keyboard keyboard = Keyboard.builder()
        .chatId(123456789)
        .code("{I will open a link;http://example.com}{I will perform a callback action;any_data}\n" +
                "_____>!@_________{I will also open a link;tg://username}______acfd_______")
        .build();
```

--------------------------------

### Gradle Dependency for OneMessageBot

Source: https://github.com/zoommax/onemessagebot/blob/master/one-message-bot-docs/docs/index.md

This Groovy snippet demonstrates how to include the OneMessageBot library in your Gradle project. It uses the 'implementation' configuration to add the specified artifact and version.

```groovy
implementation 'space.zoommax:OneMessageBot:2.1.4.8'
```

--------------------------------

### Keyboard Configuration Error Handling (Java)

Source: https://github.com/zoommax/onemessagebot/blob/master/one-message-bot-docs/docs/keyboard/keyboard.md

Shows the exception thrown when attempting to configure a keyboard using both the `code` and `keyboardButtons` parameters simultaneously. This ensures that only one method of keyboard definition is used.

```java
IllegalArgumentException("Keyboard cannot have both code and buttons")
```

--------------------------------

### Send Document with URL and Keyboard using DocumentMessage (Java)

Source: https://github.com/zoommax/onemessagebot/blob/master/one-message-bot-docs/docs/viewmessage/documentmessage.md

This Java code demonstrates how to use the DocumentMessage builder to send a document via URL. It includes setting the chat ID, document URL, a custom keyboard, caption, message flag, and notification preference. The document can also be provided as a file or byte array.

```java
import space.zoommax.view.DocumentMessage;
import java.io.File;

public class example {

    public static void main(String[] args) {
        DocumentMessage documentMessage = DocumentMessage.builder()
                .chatId(123456789)
                .documentAsUrl("https://example.com/document.pdf")
                /*optional
                .documentAsFile(new File("path/to/document.pdf"))
                .documentAsBytes(new byte[]{1,2,3,4,5})
                 */
                .keyboard(Keyboard.builder()
                        .chatId(123456789)
                        .code("{Google;https://google.ru}{Yandex;https://ya.ru}\n" +
                                "{Start;strt}")
                        .build())
                .caption("Hello")
                .onMessageFlag("start")
                .notify(false)
                .build();

        documentMessage.run();
    }
}
```

--------------------------------

### AudioMessage Builder API

Source: https://github.com/zoommax/onemessagebot/blob/master/one-message-bot-docs/docs/viewmessage/audiomessage.md

This section details the parameters and usage of the AudioMessage builder for sending audio files.

```APIDOC
## AudioMessage Builder

### Description
Provides a builder pattern to construct and send audio messages with various configurations.

### Method
POST (Implicitly through `run()` method)

### Endpoint
`/zoommax/onemessagebot/audiomessage` (Conceptual endpoint for sending)

### Parameters
#### Request Body Parameters
- **chatId** (integer) - Required - The unique identifier for the chat.
- **audioAsUrl** (string) - Optional - The URL pointing to the audio file. Use either this or `audioAsFile` or `audioAsBytes`.
- **audioAsFile** (File) - Optional - The audio file itself. Use either this or `audioAsUrl` or `audioAsBytes`.
- **audioAsBytes** (byte[]) - Optional - The raw byte array of the audio file. Use either this or `audioAsUrl` or `audioAsFile`.
- **caption** (string) - Optional - A text caption to accompany the audio message.
- **keyboard** (Keyboard) - Optional - A custom keyboard to be attached to the message.
- **onMessageFlag** (string) - Optional - A flag used for specific message processing logic.
- **notify** (boolean) - Optional - If true, the message will trigger a notification. Defaults to `false`.

### Request Example
```java
AudioMessage audioMessage = AudioMessage.builder()
    .chatId(123456789)
    .audioAsUrl("https://example.com/audio.mp3")
    .caption("Hello")
    .onMessageFlag("start")
    .notify(false)
    .build();

audioMessage.run();
```

### Response
#### Success Response (200)
Represents the sent message, potentially returned as a `ViewMessage` object upon successful execution of the `run()` method.

#### Response Example
(Conceptual, actual response depends on execution context)
```json
{
  "messageId": "some_id",
  "chatId": 123456789,
  "status": "sent"
}
```
```

--------------------------------

### Create Telegram Buttons using Formatted Strings (Java)

Source: https://github.com/zoommax/onemessagebot/blob/master/one-message-bot-docs/docs/keyboard/button.md

Demonstrates creating Telegram buttons using a formatted string where the text and action are delimited by a semicolon and enclosed in curly braces. The action prefix determines the button's functionality (Mini App, Link, or Callback).

```java
import space.zoommax.utils.keyboard.Button;

Button button1 = new Button("{I will open a Telegram Mini App;mapphttp://example.com}");
Button button2 = new Button("{I will open a link;http://example.com}");
Button button3 = new Button("{I will also open a link;tg://username}");
Button button4 = new Button("{I will perform a callback action;any_data}");
```

--------------------------------

### Handle Payments with Invoices

Source: https://context7.com/zoommax/onemessagebot/llms.txt

Processes payment transactions using invoice messages. It supports creating and sending invoices, and handling payment success or refund events. Dependencies include classes for invoice messages, payment types, and update handling.

```java
import space.zoommax.view.InvoiceMessage;
import space.zoommax.utils.PaymentType;
import space.zoommax.utils.ViewMessageListener;
import space.zoommax.view.ViewMessage;
import com.pengrad.telegrambot.model.Update;
import com.pengrad.telegrambot.model.request.LabeledPrice;

@ViewMessageListener
public class PaymentHandler {

    // Create and send invoice
    public ViewMessage createInvoice(long chatId) {
        LabeledPrice[] prices = new LabeledPrice[]{
            new LabeledPrice("Product", 1000),
            new LabeledPrice("Tax", 100)
        };

        return InvoiceMessage.builder()
            .chatId(chatId)
            .title("Product Purchase")
            .description("Buy our amazing product")
            .payload("product_123")
            .providerToken("PAYMENT_PROVIDER_TOKEN")
            .currency("USD")
            .prices(prices)
            .build();
    }

    // Handle payment result
    public ViewMessage onPayment(PaymentType type, String payload, 
                                int messageId, long chatId, Update update) {
        if (type == PaymentType.PAYMENT && payload.equals("product_123")) {
            // Payment successful
            int amount = update.message().successfulPayment().totalAmount();
            String currency = update.message().successfulPayment().currency();

            return TextMessage.builder()
                .chatId(chatId)
                .text("<b>Payment Successful!</b>\nAmount: " + amount + " " + currency)
                .build();

        } else if (type == PaymentType.REFUND) {
            // Payment refunded
            return TextMessage.builder()
                .chatId(chatId)
                .text("Your payment has been refunded")
                .build();
        }
        return null;
    }
}
```

--------------------------------

### Register Event Listeners for Telegram Bot Interactions

Source: https://context7.com/zoommax/onemessagebot/llms.txt

This Java code registers event listeners for a OneMessageBot. It defines handlers for commands (like /start), callback queries from buttons, and regular text messages. The handlers return `ViewMessage` objects, which the framework uses to update the bot's message and keyboard dynamically.

```java
import space.zoommax.utils.ViewMessageListener;
import space.zoommax.view.TextMessage;
import space.zoommax.view.ViewMessage;
import space.zoommax.utils.keyboard.Keyboard;
import space.zoommax.utils.keyboard.Button;
import space.zoommax.utils.keyboard.ButtonType;
import com.pengrad.telegrambot.model.Update;
import java.util.ArrayList;
import java.util.List;

@ViewMessageListener
public class BotEventHandler {

    // Handle /start command
    public ViewMessage onCommand(String command, int messageId, long chatId, Update update) {
        if (command.equals("/start")) {
            List<List<Button>> buttons = new ArrayList<>();
            List<Button> row1 = new ArrayList<>();
            row1.add(new Button("Settings", "settings", ButtonType.CALLBACK));
            row1.add(new Button("Help", "help", ButtonType.CALLBACK));
            buttons.add(row1);

            List<Button> row2 = new ArrayList<>();
            row2.add(new Button("GitHub", "https://github.com", ButtonType.LINK));
            buttons.add(row2);

            Keyboard keyboard = Keyboard.builder()
                .chatId(chatId)
                .keyboardButtons(buttons)
                .build();

            return TextMessage.builder()
                .chatId(chatId)
                .text("<b>Welcome!</b>\nChoose an option:")
                .keyboard(keyboard)
                .build();
        }
        return null;
    }

    // Handle button callbacks
    public ViewMessage onCallbackQuery(String data, int messageId, long chatId, Update update) {
        if (data.equals("settings")) {
            return TextMessage.builder()
                .chatId(chatId)
                .text("Settings menu opened")
                .keyboard(Keyboard.builder().chatId(chatId).keyboardButtons(new ArrayList<>()).build())
                .build();
        }
        return null;
    }

    // Handle text messages with flag
    public ViewMessage onMessage(String text, int messageId, long chatId, String flag, Update update) {
        if (flag.equals("waitingForName")) {
            return TextMessage.builder()
                .chatId(chatId)
                .text("Your name is: " + text)
                .onMessageFlag("")
                .build();
        }
        return null;
    }
}
```

--------------------------------

### Configure Localization Settings in BotSettings

Source: https://github.com/zoommax/onemessagebot/blob/master/one-message-bot-docs/docs/localization/localization.md

This demonstrates how to set the default language for the bot and specify the directory path for translation files using BotSettings. It's crucial for enabling multi-language support.

```java
botSettings.setDefaultLanguage("default_en_US");
botSettings.setLanguageDirPath("/path/to/translations");
```

--------------------------------

### Configure Custom Database Type

Source: https://github.com/zoommax/onemessagebot/blob/master/one-message-bot-docs/docs/database/custom.md

Sets the bot to use a custom database type. This is the initial step to enable custom database configurations. No external dependencies are required for this specific setting.

```java
botSettings.setDbType(DbType.CUSTOM)
```

--------------------------------

### Create Notification using Java

Source: https://github.com/zoommax/onemessagebot/blob/master/one-message-bot-docs/docs/notifications/notification.md

Demonstrates how to create and send a notification using the CreateNotification class in Java. It requires a message, chat ID, and optional image/file. The notification type can be FULL or ALERT.

```java
public class example {

    public static void main(String[] args) {
        CreateNotification createNotification = new CreateNotification(
                "Hello notify", // message
                String.valueOf(123456789), // tg_id
                null, // image
                NotificationType.FULL, // notificationType
                null // fileType
        );
        createNotification.run();
    }
}
```

--------------------------------

### Schedule Message Update with Time - Java

Source: https://github.com/zoommax/onemessagebot/blob/master/one-message-bot-docs/docs/viewmessage/updatemessage.md

This Java code illustrates how to create and schedule a message for update at a specific time. It utilizes the `viewMessageToUpdate`, `needUpdate`, and `updateTime` parameters of the TextMessage builder. The `run()` method initiates the process.

```java
import space.zoommax.view.TextMessage;

class Example {
    public static void main(String[] args) {
        ViewMessage viewMessage = TextMessage.builder()
                .text("Hello")
                .chatId(123456789)
                .viewMessageToUpdate(viewMessage.toString()) // Note: This line likely needs correction to use the actual serialized viewMessage
                .needUpdate(true)
                .updateTime(System.currentTimeMillis() + 10000)
                .build();
        viewMessage.run();
    }
}
```

--------------------------------

### Create Telegram Buttons with Type Specification (Java)

Source: https://github.com/zoommax/onemessagebot/blob/master/one-message-bot-docs/docs/keyboard/button.md

Shows how to create Telegram buttons by providing the text, action, and an explicit ButtonType (CALLBACK, LINK, MINI_APP). This method offers precise control over the button's intended behavior.

```java
Button button1 = new Button("I will open a Telegram Mini App", "http://example.com", ButtonType.MINI_APP);
Button button2 = new Button("I will open a link", "http://example.com", ButtonType.LINK);
Button button3 = new Button("I will also open a link", "tg://username", ButtonType.LINK);
Button button4 = new Button("I will perform a callback action", "any_data", ButtonType.CALLBACK);
```

--------------------------------

### Set Custom Database User Credentials

Source: https://github.com/zoommax/onemessagebot/blob/master/one-message-bot-docs/docs/database/custom.md

Specifies the username and password for authenticating with the custom database. These are standard database credentials. Ensure the provided user has the necessary privileges.

```java
botSettings.setDbUser("user")
```

```java
botSettings.setDbPassword("password")
```

--------------------------------

### Create ViewMessage for Update - Java

Source: https://github.com/zoommax/onemessagebot/blob/master/one-message-bot-docs/docs/viewmessage/updatemessage.md

This snippet demonstrates how to construct a ViewMessage object using the TextMessage builder, setting the text content and chat ID. This object will be used to define the replacement message.

```java
ViewMessage viewMessage = TextMessage.builder()
    .text("Hello, world!")
    .chatId(123456789)
    .build();
```

--------------------------------

### Set Custom Database JDBC Connection

Source: https://github.com/zoommax/onemessagebot/blob/master/one-message-bot-docs/docs/database/custom.md

Allows providing a pre-established JDBC Connection object to the custom database. This bypasses the need to configure URL, user, password, and name separately. Requires a valid `java.sql.Connection` instance.

```java
botSettings.setDbConnection(connection)
```

--------------------------------

### Set Database Type to SQLite

Source: https://github.com/zoommax/onemessagebot/blob/master/one-message-bot-docs/docs/database/overview.md

Configures OneMessageBot to use SQLite as the database. This is achieved by calling the `setDbType` method on the `botSettings` object with the `DbType.SQLITE` enum value. SQLite is the default database and requires no further configuration.

```java
botSettings.setDbType(DbType.SQLITE)
```

--------------------------------

### Managing User Language Preferences (Java)

Source: https://github.com/zoommax/onemessagebot/blob/master/one-message-bot-docs/docs/localization/localization.md

These Java methods allow you to retrieve a user's current language preference and set a new language for them. The user's language is stored and retrieved from the database.

```java
String userLanguage = UserLanguage.getUserLanguage(chatId);
UserLanguage.setUserLanguage(chatId, "language_name");
```

--------------------------------

### Process Uploaded Photos

Source: https://context7.com/zoommax/onemessagebot/llms.txt

Handles the processing of photos uploaded by users. It extracts the largest photo available, retrieves its file ID, dimensions, and caption, and then formats this information into a response message. Dependencies include `PhotoSize`, `Update`, and `ViewMessage` classes.

```java
import space.zoommax.utils.ViewMessageListener;
import space.zoommax.view.ViewMessage;
import space.zoommax.view.TextMessage;
import com.pengrad.telegrambot.model.PhotoSize;
import com.pengrad.telegrambot.model.Update;

@ViewMessageListener
public class PhotoUploadHandler {

    public ViewMessage onPicture(PhotoSize[] photos, String caption, 
                                int messageId, long chatId, Update update) {
        // Get largest photo
        PhotoSize largestPhoto = photos[photos.length - 1];
        String fileId = largestPhoto.fileId();
        int width = largestPhoto.width();
        int height = largestPhoto.height();

        // Process the uploaded photo
        String response = String.format(
            "<b>Photo received!</b>\n" +
            "File ID: %s\n" +
            "Resolution: %dx%d\n" +
            "Caption: %s",
            fileId, width, height,
            caption != null ? caption : "No caption"
        );

        return TextMessage.builder()
            .chatId(chatId)
            .text(response)
            .build();
    }
}
```

--------------------------------

### Set Database Type to MongoDB

Source: https://github.com/zoommax/onemessagebot/blob/master/one-message-bot-docs/docs/database/overview.md

Configures OneMessageBot to use MongoDB as the database. This is achieved by calling the `setDbType` method on the `botSettings` object with the `DbType.MONGODB` enum value. No additional database connection details are required when using the default MongoDB configuration.

```java
botSettings.setDbType(DbType.MONGODB)
```

--------------------------------

### Set Custom Database URL

Source: https://github.com/zoommax/onemessagebot/blob/master/one-message-bot-docs/docs/database/custom.md

Configures the JDBC URL for the custom database connection. The URL should not include the database name. This setting requires a valid JDBC driver format for your chosen database.

```java
botSettings.setDbUrl("jdbc:postgresql://localhost:5432/")
```
Tokens:
Raw