import pro.zackpollard.telegrambot.api.TelegramBot; //导入依赖的package包/类
ReddigramBot() throws Exception {
    timer = new Timer();
    config = BotConfig.configFromFile(new File("config.json"));
    dataFile = DataFile.load(this);
    client = new RedditClient(UserAgent.of("server", "xyz.mkotb.reddigram", "1.0", config.redditUsername()));
    telegramBot = TelegramBot.login(config.botApiKey());
    liveManager = new LiveManager(this);

    telegramBot.getEventsManager().register(new InlineListener(this));
    telegramBot.getEventsManager().register(new CommandListener(this));
    telegramBot.startUpdates(true);
    log("Successfully logged in");

    timer.scheduleAtFixedRate(new OAuthTask(this), 0L, 3500000L); // every 58 minutes reauth.
    timer.scheduleAtFixedRate(new TimerTask() {
        @Override
        public void run() {
            if (dataFile != null) {
                dataFile.save();
            }
        }
    }, 0L, 600000L); // every 10m save data file
}
 

import pro.zackpollard.telegrambot.api.TelegramBot; //导入依赖的package包/类
public EchoBot() {

        //This returns a logged in TelegramBot instance or null if the API key was invalid.
        telegramBot = TelegramBot.login(API_KEY);
        //This registers the EchoListener Listener to this bot.
        telegramBot.getEventsManager().register(new EchoListener(telegramBot));
        //This method starts the retrieval of updates.
        //The boolean it accepts is to specify whether to retrieve messages
        //which were sent before the bot was started but after the bot was last turned off.
        telegramBot.startUpdates(false);

        //The following while(true) loop is simply for keeping the java application alive.
        //You can do this however you like, but none of the above methods are blocking and
        //so without this code the bot would simply boot then exit.
        while (true) {
            try {
                Thread.sleep(10000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
 

import pro.zackpollard.telegrambot.api.TelegramBot; //导入依赖的package包/类
public InlineTranslationBot() {

        //This returns a logged in TelegramBot instance or null if the API key was invalid.
        telegramBot = TelegramBot.login(API_KEY);
        //This registers the FormattingListener Listener to this bot.
        telegramBot.getEventsManager().register(new InlineTranslationListener(telegramBot));
        //This method starts the retrieval of updates.
        //The boolean it accepts is to specify whether to retrieve messages
        //which were sent before the bot was started but after the bot was last turned off.
        telegramBot.startUpdates(false);

        //The following while(true) loop is simply for keeping the java application alive.
        //You can do this however you like, but none of the above methods are blocking and
        //so without this code the bot would simply boot then exit.
        while (true) {
            try {
                Thread.sleep(10000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
 

import pro.zackpollard.telegrambot.api.TelegramBot; //导入依赖的package包/类
public InlineSpoilerBot() {

        instance = this;

        //This returns a logged in TelegramBot instance or null if the API key was invalid.
        telegramBot = TelegramBot.login(API_KEY);
        //This registers the SpoilerListener Listener to this bot.
        initSpoilerManager();
        telegramBot.getEventsManager().register(listener);
        //This method starts the retrieval of updates.
        //The boolean it accepts is to specify whether to retrieve messages
        //which were sent before the bot was started but after the bot was last turned off.
        telegramBot.startUpdates(false);

        //The following while(true) loop is simply for keeping the java application alive.
        //You can do this however you like, but none of the above methods are blocking and
        //so without this code the bot would simply boot then exit.
        while (true) {
            try {
                Thread.sleep(10000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
 

import pro.zackpollard.telegrambot.api.TelegramBot; //导入依赖的package包/类
public FormattingBot() {

        //This returns a logged in TelegramBot instance or null if the API key was invalid.
        telegramBot = TelegramBot.login(API_KEY);
        //This registers the FormattingListener Listener to this bot.
        telegramBot.getEventsManager().register(new FormattingListener(telegramBot));
        //This method starts the retrieval of updates.
        //The boolean it accepts is to specify whether to retrieve messages
        //which were sent before the bot was started but after the bot was last turned off.
        telegramBot.startUpdates(false);

        //The following while(true) loop is simply for keeping the java application alive.
        //You can do this however you like, but none of the above methods are blocking and
        //so without this code the bot would simply boot then exit.
        while (true) {
            try {
                Thread.sleep(10000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
 

import pro.zackpollard.telegrambot.api.TelegramBot; //导入依赖的package包/类
/**
 * This does generic processing of ReplyingOptions objects when sending a request to the API
 *
 * @param multipartBody     The MultipartBody that the ReplyingOptions content should be appended to
 * @param replyingOptions   The ReplyingOptions that were used in this request
 */
public static void processReplyContent(MultipartBody multipartBody, ReplyingOptions replyingOptions) {

    if (replyingOptions.getReplyTo() != 0)
        multipartBody.field("reply_to_message_id", String.valueOf(replyingOptions.getReplyTo()), "application/json; charset=utf8;");
    if (replyingOptions.getReplyMarkup() != null) {

        switch (replyingOptions.getReplyMarkup().getType()) {

            case FORCE_REPLY:
                multipartBody.field("reply_markup", TelegramBot.GSON.toJson(replyingOptions.getReplyMarkup(), ForceReply.class), "application/json; charset=utf8;");
                break;
            case KEYBOARD_HIDE:
                multipartBody.field("reply_markup", TelegramBot.GSON.toJson(replyingOptions.getReplyMarkup(), ReplyKeyboardHide.class), "application/json; charset=utf8;");
                break;
            case KEYBOARD_REMOVE:
                multipartBody.field("reply_markup", TelegramBot.GSON.toJson(replyingOptions.getReplyMarkup(), ReplyKeyboardRemove.class), "application/json; charset=utf8;");
                break;
            case KEYBOARD_MARKUP:
                multipartBody.field("reply_markup", TelegramBot.GSON.toJson(replyingOptions.getReplyMarkup(), ReplyKeyboardMarkup.class), "application/json; charset=utf8;");
                break;
            case INLINE_KEYBOARD_MARKUP:
                multipartBody.field("reply_markup", TelegramBot.GSON.toJson(replyingOptions.getReplyMarkup(), InlineKeyboardMarkup.class), "application/json; charset=utf8;");
                break;
        }
    }
}
 

import pro.zackpollard.telegrambot.api.TelegramBot; //导入依赖的package包/类
private MessageImpl(JSONObject jsonObject, TelegramBot telegramBot) {

        if (!jsonObject.isNull("result")) jsonObject = jsonObject.getJSONObject("result");

        jsonMessage = jsonObject;

        message_id = jsonObject.getInt("message_id");
        from = UserImpl.createUser(jsonObject.optJSONObject("from"));
        date = jsonObject.getLong("date");
        chat = ChatImpl.createChat(jsonObject.getJSONObject("chat"), telegramBot);
        forward_from = UserImpl.createUser(jsonObject.optJSONObject("forward_from"));
        forward_from_chat = ChatImpl.createChat(jsonObject.optJSONObject("forward_from_chat"), telegramBot);
        forward_from_message_id = jsonObject.optInt("forward_from_message_id");
        forward_date = jsonObject.optLong("forward_date");
        reply_to_message = MessageImpl.createMessage(jsonObject.optJSONObject("reply_to_message"), telegramBot);
        edit_date = jsonObject.optLong("edit_date");
        content = ContentImpl.createContent(jsonObject, telegramBot);

        this.telegramBot = telegramBot;
    }
 

import pro.zackpollard.telegrambot.api.TelegramBot; //导入依赖的package包/类
public static Chat createChat(JSONObject jsonObject, TelegramBot telegramBot) {

        if(jsonObject != null) {

            String chatType = jsonObject.getString("type");

            switch (chatType) {

                case "private":
                    return IndividualChatImpl.createIndividualChat(jsonObject, telegramBot);
                case "group":
                    return GroupChatImpl.createGroupChat(jsonObject, telegramBot);
                case "channel":
                    return ChannelChatImpl.createChannelChat(jsonObject, telegramBot);
                case "supergroup":
                    return SuperGroupChatImpl.createSuperGroupChat(jsonObject, telegramBot);
                default:
                    System.err.println("An invalid chat type was provided when creating a chat object. Chat type " + chatType + " was provided. Report this to @zackpollard.");
            }
        }

        return null;
    }
 

import pro.zackpollard.telegrambot.api.TelegramBot; //导入依赖的package包/类
/**
 * Gets the download link for this file
 *
 * @param telegramBot The TelegramBot instance that relates to this file
 *
 * @return The URL to download the file in String form
 */
default String getFileDownloadLink(TelegramBot telegramBot) {

    JSONObject jsonObject = null;

    try {
        jsonObject = Unirest.post(telegramBot.getBotAPIUrl() + "getFile")
                .field("file_id", getFileId(), "application/json; charset=utf8;")
                .asJson().getBody().getObject();
    } catch (UnirestException e) {
        e.printStackTrace();
    }

    if (jsonObject != null) {

        if (jsonObject.getBoolean("ok")) {

            return "https://api.telegram.org/file/bot" + telegramBot.getAuthToken() + "/" + jsonObject.getJSONObject("result").getString("file_path");
        }
    }

    return null;
}
 

import pro.zackpollard.telegrambot.api.TelegramBot; //导入依赖的package包/类
/**
 * Downloads the file to a set location on disk
 *
 * @param telegramBot       The TelegramBot instance that relates to this file
 * @param downloadLocation  A File object pointing to the location where you want to download the file
 *
 * @return A File object that points to the downloaded file
 */
default java.io.File downloadFile(TelegramBot telegramBot, java.io.File downloadLocation) {

    String downloadLink = getFileDownloadLink(telegramBot);

    if (downloadLink != null) {

        try {
            FileUtils.copyURLToFile(new URL(downloadLink), downloadLocation);
        } catch (IOException e) {

            System.err.println("The file download failed due to the provided URL being malformed in some way. Provided URL was " + downloadLink);
        }
    }

    return downloadLocation;
}
 

import pro.zackpollard.telegrambot.api.TelegramBot; //导入依赖的package包/类
private RemindMeBot(String key) {
    TimeZone.setDefault(TimeZone.getTimeZone("UTC"));
    instance = this;
    this.bot = TelegramBot.login(key);
    bot.getEventsManager().register(new RemindMeBotListener());
    bot.startUpdates(false);
    storageHook = new StorageHook();
    reminderManager = new ReminderManager();

    //Save reminder map on shutdown to ensure persistence of reminders
    Runtime.getRuntime().addShutdownHook(new Thread(storageHook::save));

    this.debug("Bot started!");
}
 

import pro.zackpollard.telegrambot.api.TelegramBot; //导入依赖的package包/类
public WhatIsBot(String key) {
    System.out.println("Initialising bot");
    bot = TelegramBot.login(key);
    if (bot == null) {
        System.out.println("Failed to login! Faulty API key?");
        System.exit(1);
    }
    System.out.println("Registering events");
    bot.getEventsManager().register(new WhatIsBotListener(this));
    bot.startUpdates(false);
    System.out.println("Bot initialised!");
}
 

import pro.zackpollard.telegrambot.api.TelegramBot; //导入依赖的package包/类
private Conversation(TelegramBot bot, Map<String, Object> sessionData, Chat forWhom, boolean silent,
                    boolean disableGlobalEvents, List<ConversationPrompt> prompts,
                     Predicate<User> userPredicate, boolean repliesOnly,
                     BiConsumer<Conversation, ConversationContext> endCallback,
                     BiPredicate<ConversationContext, Content> endPredicate,
                     long timeout, SendableMessage timeoutMessage) {
    this.forWhom = forWhom;
    this.context = new ConversationContext(this, bot, sessionData);
    this.currentPrompt = prompts.get(promptIndex);
    this.prompts = Collections.unmodifiableList(prompts);
    this.silent = silent;
    this.disableGlobalEvents = disableGlobalEvents;
    this.userPredicate = (userPredicate == null) ? (user) -> true : userPredicate;
    this.repliesOnly = repliesOnly;
    this.endCallback = endCallback;
    this.endPredicate = endPredicate;

    if (timeout > 0) {
        TIMER.schedule(new TimerTask() {
            @Override
            public void run() {
                if (isVirgin()) {
                    if (timeoutMessage != null) {
                        sendMessage(timeoutMessage);
                    }

                    end();
                }
            }
        }, TimeUnit.SECONDS.toMillis(timeout));
    }
}
 

import pro.zackpollard.telegrambot.api.TelegramBot; //导入依赖的package包/类
private ConversationRegistryImpl(TelegramBot bot) {
    bot.getEventsManager().register(new Listener() {
        @Override
        @Event.Handler(ignoreCancelled = true, priority = Event.Priority.LOWEST)
        public void onMessageReceived(MessageReceivedEvent event) {
            if (processMessage(event.getMessage())) {
                event.setCancelled(true);
            }
        }
    });
}
 

import pro.zackpollard.telegrambot.api.TelegramBot; //导入依赖的package包/类
private InlineMenuRegistryImpl(TelegramBot bot) {
    bot.getEventsManager().register(new Listener() {
        @Event.Handler(ignoreCancelled = true, priority = Event.Priority.LOWEST)
        @Override
        public void onCallbackQueryReceivedEvent(CallbackQueryReceivedEvent event) {
            if (process(event.getCallbackQuery())) {
                event.setCancelled(true);
            }
        }
    });
}
 

import pro.zackpollard.telegrambot.api.TelegramBot; //导入依赖的package包/类
public static UserProfilePhotos createUserProfilePhotos(long user_id, TelegramBot telegramBot) {

        try {
            JSONObject json = Unirest.post(telegramBot.getBotAPIUrl() + "getUserProfilePhotos")
                    .queryString("user_id", user_id).asJson().getBody().getObject();
            if(json.getBoolean("ok")) {
                return new UserProfilePhotosImpl(json.getJSONObject("result"));
            }
        } catch (UnirestException e) {
            e.printStackTrace();
        }

        return null;
    }
 

import pro.zackpollard.telegrambot.api.TelegramBot; //导入依赖的package包/类
protected CallbackQueryImpl(JSONObject jsonObject, TelegramBot telegramBot) {

        this.id = jsonObject.getString("id");
        this.from = UserImpl.createUser(jsonObject.getJSONObject("from"));
        this.data = jsonObject.optString("data");
        this.chatInstance = jsonObject.getString("chat_instance");

        this.jsonCallbackQuery = jsonObject;

        this.telegramBot = telegramBot;
    }
 

import pro.zackpollard.telegrambot.api.TelegramBot; //导入依赖的package包/类
private SuperGroupChatImpl(JSONObject jsonObject, TelegramBot telegramBot) {

        this.id = jsonObject.getLong("id");
        this.username = "@" + jsonObject.optString("username");
        this.title = jsonObject.getString("title");
        this.allMembersAreAdministrators = jsonObject.optBoolean("all_members_are_administrators");
        this.telegramBot = telegramBot;
    }
 

import pro.zackpollard.telegrambot.api.TelegramBot; //导入依赖的package包/类
private GroupChatImpl(JSONObject jsonObject, TelegramBot telegramBot) {

        this.id = jsonObject.getInt("id");
        this.title = jsonObject.getString("title");
        this.allMembersAreAdministrators = jsonObject.optBoolean("all_members_are_administrators");
        this.telegramBot = telegramBot;
    }
 

import pro.zackpollard.telegrambot.api.TelegramBot; //导入依赖的package包/类
/**
 * Create an InputFile object based on an external URL to be sent within a SendableMessage
 *
 * @param url The URL of the file you want this InputFile to point to
 */
public InputFile(URL url) {

    File file = TelegramBot.getFileManager().getFile(url);
    String extension = null;
    if (file == null) {
        try {
            String stringifiedUrl = url.toExternalForm();
            HttpResponse<InputStream> response = Unirest.get(stringifiedUrl).asBinary();
            extension = FileExtension.getByMimeType(response.getHeaders().getFirst("content-type"));
            if (extension == null) {
                extension = stringifiedUrl.substring(stringifiedUrl.lastIndexOf('.') + 1);

                int variableIndex = extension.indexOf('?');
                if (variableIndex > 0) extension = extension.substring(0, variableIndex);

                if (extension.length() > 4) {
                    extension = null; // Default to .tmp if there was no valid extension
                }
            }
            file = File.createTempFile("jtb-" + System.currentTimeMillis(), "." + extension, FileManager.getTemporaryFolder());
            file.deleteOnExit();
            TelegramBot.getFileManager().cacheUrl(url, file);
            Files.copy(response.getRawBody(), file.toPath(), StandardCopyOption.REPLACE_EXISTING);
        } catch (UnirestException | IOException ex) {
            ex.printStackTrace();
        }
    }
    this.fileName = FilenameUtils.getBaseName(url.toString()) + "." + extension;
    this.file = file;
    this.fileID = TelegramBot.getFileManager().getFileID(file);
    this.inputStream = null;
}