From ffcdbd126ed68eda0f575628a6fb4a58ee6a34e7 Mon Sep 17 00:00:00 2001 From: Ruben Bermudez Date: Fri, 21 Jul 2017 16:17:48 +0200 Subject: [PATCH] Update version 3.2 --- README.md | 8 +- TelegramBots.wiki/Changelog.md | 13 +- TelegramBots.wiki/Getting-Started.md | 4 +- TelegramBots.wiki/How-To-Update.md | 7 +- pom.xml | 4 +- telegrambots-abilities/README.md | 8 +- telegrambots-abilities/pom.xml | 10 +- .../abilitybots/api/objects/Ability.java | 1 + .../abilitybots/api/objects/Reply.java | 1 + .../api/sender/DefaultMessageSender.java | 132 +++++------ telegrambots-extensions/README.md | 4 +- telegrambots-extensions/pom.xml | 4 +- .../TelegramLongPollingCommandBot.java | 42 +--- telegrambots-meta/pom.xml | 2 +- .../org/telegram/telegrambots/ApiContext.java | 1 + .../api/methods/stickers/AddStickerToSet.java | 190 +++++++++++++++ .../methods/stickers/CreateNewStickerSet.java | 220 ++++++++++++++++++ .../stickers/DeleteStickerFromSet.java | 78 +++++++ .../api/methods/stickers/GetStickerSet.java | 79 +++++++ .../stickers/SetStickerPositionInSet.java | 94 ++++++++ .../methods/stickers/UploadStickerFile.java | 114 +++++++++ .../telegrambots/api/objects/Message.java | 1 + .../api/objects/stickers/MaskPosition.java | 89 +++++++ .../api/objects/{ => stickers}/Sticker.java | 22 +- .../api/objects/stickers/StickerSet.java | 57 +++++ .../telegram/telegrambots/bots/AbsSender.java | 110 ++++++++- telegrambots/pom.xml | 4 +- .../telegrambots/bots/DefaultAbsSender.java | 97 ++++++++ 28 files changed, 1255 insertions(+), 141 deletions(-) create mode 100644 telegrambots-meta/src/main/java/org/telegram/telegrambots/api/methods/stickers/AddStickerToSet.java create mode 100644 telegrambots-meta/src/main/java/org/telegram/telegrambots/api/methods/stickers/CreateNewStickerSet.java create mode 100644 telegrambots-meta/src/main/java/org/telegram/telegrambots/api/methods/stickers/DeleteStickerFromSet.java create mode 100644 telegrambots-meta/src/main/java/org/telegram/telegrambots/api/methods/stickers/GetStickerSet.java create mode 100644 telegrambots-meta/src/main/java/org/telegram/telegrambots/api/methods/stickers/SetStickerPositionInSet.java create mode 100644 telegrambots-meta/src/main/java/org/telegram/telegrambots/api/methods/stickers/UploadStickerFile.java create mode 100644 telegrambots-meta/src/main/java/org/telegram/telegrambots/api/objects/stickers/MaskPosition.java rename telegrambots-meta/src/main/java/org/telegram/telegrambots/api/objects/{ => stickers}/Sticker.java (70%) create mode 100644 telegrambots-meta/src/main/java/org/telegram/telegrambots/api/objects/stickers/StickerSet.java diff --git a/README.md b/README.md index bf9022a9..98e5ecce 100644 --- a/README.md +++ b/README.md @@ -27,16 +27,16 @@ Just import add the library to your project with one of these options: org.telegram telegrambots - 3.1.2 + 3.2 ``` ```gradle - compile "org.telegram:telegrambots:3.1.2" + compile "org.telegram:telegrambots:3.2" ``` - 2. Using Jitpack from [here](https://jitpack.io/#rubenlagus/TelegramBots/3.1.2) - 3. Download the jar(including all dependencies) from [here](https://github.com/rubenlagus/TelegramBots/releases/tag/v3.1.2) + 2. Using Jitpack from [here](https://jitpack.io/#rubenlagus/TelegramBots/3.2) + 3. Download the jar(including all dependencies) from [here](https://github.com/rubenlagus/TelegramBots/releases/tag/v3.2) In order to use Long Polling mode, just create your own bot extending `org.telegram.telegrambots.bots.TelegramLongPollingBot`. diff --git a/TelegramBots.wiki/Changelog.md b/TelegramBots.wiki/Changelog.md index b0dc16d6..0ef3a7b0 100644 --- a/TelegramBots.wiki/Changelog.md +++ b/TelegramBots.wiki/Changelog.md @@ -82,4 +82,15 @@ ### 3.1.2 ### -1. Fix bug #266 \ No newline at end of file +1. Fix bug #266 + +### 3.2 ### +1. Support for Api Version [3.2](https://core.telegram.org/bots/api-changelog#july-21-2017) +2. Deprecated all redundant methods in AbsSender, will be removed in next major release +3. New Abstract methods `addStickerToSet`, `createNewStickerSet` and `uploadStickerFile` in AbsSender. +4. Abilities module +5. Removed deprecated methods from previous versions +6. Bug fixing: #257, #270 +7. Simplify code from DefaultAbsSender: #272 + +**[[How to update to version 3.2|How-To-Update#3.2]]** \ No newline at end of file diff --git a/TelegramBots.wiki/Getting-Started.md b/TelegramBots.wiki/Getting-Started.md index 7c0893be..c45cc993 100644 --- a/TelegramBots.wiki/Getting-Started.md +++ b/TelegramBots.wiki/Getting-Started.md @@ -11,13 +11,13 @@ First you need ot get the library and add it to your project. There are few poss org.telegram telegrambots - 3.1.2 + 3.2 ``` * With **Gradle**: ```groovy - compile group: 'org.telegram', name: 'telegrambots', version: '3.1.2' + compile group: 'org.telegram', name: 'telegrambots', version: '3.2' ``` 2. Don't like **Maven Central Repository**? It can also be taken from [Jitpack](https://jitpack.io/#rubenlagus/TelegramBots). diff --git a/TelegramBots.wiki/How-To-Update.md b/TelegramBots.wiki/How-To-Update.md index a09bfae3..d641fa88 100644 --- a/TelegramBots.wiki/How-To-Update.md +++ b/TelegramBots.wiki/How-To-Update.md @@ -27,4 +27,9 @@ ### To version 3.0.2 ### 1. If you were using `TelegramLongPollingCommandBot`, add the new [extensions dependency](https://github.com/rubenlagus/TelegramBots/tree/master/telegrambots-extensions) to your maven and fix import statements in your project. -2. If you were using `TelegramLongPollingCommandBot`, make sure you start using constructors with username and prevent overriding `getUsername` method. \ No newline at end of file +2. If you were using `TelegramLongPollingCommandBot`, make sure you start using constructors with username and prevent overriding `getUsername` method. + + +### To version 3.2 ### +1. Replace usage of all deprecated methods from AbsSender with methods `execute` or `executeAsync`. +2. If you are extending AbsSender class, implement new added methods. \ No newline at end of file diff --git a/pom.xml b/pom.xml index 124187fc..af5ae0f0 100644 --- a/pom.xml +++ b/pom.xml @@ -7,7 +7,7 @@ org.telegram Bots pom - 3.1.2 + 3.2 telegrambots @@ -26,6 +26,6 @@ true - 3.1.2 + 3.2 \ No newline at end of file diff --git a/telegrambots-abilities/README.md b/telegrambots-abilities/README.md index 8837ed7d..c4f76df4 100644 --- a/telegrambots-abilities/README.md +++ b/telegrambots-abilities/README.md @@ -18,19 +18,19 @@ Usage org.telegram telegrambots-abilities - 3.1.1 + 3.2 ``` **Gradle** ```gradle - compile "org.telegram:telegrambots-abilities:3.1.1" + compile "org.telegram:telegrambots-abilities:3.2" ``` -**JitPack** - [JitPack](https://jitpack.io/#rubenlagus/TelegramBots/v3.1.1) +**JitPack** - [JitPack](https://jitpack.io/#rubenlagus/TelegramBots/v3.2) -**Plain imports** - [Jar](https://github.com/addo37/AbilityBots/releases/download/v1.2.5/AbilityBots-1.2.5.jar) | [fatJar](https://github.com/addo37/AbilityBots/releases/download/v1.2.5/AbilityBots-with-dependencies-1.2.5.jar) +**Plain imports** - [Here](https://github.com/rubenlagus/TelegramBots/releases/tag/v3.2) Motivation ---------- diff --git a/telegrambots-abilities/pom.xml b/telegrambots-abilities/pom.xml index 6ac35993..6017c0bc 100644 --- a/telegrambots-abilities/pom.xml +++ b/telegrambots-abilities/pom.xml @@ -5,7 +5,7 @@ 4.0.0 org.telegram telegrambots-abilities - 3.1.2 + 3.2 jar Telegram Ability Bot @@ -35,6 +35,12 @@ https://github.com/addo37 addo37 + + rberlopez@gmail.com + Ruben Bermudez + https://github.com/rubenlagus + rubenlagus + @@ -59,7 +65,7 @@ UTF-8 UTF-8 - 3.1.2 + 3.2 3.5 3.0.4 19.0 diff --git a/telegrambots-abilities/src/main/java/org/telegram/abilitybots/api/objects/Ability.java b/telegrambots-abilities/src/main/java/org/telegram/abilitybots/api/objects/Ability.java index 46a9e326..1064bb29 100644 --- a/telegrambots-abilities/src/main/java/org/telegram/abilitybots/api/objects/Ability.java +++ b/telegrambots-abilities/src/main/java/org/telegram/abilitybots/api/objects/Ability.java @@ -46,6 +46,7 @@ public final class Ability { private final List replies; private final List> flags; + @SafeVarargs private Ability(String name, String info, Locality locality, Privacy privacy, int argNum, Consumer action, Consumer postAction, List replies, Predicate... flags) { checkArgument(!isEmpty(name), "Method name cannot be empty"); checkArgument(!containsWhitespace(name), "Method name cannot contain spaces"); diff --git a/telegrambots-abilities/src/main/java/org/telegram/abilitybots/api/objects/Reply.java b/telegrambots-abilities/src/main/java/org/telegram/abilitybots/api/objects/Reply.java index e6e08e4c..113d26b8 100644 --- a/telegrambots-abilities/src/main/java/org/telegram/abilitybots/api/objects/Reply.java +++ b/telegrambots-abilities/src/main/java/org/telegram/abilitybots/api/objects/Reply.java @@ -27,6 +27,7 @@ public final class Reply { this.action = action; } + @SafeVarargs public static Reply of(Consumer action, Predicate... conditions) { return new Reply(asList(conditions), action); } diff --git a/telegrambots-abilities/src/main/java/org/telegram/abilitybots/api/sender/DefaultMessageSender.java b/telegrambots-abilities/src/main/java/org/telegram/abilitybots/api/sender/DefaultMessageSender.java index 6e49d764..f73f64ba 100644 --- a/telegrambots-abilities/src/main/java/org/telegram/abilitybots/api/sender/DefaultMessageSender.java +++ b/telegrambots-abilities/src/main/java/org/telegram/abilitybots/api/sender/DefaultMessageSender.java @@ -70,67 +70,67 @@ public class DefaultMessageSender implements MessageSender { @Override public Boolean answerInlineQuery(AnswerInlineQuery answerInlineQuery) throws TelegramApiException { - return bot.answerInlineQuery(answerInlineQuery); + return bot.execute(answerInlineQuery); } @Override public Boolean sendChatAction(SendChatAction sendChatAction) throws TelegramApiException { - return bot.sendChatAction(sendChatAction); + return bot.execute(sendChatAction); } @Override public Message forwardMessage(ForwardMessage forwardMessage) throws TelegramApiException { - return bot.forwardMessage(forwardMessage); + return bot.execute(forwardMessage); } @Override public Message sendLocation(SendLocation sendLocation) throws TelegramApiException { - return bot.sendLocation(sendLocation); + return bot.execute(sendLocation); } @Override public Message sendVenue(SendVenue sendVenue) throws TelegramApiException { - return bot.sendVenue(sendVenue); + return bot.execute(sendVenue); } @Override public Message sendContact(SendContact sendContact) throws TelegramApiException { - return bot.sendContact(sendContact); + return bot.execute(sendContact); } @Override public Boolean kickMember(KickChatMember kickChatMember) throws TelegramApiException { - return bot.kickMember(kickChatMember); + return bot.execute(kickChatMember); } @Override public Boolean unbanMember(UnbanChatMember unbanChatMember) throws TelegramApiException { - return bot.unbanMember(unbanChatMember); + return bot.execute(unbanChatMember); } @Override public Boolean leaveChat(LeaveChat leaveChat) throws TelegramApiException { - return bot.leaveChat(leaveChat); + return bot.execute(leaveChat); } @Override public Chat getChat(GetChat getChat) throws TelegramApiException { - return bot.getChat(getChat); + return bot.execute(getChat); } @Override public List getChatAdministrators(GetChatAdministrators getChatAdministrators) throws TelegramApiException { - return bot.getChatAdministrators(getChatAdministrators); + return bot.execute(getChatAdministrators); } @Override public ChatMember getChatMember(GetChatMember getChatMember) throws TelegramApiException { - return bot.getChatMember(getChatMember); + return bot.execute(getChatMember); } @Override public Integer getChatMemberCount(GetChatMemberCount getChatMemberCount) throws TelegramApiException { - return bot.getChatMemberCount(getChatMemberCount); + return bot.execute(getChatMemberCount); } @Override @@ -140,117 +140,117 @@ public class DefaultMessageSender implements MessageSender { @Override public Boolean deleteChatPhoto(DeleteChatPhoto deleteChatPhoto) throws TelegramApiException { - return bot.deleteChatPhoto(deleteChatPhoto); + return bot.execute(deleteChatPhoto); } @Override public void deleteChatPhoto(DeleteChatPhoto deleteChatPhoto, SentCallback sentCallback) throws TelegramApiException { - bot.deleteChatPhoto(deleteChatPhoto, sentCallback); + bot.executeAsync(deleteChatPhoto, sentCallback); } @Override public Boolean pinChatMessage(PinChatMessage pinChatMessage) throws TelegramApiException { - return bot.pinChatMessage(pinChatMessage); + return bot.execute(pinChatMessage); } @Override public void pinChatMessage(PinChatMessage pinChatMessage, SentCallback sentCallback) throws TelegramApiException { - bot.pinChatMessage(pinChatMessage, sentCallback); + bot.executeAsync(pinChatMessage, sentCallback); } @Override public Boolean unpinChatMessage(UnpinChatMessage unpinChatMessage) throws TelegramApiException { - return bot.unpinChatMessage(unpinChatMessage); + return bot.execute(unpinChatMessage); } @Override public void unpinChatMessage(UnpinChatMessage unpinChatMessage, SentCallback sentCallback) throws TelegramApiException { - bot.unpinChatMessage(unpinChatMessage, sentCallback); + bot.executeAsync(unpinChatMessage, sentCallback); } @Override public Boolean promoteChatMember(PromoteChatMember promoteChatMember) throws TelegramApiException { - return bot.promoteChatMember(promoteChatMember); + return bot.execute(promoteChatMember); } @Override public void promoteChatMember(PromoteChatMember promoteChatMember, SentCallback sentCallback) throws TelegramApiException { - bot.promoteChatMember(promoteChatMember, sentCallback); + bot.executeAsync(promoteChatMember, sentCallback); } @Override public Boolean restrictChatMember(RestrictChatMember restrictChatMember) throws TelegramApiException { - return bot.restrictChatMember(restrictChatMember); + return bot.execute(restrictChatMember); } @Override public void restrictChatMember(RestrictChatMember restrictChatMember, SentCallback sentCallback) throws TelegramApiException { - bot.restrictChatMember(restrictChatMember, sentCallback); + bot.executeAsync(restrictChatMember, sentCallback); } @Override public Boolean setChatDescription(SetChatDescription setChatDescription) throws TelegramApiException { - return bot.setChatDescription(setChatDescription); + return bot.execute(setChatDescription); } @Override public void setChatDescription(SetChatDescription setChatDescription, SentCallback sentCallback) throws TelegramApiException { - bot.setChatDescription(setChatDescription, sentCallback); + bot.executeAsync(setChatDescription, sentCallback); } @Override public Boolean setChatTite(SetChatTitle setChatTitle) throws TelegramApiException { - return bot.setChatTitle(setChatTitle); + return bot.execute(setChatTitle); } @Override public void setChatTite(SetChatTitle setChatTitle, SentCallback sentCallback) throws TelegramApiException { - bot.setChatTitle(setChatTitle, sentCallback); + bot.executeAsync(setChatTitle, sentCallback); } @Override public String exportChatInviteLink(ExportChatInviteLink exportChatInviteLink) throws TelegramApiException { - return bot.exportChatInviteLink(exportChatInviteLink); + return bot.execute(exportChatInviteLink); } @Override public void exportChatInviteLinkAsync(ExportChatInviteLink exportChatInviteLink, SentCallback sentCallback) throws TelegramApiException { - bot.exportChatInviteLinkAsync(exportChatInviteLink, sentCallback); + bot.executeAsync(exportChatInviteLink, sentCallback); } @Override public Boolean deleteMessage(DeleteMessage deleteMessage) throws TelegramApiException { - return bot.deleteMessage(deleteMessage); + return bot.execute(deleteMessage); } @Override public void deleteMessageAsync(DeleteMessage deleteMessage, SentCallback sentCallback) throws TelegramApiException { - bot.deleteMessage(deleteMessage, sentCallback); + bot.executeAsync(deleteMessage, sentCallback); } @Override public Serializable editMessageText(EditMessageText editMessageText) throws TelegramApiException { - return bot.editMessageText(editMessageText); + return bot.execute(editMessageText); } @Override public Serializable editMessageCaption(EditMessageCaption editMessageCaption) throws TelegramApiException { - return bot.editMessageCaption(editMessageCaption); + return bot.execute(editMessageCaption); } @Override public Serializable editMessageReplyMarkup(EditMessageReplyMarkup editMessageReplyMarkup) throws TelegramApiException { - return bot.editMessageReplyMarkup(editMessageReplyMarkup); + return bot.execute(editMessageReplyMarkup); } @Override public Boolean answerCallbackQuery(AnswerCallbackQuery answerCallbackQuery) throws TelegramApiException { - return bot.answerCallbackQuery(answerCallbackQuery); + return bot.execute(answerCallbackQuery); } @Override public UserProfilePhotos getUserProfilePhotos(GetUserProfilePhotos getUserProfilePhotos) throws TelegramApiException { - return bot.getUserProfilePhotos(getUserProfilePhotos); + return bot.execute(getUserProfilePhotos); } @Override @@ -275,7 +275,7 @@ public class DefaultMessageSender implements MessageSender { @Override public File getFile(GetFile getFile) throws TelegramApiException { - return bot.getFile(getFile); + return bot.execute(getFile); } @Override @@ -290,127 +290,127 @@ public class DefaultMessageSender implements MessageSender { @Override public Serializable setGameScore(SetGameScore setGameScore) throws TelegramApiException { - return bot.setGameScore(setGameScore); + return bot.execute(setGameScore); } @Override public Serializable getGameHighScores(GetGameHighScores getGameHighScores) throws TelegramApiException { - return bot.getGameHighScores(getGameHighScores); + return bot.execute(getGameHighScores); } @Override public Message sendGame(SendGame sendGame) throws TelegramApiException { - return bot.sendGame(sendGame); + return bot.execute(sendGame); } @Override public Boolean deleteWebhook(DeleteWebhook deleteWebhook) throws TelegramApiException { - return bot.deleteWebhook(deleteWebhook); + return bot.execute(deleteWebhook); } @Override public Message sendMessage(SendMessage sendMessage) throws TelegramApiException { - return bot.sendMessage(sendMessage); + return bot.execute(sendMessage); } @Override public void sendMessageAsync(SendMessage sendMessage, SentCallback sentCallback) throws TelegramApiException { - bot.sendMessageAsync(sendMessage, sentCallback); + bot.executeAsync(sendMessage, sentCallback); } @Override public void answerInlineQueryAsync(AnswerInlineQuery answerInlineQuery, SentCallback sentCallback) throws TelegramApiException { - bot.answerInlineQueryAsync(answerInlineQuery, sentCallback); + bot.executeAsync(answerInlineQuery, sentCallback); } @Override public void sendChatActionAsync(SendChatAction sendChatAction, SentCallback sentCallback) throws TelegramApiException { - bot.sendChatActionAsync(sendChatAction, sentCallback); + bot.executeAsync(sendChatAction, sentCallback); } @Override public void forwardMessageAsync(ForwardMessage forwardMessage, SentCallback sentCallback) throws TelegramApiException { - bot.forwardMessageAsync(forwardMessage, sentCallback); + bot.executeAsync(forwardMessage, sentCallback); } @Override public void sendLocationAsync(SendLocation sendLocation, SentCallback sentCallback) throws TelegramApiException { - bot.sendLocationAsync(sendLocation, sentCallback); + bot.executeAsync(sendLocation, sentCallback); } @Override public void sendVenueAsync(SendVenue sendVenue, SentCallback sentCallback) throws TelegramApiException { - bot.sendVenueAsync(sendVenue, sentCallback); + bot.executeAsync(sendVenue, sentCallback); } @Override public void sendContactAsync(SendContact sendContact, SentCallback sentCallback) throws TelegramApiException { - bot.sendContactAsync(sendContact, sentCallback); + bot.executeAsync(sendContact, sentCallback); } @Override public void kickMemberAsync(KickChatMember kickChatMember, SentCallback sentCallback) throws TelegramApiException { - bot.kickMemberAsync(kickChatMember, sentCallback); + bot.executeAsync(kickChatMember, sentCallback); } @Override public void unbanMemberAsync(UnbanChatMember unbanChatMember, SentCallback sentCallback) throws TelegramApiException { - bot.unbanMemberAsync(unbanChatMember, sentCallback); + bot.executeAsync(unbanChatMember, sentCallback); } @Override public void leaveChatAsync(LeaveChat leaveChat, SentCallback sentCallback) throws TelegramApiException { - bot.leaveChatAsync(leaveChat, sentCallback); + bot.executeAsync(leaveChat, sentCallback); } @Override public void getChatAsync(GetChat getChat, SentCallback sentCallback) throws TelegramApiException { - bot.getChatAsync(getChat, sentCallback); + bot.executeAsync(getChat, sentCallback); } @Override public void getChatAdministratorsAsync(GetChatAdministrators getChatAdministrators, SentCallback> sentCallback) throws TelegramApiException { - bot.getChatAdministratorsAsync(getChatAdministrators, sentCallback); + bot.executeAsync(getChatAdministrators, sentCallback); } @Override public void getChatMemberAsync(GetChatMember getChatMember, SentCallback sentCallback) throws TelegramApiException { - bot.getChatMemberAsync(getChatMember, sentCallback); + bot.executeAsync(getChatMember, sentCallback); } @Override public void getChatMemberCountAsync(GetChatMemberCount getChatMemberCount, SentCallback sentCallback) throws TelegramApiException { - bot.getChatMemberCountAsync(getChatMemberCount, sentCallback); + bot.executeAsync(getChatMemberCount, sentCallback); } @Override public void editMessageTextAsync(EditMessageText editMessageText, SentCallback sentCallback) throws TelegramApiException { - bot.editMessageTextAsync(editMessageText, sentCallback); + bot.executeAsync(editMessageText, sentCallback); } @Override public void editMessageCaptionAsync(EditMessageCaption editMessageCaption, SentCallback sentCallback) throws TelegramApiException { - bot.editMessageCaptionAsync(editMessageCaption, sentCallback); + bot.executeAsync(editMessageCaption, sentCallback); } @Override public void editMessageReplyMarkup(EditMessageReplyMarkup editMessageReplyMarkup, SentCallback sentCallback) throws TelegramApiException { - bot.editMessageReplyMarkup(editMessageReplyMarkup, sentCallback); + bot.executeAsync(editMessageReplyMarkup, sentCallback); } @Override public void answerCallbackQueryAsync(AnswerCallbackQuery answerCallbackQuery, SentCallback sentCallback) throws TelegramApiException { - bot.answerCallbackQueryAsync(answerCallbackQuery, sentCallback); + bot.executeAsync(answerCallbackQuery, sentCallback); } @Override public void getUserProfilePhotosAsync(GetUserProfilePhotos getUserProfilePhotos, SentCallback sentCallback) throws TelegramApiException { - bot.getUserProfilePhotosAsync(getUserProfilePhotos, sentCallback); + bot.executeAsync(getUserProfilePhotos, sentCallback); } @Override public void getFileAsync(GetFile getFile, SentCallback sentCallback) throws TelegramApiException { - bot.getFileAsync(getFile, sentCallback); + bot.executeAsync(getFile, sentCallback); } @Override @@ -425,22 +425,22 @@ public class DefaultMessageSender implements MessageSender { @Override public void setGameScoreAsync(SetGameScore setGameScore, SentCallback sentCallback) throws TelegramApiException { - bot.setGameScoreAsync(setGameScore, sentCallback); + bot.executeAsync(setGameScore, sentCallback); } @Override public void getGameHighScoresAsync(GetGameHighScores getGameHighScores, SentCallback> sentCallback) throws TelegramApiException { - bot.getGameHighScoresAsync(getGameHighScores, sentCallback); + bot.executeAsync(getGameHighScores, sentCallback); } @Override public void sendGameAsync(SendGame sendGame, SentCallback sentCallback) throws TelegramApiException { - bot.sendGameAsync(sendGame, sentCallback); + bot.executeAsync(sendGame, sentCallback); } @Override public void deleteWebhook(DeleteWebhook deleteWebhook, SentCallback sentCallback) throws TelegramApiException { - bot.deleteWebhook(deleteWebhook, sentCallback); + bot.executeAsync(deleteWebhook, sentCallback); } @Override diff --git a/telegrambots-extensions/README.md b/telegrambots-extensions/README.md index 0578c717..e6176851 100644 --- a/telegrambots-extensions/README.md +++ b/telegrambots-extensions/README.md @@ -16,12 +16,12 @@ Just import add the library to your project with one of these options: org.telegram telegrambotsextensions - 3.1.2 + 3.2 ``` 2. Using Gradle: ```gradle - compile "org.telegram:telegrambotsextensions:3.1.2" + compile "org.telegram:telegrambotsextensions:3.2" ``` \ No newline at end of file diff --git a/telegrambots-extensions/pom.xml b/telegrambots-extensions/pom.xml index c5a113d6..f4d66ff8 100644 --- a/telegrambots-extensions/pom.xml +++ b/telegrambots-extensions/pom.xml @@ -5,7 +5,7 @@ 4.0.0 org.telegram telegrambotsextensions - 3.1.2 + 3.2 jar Telegram Bots Extensions @@ -59,7 +59,7 @@ UTF-8 UTF-8 - 3.1.2 + 3.2 diff --git a/telegrambots-extensions/src/main/java/org/telegram/telegrambots/bots/commandbot/TelegramLongPollingCommandBot.java b/telegrambots-extensions/src/main/java/org/telegram/telegrambots/bots/commandbot/TelegramLongPollingCommandBot.java index 428e8279..1ddb1ac1 100644 --- a/telegrambots-extensions/src/main/java/org/telegram/telegrambots/bots/commandbot/TelegramLongPollingCommandBot.java +++ b/telegrambots-extensions/src/main/java/org/telegram/telegrambots/bots/commandbot/TelegramLongPollingCommandBot.java @@ -24,17 +24,6 @@ public abstract class TelegramLongPollingCommandBot extends TelegramLongPollingB private final CommandRegistry commandRegistry; private String botUsername; - /** - * Creates a TelegramLongPollingCommandBot using default options - * Use ICommandRegistry's methods on this bot to register commands - * - * @deprecated Uses {@link #TelegramLongPollingCommandBot(String)} instead - */ - @Deprecated - public TelegramLongPollingCommandBot() { - this(ApiContext.getInstance(DefaultBotOptions.class)); - } - /** * Creates a TelegramLongPollingCommandBot using default options * Use ICommandRegistry's methods on this bot to register commands @@ -45,19 +34,6 @@ public abstract class TelegramLongPollingCommandBot extends TelegramLongPollingB this(ApiContext.getInstance(DefaultBotOptions.class), botUsername); } - /** - * Creates a TelegramLongPollingCommandBot with custom options and allowing commands with - * usernames - * Use ICommandRegistry's methods on this bot to register commands - * @param options Bot options - * - * @deprecated Use {@link #TelegramLongPollingCommandBot(DefaultBotOptions, String)} instead - */ - @Deprecated - public TelegramLongPollingCommandBot(DefaultBotOptions options) { - this(options, true); - } - /** * Creates a TelegramLongPollingCommandBot with custom options and allowing commands with * usernames @@ -69,21 +45,6 @@ public abstract class TelegramLongPollingCommandBot extends TelegramLongPollingB this(options, true, botUsername); } - /** - * Creates a TelegramLongPollingCommandBot - * Use ICommandRegistry's methods on this bot to register commands - * @param options Bot options - * @param allowCommandsWithUsername true to allow commands with parameters (default), - * false otherwise - * - * @deprecated Use {@link #TelegramLongPollingCommandBot(DefaultBotOptions, boolean, String)} instead - */ - @Deprecated - public TelegramLongPollingCommandBot(DefaultBotOptions options, boolean allowCommandsWithUsername) { - super(options); - this.commandRegistry = new CommandRegistry(allowCommandsWithUsername, getBotUsername()); - } - /** * Creates a TelegramLongPollingCommandBot * Use ICommandRegistry's methods on this bot to register commands @@ -164,11 +125,10 @@ public abstract class TelegramLongPollingCommandBot extends TelegramLongPollingB } /** - * TODO This method will become final in next mayor release, avoid overriding it * @return Bot username */ @Override - public String getBotUsername() { + public final String getBotUsername() { return botUsername; } diff --git a/telegrambots-meta/pom.xml b/telegrambots-meta/pom.xml index a1341b3d..8d9fecf3 100644 --- a/telegrambots-meta/pom.xml +++ b/telegrambots-meta/pom.xml @@ -5,7 +5,7 @@ 4.0.0 org.telegram telegrambots-meta - 3.1.2 + 3.2 jar Telegram Bots Meta diff --git a/telegrambots-meta/src/main/java/org/telegram/telegrambots/ApiContext.java b/telegrambots-meta/src/main/java/org/telegram/telegrambots/ApiContext.java index 76bab484..6a647bbd 100644 --- a/telegrambots-meta/src/main/java/org/telegram/telegrambots/ApiContext.java +++ b/telegrambots-meta/src/main/java/org/telegram/telegrambots/ApiContext.java @@ -50,6 +50,7 @@ public class ApiContext { return INJECTOR; } + @SuppressWarnings("unchecked") private static class ApiModule extends AbstractModule { @Override protected void configure() { diff --git a/telegrambots-meta/src/main/java/org/telegram/telegrambots/api/methods/stickers/AddStickerToSet.java b/telegrambots-meta/src/main/java/org/telegram/telegrambots/api/methods/stickers/AddStickerToSet.java new file mode 100644 index 00000000..93b6031f --- /dev/null +++ b/telegrambots-meta/src/main/java/org/telegram/telegrambots/api/methods/stickers/AddStickerToSet.java @@ -0,0 +1,190 @@ +package org.telegram.telegrambots.api.methods.stickers; + +import com.fasterxml.jackson.core.type.TypeReference; +import org.telegram.telegrambots.api.methods.PartialBotApiMethod; +import org.telegram.telegrambots.api.objects.replykeyboard.ApiResponse; +import org.telegram.telegrambots.api.objects.stickers.MaskPosition; +import org.telegram.telegrambots.exceptions.TelegramApiRequestException; +import org.telegram.telegrambots.exceptions.TelegramApiValidationException; + +import java.io.File; +import java.io.IOException; +import java.io.InputStream; +import java.util.Objects; + +import static com.google.common.base.Preconditions.checkNotNull; + +/** + * @author Ruben Bermudez + * @version 1.0 + * Use this method to add a new sticker to a set created by the bot. Returns True on success. + */ +public class AddStickerToSet extends PartialBotApiMethod { + public static final String PATH = "addStickerToSet"; + + public static final String USERID_FIELD = "user_id"; + public static final String NAME_FIELD = "name"; + public static final String PNGSTICKER_FIELD = "png_sticker"; + public static final String EMOJIS_FIELD = "emojis"; + public static final String MASKPOSITION_FIELD = "mask_position"; + + private Integer userId; ///< User identifier of sticker set owner + private String name; ///< Sticker set name + private String emojis; ///< One or more emoji corresponding to the sticker + private MaskPosition maskPosition; ///< Position where the mask should be placed on faces + /** + * Png image with the sticker, must be up to 512 kilobytes in size, dimensions must not exceed 512px, + * and either width or height must be exactly 512px. Pass a file_id as a String to send a file + * that already exists on the Telegram servers, pass an HTTP URL as a String for Telegram + * to get a file from the Internet, or upload a new one using multipart/form-data. + */ + private Boolean isNewPngSticker; + private String pngSticker; + private File pngStickerFile; ///< New sticker file + private InputStream pngStickerStream; ///< New sticker stream + private String pngStickerName; ///< New sticker stream name + + public AddStickerToSet() { + super(); + } + + public AddStickerToSet(Integer userId, String name, String emojis) { + this.userId = checkNotNull(userId); + this.name = checkNotNull(name); + this.emojis = checkNotNull(emojis); + } + + public Integer getUserId() { + return userId; + } + + public AddStickerToSet setUserId(Integer userId) { + this.userId = userId; + return this; + } + + public String getPngSticker() { + return pngSticker; + } + + public AddStickerToSet setPngSticker(String pngSticker) { + this.pngSticker = pngSticker; + this.isNewPngSticker = false; + return this; + } + + public File getPngStickerFile() { + return pngStickerFile; + } + + public AddStickerToSet setPngStickerFile(File pngStickerFile) { + Objects.requireNonNull(pngStickerFile, "pngStickerFile cannot be null!"); + this.pngStickerFile = pngStickerFile; + this.isNewPngSticker = true; + return this; + } + + public InputStream getPngStickerStream() { + return pngStickerStream; + } + + public AddStickerToSet setPngStickerStream(String pngStickerName, InputStream pngStickerStream) { + Objects.requireNonNull(pngStickerName, "pngStickerName cannot be null!"); + Objects.requireNonNull(pngStickerStream, "pngStickerStream cannot be null!"); + this.pngStickerStream = pngStickerStream; + this.pngStickerName = pngStickerName; + this.isNewPngSticker = true; + return this; + } + + public String getPngStickerName() { + return pngStickerName; + } + + public Boolean isNewPngSticker() { + return isNewPngSticker; + } + + public String getName() { + return name; + } + + public AddStickerToSet setName(String name) { + this.name = name; + return this; + } + + public String getEmojis() { + return emojis; + } + + public AddStickerToSet setEmojis(String emojis) { + this.emojis = emojis; + return this; + } + + public MaskPosition getMaskPosition() { + return maskPosition; + } + + public AddStickerToSet setMaskPosition(MaskPosition maskPosition) { + this.maskPosition = maskPosition; + return this; + } + + @Override + public Boolean deserializeResponse(String answer) throws TelegramApiRequestException { + try { + ApiResponse result = OBJECT_MAPPER.readValue(answer, + new TypeReference>(){}); + if (result.getOk()) { + return result.getResult(); + } else { + throw new TelegramApiRequestException("Error creating new sticker set", result); + } + } catch (IOException e) { + throw new TelegramApiRequestException("Unable to deserialize response", e); + } + } + + @Override + public void validate() throws TelegramApiValidationException { + if (userId == null || userId <= 0) { + throw new TelegramApiValidationException("userId can't be empty", this); + } + if (name == null || name.isEmpty()) { + throw new TelegramApiValidationException("name can't be empty", this); + } + if (emojis == null || emojis.isEmpty()) { + throw new TelegramApiValidationException("emojis can't be empty", this); + } + if (isNewPngSticker) { + if (pngStickerFile == null && pngStickerStream == null) { + throw new TelegramApiValidationException("PngSticker can't be empty", this); + } + if (pngStickerStream != null && (pngStickerName == null || pngStickerName.isEmpty())) { + throw new TelegramApiValidationException("PngSticker name can't be empty", this); + } + } else if (pngSticker == null) { + throw new TelegramApiValidationException("PngSticker can't be empty", this); + } + if (maskPosition != null) { + maskPosition.validate(); + } + } + + @Override + public String toString() { + return "AddStickerToSet{" + + "userId=" + userId + + ", name='" + name + '\'' + + ", emojis='" + emojis + '\'' + + ", maskPosition=" + maskPosition + + ", isNewPngSticker=" + isNewPngSticker + + ", pngSticker='" + pngSticker + '\'' + + ", pngStickerFile=" + pngStickerFile + + ", pngStickerStream=" + pngStickerStream + + ", pngStickerName='" + pngStickerName + '\'' + + '}'; + } +} diff --git a/telegrambots-meta/src/main/java/org/telegram/telegrambots/api/methods/stickers/CreateNewStickerSet.java b/telegrambots-meta/src/main/java/org/telegram/telegrambots/api/methods/stickers/CreateNewStickerSet.java new file mode 100644 index 00000000..a9c2b308 --- /dev/null +++ b/telegrambots-meta/src/main/java/org/telegram/telegrambots/api/methods/stickers/CreateNewStickerSet.java @@ -0,0 +1,220 @@ +package org.telegram.telegrambots.api.methods.stickers; + +import com.fasterxml.jackson.core.type.TypeReference; +import org.telegram.telegrambots.api.methods.PartialBotApiMethod; +import org.telegram.telegrambots.api.objects.replykeyboard.ApiResponse; +import org.telegram.telegrambots.api.objects.stickers.MaskPosition; +import org.telegram.telegrambots.exceptions.TelegramApiRequestException; +import org.telegram.telegrambots.exceptions.TelegramApiValidationException; + +import java.io.File; +import java.io.IOException; +import java.io.InputStream; +import java.util.Objects; + +import static com.google.common.base.Preconditions.checkNotNull; + +/** + * @author Ruben Bermudez + * @version 1.0 + * Use this method to create new sticker set owned by a user. The bot will be able to edit the created sticker set. + * Returns True on success. + */ +public class CreateNewStickerSet extends PartialBotApiMethod { + public static final String PATH = "createNewStickerSet"; + + public static final String USERID_FIELD = "user_id"; + public static final String NAME_FIELD = "name"; + public static final String TITLE_FIELD = "title"; + public static final String PNGSTICKER_FIELD = "png_sticker"; + public static final String EMOJIS_FIELD = "emojis"; + public static final String CONTAINSMASKS_FIELD = "contains_masks"; + public static final String MASKPOSITION_FIELD = "mask_position"; + + private Integer userId; ///< User identifier of created sticker set owner + /** + * Name of sticker set, to be used in t.me/addstickers/ URLs. + * Can contain only english letters, digits and underscores. + * Must begin with a letter, can't contain consecutive underscores and must end in “_by_”. + * is case insensitive. 7-64 characters. + */ + private String name; ///< Sticker set title, 1-64 characters + private String title; ///< User identifier of created sticker set owner + private String emojis; ///< One or more emoji corresponding to the sticker + private Boolean containsMasks; ///< Pass True, if a set of mask stickers should be created + private MaskPosition maskPosition; ///< Position where the mask should be placed on faces + /** + * Png image with the sticker, must be up to 512 kilobytes in size, dimensions must not exceed 512px, + * and either width or height must be exactly 512px. + * Pass a file_id as a String to send a file that already exists on the Telegram servers, + * pass an HTTP URL as a String for Telegram to get a file from the Internet, or upload a new one + * using multipart/form-data. More info on Sending Files » + */ + private Boolean isNewPngSticker; + private String pngSticker; + private java.io.File pngStickerFile; ///< New sticker file + private InputStream pngStickerStream; ///< New sticker stream + private String pngStickerName; ///< New sticker stream name + + public CreateNewStickerSet() { + super(); + } + + public CreateNewStickerSet(Integer userId, String name, String title, String emojis) { + this.userId = checkNotNull(userId); + this.name = checkNotNull(name); + this.title = checkNotNull(title); + this.emojis = checkNotNull(emojis); + } + + public Integer getUserId() { + return userId; + } + + public void setUserId(Integer userId) { + this.userId = userId; + } + + public String getPngSticker() { + return pngSticker; + } + + public CreateNewStickerSet setPngSticker(String pngSticker) { + this.pngSticker = pngSticker; + this.isNewPngSticker = false; + return this; + } + + public File getPngStickerFile() { + return pngStickerFile; + } + + public CreateNewStickerSet setPngStickerFile(File pngStickerFile) { + Objects.requireNonNull(pngStickerFile, "pngStickerFile cannot be null!"); + this.pngStickerFile = pngStickerFile; + this.isNewPngSticker = true; + return this; + } + + public InputStream getPngStickerStream() { + return pngStickerStream; + } + + public CreateNewStickerSet setPngStickerStream(String pngStickerName, InputStream pngStickerStream) { + Objects.requireNonNull(pngStickerName, "pngStickerName cannot be null!"); + Objects.requireNonNull(pngStickerStream, "pngStickerStream cannot be null!"); + this.pngStickerStream = pngStickerStream; + this.pngStickerName = pngStickerName; + this.isNewPngSticker = true; + return this; + } + + public String getPngStickerName() { + return pngStickerName; + } + + public Boolean isNewPngSticker() { + return isNewPngSticker; + } + + public String getName() { + return name; + } + + public void setName(String name) { + this.name = name; + } + + public String getTitle() { + return title; + } + + public void setTitle(String title) { + this.title = title; + } + + public String getEmojis() { + return emojis; + } + + public void setEmojis(String emojis) { + this.emojis = emojis; + } + + public Boolean getContainsMasks() { + return containsMasks; + } + + public void setContainsMasks(Boolean containsMasks) { + this.containsMasks = containsMasks; + } + + public MaskPosition getMaskPosition() { + return maskPosition; + } + + public void setMaskPosition(MaskPosition maskPosition) { + this.maskPosition = maskPosition; + } + + @Override + public Boolean deserializeResponse(String answer) throws TelegramApiRequestException { + try { + ApiResponse result = OBJECT_MAPPER.readValue(answer, + new TypeReference>(){}); + if (result.getOk()) { + return result.getResult(); + } else { + throw new TelegramApiRequestException("Error creating new sticker set", result); + } + } catch (IOException e) { + throw new TelegramApiRequestException("Unable to deserialize response", e); + } + } + + @Override + public void validate() throws TelegramApiValidationException { + if (userId == null || userId <= 0) { + throw new TelegramApiValidationException("userId can't be empty", this); + } + if (name == null || name.isEmpty()) { + throw new TelegramApiValidationException("name can't be empty", this); + } + if (title == null || title.isEmpty()) { + throw new TelegramApiValidationException("userId can't be empty", this); + } + if (emojis == null || emojis.isEmpty()) { + throw new TelegramApiValidationException("emojis can't be empty", this); + } + if (isNewPngSticker) { + if (pngStickerFile == null && pngStickerStream == null) { + throw new TelegramApiValidationException("PngSticker can't be empty", this); + } + if (pngStickerStream != null && (pngStickerName == null || pngStickerName.isEmpty())) { + throw new TelegramApiValidationException("PngSticker name can't be empty", this); + } + } else if (pngSticker == null) { + throw new TelegramApiValidationException("PngSticker can't be empty", this); + } + if (maskPosition != null) { + maskPosition.validate(); + } + } + + @Override + public String toString() { + return "CreateNewStickerSet{" + + "userId=" + userId + + ", name='" + name + '\'' + + ", title='" + title + '\'' + + ", emojis='" + emojis + '\'' + + ", containsMasks=" + containsMasks + + ", maskPosition=" + maskPosition + + ", isNewPngSticker=" + isNewPngSticker + + ", pngSticker='" + pngSticker + '\'' + + ", pngStickerFile=" + pngStickerFile + + ", pngStickerStream=" + pngStickerStream + + ", pngStickerName='" + pngStickerName + '\'' + + '}'; + } +} diff --git a/telegrambots-meta/src/main/java/org/telegram/telegrambots/api/methods/stickers/DeleteStickerFromSet.java b/telegrambots-meta/src/main/java/org/telegram/telegrambots/api/methods/stickers/DeleteStickerFromSet.java new file mode 100644 index 00000000..391de9a4 --- /dev/null +++ b/telegrambots-meta/src/main/java/org/telegram/telegrambots/api/methods/stickers/DeleteStickerFromSet.java @@ -0,0 +1,78 @@ +package org.telegram.telegrambots.api.methods.stickers; + +import com.fasterxml.jackson.annotation.JsonProperty; +import com.fasterxml.jackson.core.type.TypeReference; +import org.telegram.telegrambots.api.methods.BotApiMethod; +import org.telegram.telegrambots.api.objects.replykeyboard.ApiResponse; +import org.telegram.telegrambots.exceptions.TelegramApiRequestException; +import org.telegram.telegrambots.exceptions.TelegramApiValidationException; + +import java.io.IOException; + +import static com.google.common.base.Preconditions.checkNotNull; + +/** + * @author Ruben Bermudez + * @version 1.0 + * Use this method to delete a sticker from a set created by the bot. Returns True on success. + */ +public class DeleteStickerFromSet extends BotApiMethod { + private static final String PATH = "deleteStickerFromSet"; + + private static final String STICKER_FIELD = "sticker"; + + @JsonProperty(STICKER_FIELD) + private String sticker; ///< File identifier of the sticker + + public DeleteStickerFromSet() { + super(); + } + + public DeleteStickerFromSet(String sticker) { + super(); + this.sticker = checkNotNull(sticker); + } + + @Override + public String getMethod() { + return PATH; + } + + @Override + public Boolean deserializeResponse(String answer) throws TelegramApiRequestException { + try { + ApiResponse result = OBJECT_MAPPER.readValue(answer, + new TypeReference>(){}); + if (result.getOk()) { + return result.getResult(); + } else { + throw new TelegramApiRequestException("Error deleting sticker from set", result); + } + } catch (IOException e) { + throw new TelegramApiRequestException("Unable to deserialize response", e); + } + } + + @Override + public void validate() throws TelegramApiValidationException { + if (sticker == null || sticker.isEmpty()) { + throw new TelegramApiValidationException("sticker can't be null", this); + } + } + + public String getSticker() { + return sticker; + } + + public DeleteStickerFromSet setSticker(String sticker) { + this.sticker = sticker; + return this; + } + + @Override + public String toString() { + return "DeleteStickerFromSet{" + + "sticker='" + sticker + '\'' + + '}'; + } +} diff --git a/telegrambots-meta/src/main/java/org/telegram/telegrambots/api/methods/stickers/GetStickerSet.java b/telegrambots-meta/src/main/java/org/telegram/telegrambots/api/methods/stickers/GetStickerSet.java new file mode 100644 index 00000000..9155c796 --- /dev/null +++ b/telegrambots-meta/src/main/java/org/telegram/telegrambots/api/methods/stickers/GetStickerSet.java @@ -0,0 +1,79 @@ +package org.telegram.telegrambots.api.methods.stickers; + +import com.fasterxml.jackson.annotation.JsonProperty; +import com.fasterxml.jackson.core.type.TypeReference; +import org.telegram.telegrambots.api.methods.BotApiMethod; +import org.telegram.telegrambots.api.objects.replykeyboard.ApiResponse; +import org.telegram.telegrambots.api.objects.stickers.StickerSet; +import org.telegram.telegrambots.exceptions.TelegramApiRequestException; +import org.telegram.telegrambots.exceptions.TelegramApiValidationException; + +import java.io.IOException; + +import static com.google.common.base.Preconditions.checkNotNull; + +/** + * @author Ruben Bermudez + * @version 1.0 + * Use this method to get a sticker set. On success, a StickerSet object is returned. + */ +public class GetStickerSet extends BotApiMethod { + private static final String PATH = "getStickerSet"; + + private static final String NAME_FIELD = "name"; + + @JsonProperty(NAME_FIELD) + private String name; ///< Name of the sticker set + + public GetStickerSet(String name) { + super(); + this.name = checkNotNull(name); + } + + public GetStickerSet() { + super(); + } + + @Override + public String getMethod() { + return PATH; + } + + @Override + public StickerSet deserializeResponse(String answer) throws TelegramApiRequestException { + try { + ApiResponse result = OBJECT_MAPPER.readValue(answer, + new TypeReference>(){}); + if (result.getOk()) { + return result.getResult(); + } else { + throw new TelegramApiRequestException("Error getting sticker set", result); + } + } catch (IOException e) { + throw new TelegramApiRequestException("Unable to deserialize response", e); + } + } + + @Override + public void validate() throws TelegramApiValidationException { + if (name == null || name.isEmpty()) { + throw new TelegramApiValidationException("Name can't be null", this); + } + } + + public String getName() { + return name; + } + + public GetStickerSet setName(String name) { + this.name = name; + return this; + } + + @Override + public String toString() { + return "GetStickerSet{" + + "name='" + name + '\'' + + '}'; + } +} diff --git a/telegrambots-meta/src/main/java/org/telegram/telegrambots/api/methods/stickers/SetStickerPositionInSet.java b/telegrambots-meta/src/main/java/org/telegram/telegrambots/api/methods/stickers/SetStickerPositionInSet.java new file mode 100644 index 00000000..49232f77 --- /dev/null +++ b/telegrambots-meta/src/main/java/org/telegram/telegrambots/api/methods/stickers/SetStickerPositionInSet.java @@ -0,0 +1,94 @@ +package org.telegram.telegrambots.api.methods.stickers; + +import com.fasterxml.jackson.annotation.JsonProperty; +import com.fasterxml.jackson.core.type.TypeReference; +import org.telegram.telegrambots.api.methods.BotApiMethod; +import org.telegram.telegrambots.api.objects.replykeyboard.ApiResponse; +import org.telegram.telegrambots.exceptions.TelegramApiRequestException; +import org.telegram.telegrambots.exceptions.TelegramApiValidationException; + +import java.io.IOException; + +import static com.google.common.base.Preconditions.checkNotNull; + +/** + * @author Ruben Bermudez + * @version 1.0 + * Use this method to move a sticker in a set created by the bot to a specific position. Returns True on success. + */ +public class SetStickerPositionInSet extends BotApiMethod { + private static final String PATH = "getStickerSet"; + + private static final String STICKER_FIELD = "sticker"; + private static final String POSITION_FIELD = "position"; + + @JsonProperty(STICKER_FIELD) + private String sticker; ///< File identifier of the sticker + @JsonProperty(STICKER_FIELD) + private Integer position; ///< New sticker position in the set, zero-based + + public SetStickerPositionInSet(String sticker, Integer position) { + this.sticker = checkNotNull(sticker); + this.position = checkNotNull(position); + } + + public SetStickerPositionInSet() { + super(); + } + + @Override + public String getMethod() { + return PATH; + } + + @Override + public Boolean deserializeResponse(String answer) throws TelegramApiRequestException { + try { + ApiResponse result = OBJECT_MAPPER.readValue(answer, + new TypeReference>(){}); + if (result.getOk()) { + return result.getResult(); + } else { + throw new TelegramApiRequestException("Error setting sticker position in set", result); + } + } catch (IOException e) { + throw new TelegramApiRequestException("Unable to deserialize response", e); + } + } + + @Override + public void validate() throws TelegramApiValidationException { + if (sticker == null || sticker.isEmpty()) { + throw new TelegramApiValidationException("sticker can't be null", this); + } + if (position == null || position > 0) { + throw new TelegramApiValidationException("position can't be null", this); + } + } + + public String getSticker() { + return sticker; + } + + public SetStickerPositionInSet setSticker(String sticker) { + this.sticker = sticker; + return this; + } + + public Integer getPosition() { + return position; + } + + public SetStickerPositionInSet setPosition(Integer position) { + this.position = position; + return this; + } + + @Override + public String toString() { + return "SetStickerPositionInSet{" + + "sticker='" + sticker + '\'' + + ", position=" + position + + '}'; + } +} diff --git a/telegrambots-meta/src/main/java/org/telegram/telegrambots/api/methods/stickers/UploadStickerFile.java b/telegrambots-meta/src/main/java/org/telegram/telegrambots/api/methods/stickers/UploadStickerFile.java new file mode 100644 index 00000000..a4196a46 --- /dev/null +++ b/telegrambots-meta/src/main/java/org/telegram/telegrambots/api/methods/stickers/UploadStickerFile.java @@ -0,0 +1,114 @@ +package org.telegram.telegrambots.api.methods.stickers; + +import com.fasterxml.jackson.core.type.TypeReference; +import org.telegram.telegrambots.api.methods.PartialBotApiMethod; +import org.telegram.telegrambots.api.objects.File; +import org.telegram.telegrambots.api.objects.replykeyboard.ApiResponse; +import org.telegram.telegrambots.exceptions.TelegramApiRequestException; +import org.telegram.telegrambots.exceptions.TelegramApiValidationException; + +import java.io.IOException; +import java.io.InputStream; + +import static com.google.common.base.Preconditions.checkNotNull; + +/** + * @author Ruben Bermudez + * @version 1.0 + * Use this method to upload a .png file with a sticker for later use in createNewStickerSet and addStickerToSet + * methods (can be used multiple times). Returns the uploaded File on success. + */ +public class UploadStickerFile extends PartialBotApiMethod { + public static final String PATH = "uploadStickerFile"; + + public static final String USERID_FIELD = "name"; + public static final String PNGSTICKER_FIELD = "png_sticker"; + + private Integer userId; ///< User identifier of sticker file owner + /** + * Png image with the sticker, must be up to 512 kilobytes in size, dimensions must not exceed 512px, + * and either width or height must be exactly 512px. More info on Sending Files » + */ + private java.io.File newPngStickerFile; ///< New sticker file + private InputStream newPngStickerStream; ///< New sticker stream + private String newPngStickerName; ///< New sticker stream name + + public UploadStickerFile() { + super(); + } + + public UploadStickerFile(Integer userId) { + super(); + this.userId = checkNotNull(userId); + } + + @Override + public File deserializeResponse(String answer) throws TelegramApiRequestException { + try { + ApiResponse result = OBJECT_MAPPER.readValue(answer, + new TypeReference>(){}); + if (result.getOk()) { + return result.getResult(); + } else { + throw new TelegramApiRequestException("Error uploading sticker set", result); + } + } catch (IOException e) { + throw new TelegramApiRequestException("Unable to deserialize response", e); + } + } + + @Override + public void validate() throws TelegramApiValidationException { + if (userId == null || userId <= 0) { + throw new TelegramApiValidationException("userId can't be empty", this); + } + if (newPngStickerFile == null && newPngStickerStream == null) { + throw new TelegramApiValidationException("file or stream must be present", this); + } + if (newPngStickerStream != null && (newPngStickerName == null || newPngStickerName.isEmpty())) { + throw new TelegramApiValidationException("Stream name must be present", this); + } + } + + public Integer getUserId() { + return userId; + } + + public UploadStickerFile setUserId(Integer userId) { + this.userId = userId; + return this; + } + + public java.io.File getNewPngStickerFile() { + return newPngStickerFile; + } + + public UploadStickerFile setNewPngSticker(java.io.File newPngStickerFile) { + this.newPngStickerFile = newPngStickerFile; + return this; + } + + public InputStream getNewPngStickerStream() { + return newPngStickerStream; + } + + public UploadStickerFile setNewPngSticker(String newPngStickerName, InputStream newPngStickerStream) { + this.newPngStickerName = newPngStickerName; + this.newPngStickerStream = newPngStickerStream; + return this; + } + + public String getNewPngStickerName() { + return newPngStickerName; + } + + @Override + public String toString() { + return "UploadStickerFile{" + + "userId=" + userId + + ", newPngStickerFile=" + newPngStickerFile + + ", newPngStickerStream=" + newPngStickerStream + + ", newPngStickerName='" + newPngStickerName + '\'' + + '}'; + } +} diff --git a/telegrambots-meta/src/main/java/org/telegram/telegrambots/api/objects/Message.java b/telegrambots-meta/src/main/java/org/telegram/telegrambots/api/objects/Message.java index 17bdcd75..05ec6374 100644 --- a/telegrambots-meta/src/main/java/org/telegram/telegrambots/api/objects/Message.java +++ b/telegrambots-meta/src/main/java/org/telegram/telegrambots/api/objects/Message.java @@ -5,6 +5,7 @@ import org.telegram.telegrambots.api.interfaces.BotApiObject; import org.telegram.telegrambots.api.objects.games.Game; import org.telegram.telegrambots.api.objects.payments.Invoice; import org.telegram.telegrambots.api.objects.payments.SuccessfulPayment; +import org.telegram.telegrambots.api.objects.stickers.Sticker; import java.util.List; diff --git a/telegrambots-meta/src/main/java/org/telegram/telegrambots/api/objects/stickers/MaskPosition.java b/telegrambots-meta/src/main/java/org/telegram/telegrambots/api/objects/stickers/MaskPosition.java new file mode 100644 index 00000000..599ea24e --- /dev/null +++ b/telegrambots-meta/src/main/java/org/telegram/telegrambots/api/objects/stickers/MaskPosition.java @@ -0,0 +1,89 @@ +package org.telegram.telegrambots.api.objects.stickers; + +import com.fasterxml.jackson.annotation.JsonProperty; +import org.telegram.telegrambots.api.interfaces.InputBotApiObject; +import org.telegram.telegrambots.api.interfaces.Validable; +import org.telegram.telegrambots.exceptions.TelegramApiValidationException; + +/** + * @author Ruben Bermudez + * @version 3.2 + * This object describes the position on faces where a mask should be placed by default. + */ +public class MaskPosition implements InputBotApiObject, Validable { + private static final String POINT_FIELD = "point"; + private static final String XSHIFT_FIELD = "x_shift"; + private static final String YSHIFT_FIELD = "y_shift"; + private static final String SCALE_FIELD = "scale"; + + @JsonProperty(POINT_FIELD) + private String point; ///< The part of the face relative to which the mask should be placed. One of “forehead”, “eyes”, “mouth”, or “chin”. + @JsonProperty(XSHIFT_FIELD) + private Float xShift; ///< Shift by X-axis measured in widths of the mask scaled to the face size, from left to right. For example, choosing -1.0 will place mask just to the left of the default mask position. + @JsonProperty(YSHIFT_FIELD) + private Float yShift; ///< Shift by Y-axis measured in heights of the mask scaled to the face size, from top to bottom. For example, 1.0 will place the mask just below the default mask position. + @JsonProperty(SCALE_FIELD) + private Float scale; ///< Mask scaling coefficient. For example, 2.0 means double size. + + public MaskPosition() { + super(); + } + + public String getPoint() { + return point; + } + + public Float getxShift() { + return xShift; + } + + public Float getyShift() { + return yShift; + } + + public Float getScale() { + return scale; + } + + public void setPoint(String point) { + this.point = point; + } + + public void setxShift(Float xShift) { + this.xShift = xShift; + } + + public void setyShift(Float yShift) { + this.yShift = yShift; + } + + public void setScale(Float scale) { + this.scale = scale; + } + + @Override + public String toString() { + return "MaskPosition{" + + "point='" + point + '\'' + + ", xShift=" + xShift + + ", yShift=" + yShift + + ", scale=" + scale + + '}'; + } + + @Override + public void validate() throws TelegramApiValidationException { + if (point == null || point.isEmpty()) { + throw new TelegramApiValidationException("point can't be empty", this); + } + if (xShift == null) { + throw new TelegramApiValidationException("xShift can't be empty", this); + } + if (yShift == null) { + throw new TelegramApiValidationException("yShift can't be empty", this); + } + if (scale == null) { + throw new TelegramApiValidationException("scale can't be empty", this); + } + } +} diff --git a/telegrambots-meta/src/main/java/org/telegram/telegrambots/api/objects/Sticker.java b/telegrambots-meta/src/main/java/org/telegram/telegrambots/api/objects/stickers/Sticker.java similarity index 70% rename from telegrambots-meta/src/main/java/org/telegram/telegrambots/api/objects/Sticker.java rename to telegrambots-meta/src/main/java/org/telegram/telegrambots/api/objects/stickers/Sticker.java index 1984dd90..a5b08951 100644 --- a/telegrambots-meta/src/main/java/org/telegram/telegrambots/api/objects/Sticker.java +++ b/telegrambots-meta/src/main/java/org/telegram/telegrambots/api/objects/stickers/Sticker.java @@ -1,14 +1,14 @@ -package org.telegram.telegrambots.api.objects; +package org.telegram.telegrambots.api.objects.stickers; import com.fasterxml.jackson.annotation.JsonProperty; import org.telegram.telegrambots.api.interfaces.BotApiObject; +import org.telegram.telegrambots.api.objects.PhotoSize; /** * @author Ruben Bermudez * @version 1.0 * @brief This object represents a sticker. - * @date 20 of June of 2015 */ public class Sticker implements BotApiObject { @@ -18,6 +18,8 @@ public class Sticker implements BotApiObject { private static final String THUMB_FIELD = "thumb"; private static final String FILESIZE_FIELD = "file_size"; private static final String EMOJI_FIELD = "emoji"; + private static final String SETNAME_FIELD = "set_name"; + private static final String MASKPOSITON_FIELD = "mask_position"; @JsonProperty(FILEID_FIELD) private String fileId; ///< Unique identifier for this file @@ -31,6 +33,10 @@ public class Sticker implements BotApiObject { private Integer fileSize; ///< Optional. File size @JsonProperty(EMOJI_FIELD) private String emoji; ///< Optional. Emoji associated with the sticker + @JsonProperty(SETNAME_FIELD) + private String setName; ///< Optional. Name of the sticker set to which the sticker belongs + @JsonProperty(MASKPOSITON_FIELD) + private String maskPosition; ///< Optional. For mask stickers, the position where the mask should be placed public Sticker() { super(); @@ -60,6 +66,14 @@ public class Sticker implements BotApiObject { return emoji; } + public String getSetName() { + return setName; + } + + public String getMaskPosition() { + return maskPosition; + } + @Override public String toString() { return "Sticker{" + @@ -68,7 +82,9 @@ public class Sticker implements BotApiObject { ", height=" + height + ", thumb=" + thumb + ", fileSize=" + fileSize + - ", emoji=" + emoji + + ", emoji='" + emoji + '\'' + + ", setName='" + setName + '\'' + + ", maskPosition='" + maskPosition + '\'' + '}'; } } diff --git a/telegrambots-meta/src/main/java/org/telegram/telegrambots/api/objects/stickers/StickerSet.java b/telegrambots-meta/src/main/java/org/telegram/telegrambots/api/objects/stickers/StickerSet.java new file mode 100644 index 00000000..20fb1e20 --- /dev/null +++ b/telegrambots-meta/src/main/java/org/telegram/telegrambots/api/objects/stickers/StickerSet.java @@ -0,0 +1,57 @@ +package org.telegram.telegrambots.api.objects.stickers; + +import com.fasterxml.jackson.annotation.JsonProperty; +import org.telegram.telegrambots.api.interfaces.BotApiObject; + +import java.util.List; + +/** + * @author Ruben Bermudez + * @version 1.0 + * This object represents a sticker set. + */ +public class StickerSet implements BotApiObject { + private static final String NAME_FIELD = "name"; + private static final String TITLE_FIELD = "title"; + private static final String CONTAINSMASKS_FIELD = "contains_masks"; + private static final String STICKERS_FIELD = "stickers"; + + @JsonProperty(NAME_FIELD) + private String name; + @JsonProperty(TITLE_FIELD) + private String title; + @JsonProperty(CONTAINSMASKS_FIELD) + private Boolean containsMasks; + @JsonProperty(STICKERS_FIELD) + private List stickers; + + public StickerSet() { + super(); + } + + public String getName() { + return name; + } + + public String getTitle() { + return title; + } + + public Boolean getContainsMasks() { + return containsMasks; + } + + public List getStickers() { + return stickers; + } + + @Override + public String toString() { + return "StickerSet{" + + "name='" + name + '\'' + + ", title='" + title + '\'' + + ", containsMasks=" + containsMasks + + ", stickers=" + stickers + + '}'; + } +} diff --git a/telegrambots-meta/src/main/java/org/telegram/telegrambots/bots/AbsSender.java b/telegrambots-meta/src/main/java/org/telegram/telegrambots/bots/AbsSender.java index 09a0995f..e44babd1 100644 --- a/telegrambots-meta/src/main/java/org/telegram/telegrambots/bots/AbsSender.java +++ b/telegrambots-meta/src/main/java/org/telegram/telegrambots/bots/AbsSender.java @@ -7,6 +7,9 @@ import org.telegram.telegrambots.api.methods.groupadministration.*; import org.telegram.telegrambots.api.methods.pinnedmessages.PinChatMessage; import org.telegram.telegrambots.api.methods.pinnedmessages.UnpinChatMessage; import org.telegram.telegrambots.api.methods.send.*; +import org.telegram.telegrambots.api.methods.stickers.AddStickerToSet; +import org.telegram.telegrambots.api.methods.stickers.CreateNewStickerSet; +import org.telegram.telegrambots.api.methods.stickers.UploadStickerFile; import org.telegram.telegrambots.api.methods.updates.DeleteWebhook; import org.telegram.telegrambots.api.methods.updates.GetWebhookInfo; import org.telegram.telegrambots.api.methods.updatingmessages.DeleteMessage; @@ -52,6 +55,7 @@ public abstract class AbsSender { // Send Requests + @Deprecated public final Message sendMessage(SendMessage sendMessage) throws TelegramApiException { if (sendMessage == null) { throw new TelegramApiException("Parameter sendMessage can not be null"); @@ -60,6 +64,7 @@ public abstract class AbsSender { return sendApiMethod(sendMessage); } + @Deprecated public final Boolean answerInlineQuery(AnswerInlineQuery answerInlineQuery) throws TelegramApiException { if (answerInlineQuery == null) { throw new TelegramApiException("Parameter answerInlineQuery can not be null"); @@ -68,6 +73,7 @@ public abstract class AbsSender { return sendApiMethod(answerInlineQuery); } + @Deprecated public final Boolean sendChatAction(SendChatAction sendChatAction) throws TelegramApiException { if (sendChatAction == null) { throw new TelegramApiException("Parameter sendChatAction can not be null"); @@ -76,6 +82,7 @@ public abstract class AbsSender { return sendApiMethod(sendChatAction); } + @Deprecated public final Message forwardMessage(ForwardMessage forwardMessage) throws TelegramApiException { if (forwardMessage == null) { throw new TelegramApiException("Parameter forwardMessage can not be null"); @@ -84,6 +91,7 @@ public abstract class AbsSender { return sendApiMethod(forwardMessage); } + @Deprecated public final Message sendLocation(SendLocation sendLocation) throws TelegramApiException { if (sendLocation == null) { throw new TelegramApiException("Parameter sendLocation can not be null"); @@ -92,6 +100,7 @@ public abstract class AbsSender { return sendApiMethod(sendLocation); } + @Deprecated public final Message sendVenue(SendVenue sendVenue) throws TelegramApiException { if (sendVenue == null) { throw new TelegramApiException("Parameter sendVenue can not be null"); @@ -100,6 +109,7 @@ public abstract class AbsSender { return sendApiMethod(sendVenue); } + @Deprecated public final Message sendContact(SendContact sendContact) throws TelegramApiException { if (sendContact == null) { throw new TelegramApiException("Parameter sendContact can not be null"); @@ -108,6 +118,7 @@ public abstract class AbsSender { return sendApiMethod(sendContact); } + @Deprecated public final Boolean kickMember(KickChatMember kickChatMember) throws TelegramApiException { if (kickChatMember == null) { throw new TelegramApiException("Parameter kickChatMember can not be null"); @@ -115,6 +126,7 @@ public abstract class AbsSender { return sendApiMethod(kickChatMember); } + @Deprecated public final Boolean unbanMember(UnbanChatMember unbanChatMember) throws TelegramApiException { if (unbanChatMember == null) { throw new TelegramApiException("Parameter unbanChatMember can not be null"); @@ -122,6 +134,7 @@ public abstract class AbsSender { return sendApiMethod(unbanChatMember); } + @Deprecated public final Boolean leaveChat(LeaveChat leaveChat) throws TelegramApiException { if (leaveChat == null) { throw new TelegramApiException("Parameter leaveChat can not be null"); @@ -129,6 +142,7 @@ public abstract class AbsSender { return sendApiMethod(leaveChat); } + @Deprecated public final Chat getChat(GetChat getChat) throws TelegramApiException { if (getChat == null) { throw new TelegramApiException("Parameter getChat can not be null"); @@ -136,6 +150,7 @@ public abstract class AbsSender { return sendApiMethod(getChat); } + @Deprecated public final String exportChatInviteLink(ExportChatInviteLink exportChatInviteLink) throws TelegramApiException { if (exportChatInviteLink == null) { throw new TelegramApiException("Parameter exportChatInviteLink can not be null"); @@ -143,6 +158,7 @@ public abstract class AbsSender { return sendApiMethod(exportChatInviteLink); } + @Deprecated public final List getChatAdministrators(GetChatAdministrators getChatAdministrators) throws TelegramApiException { if (getChatAdministrators == null) { throw new TelegramApiException("Parameter getChatAdministrators can not be null"); @@ -150,6 +166,7 @@ public abstract class AbsSender { return sendApiMethod(getChatAdministrators); } + @Deprecated public final ChatMember getChatMember(GetChatMember getChatMember) throws TelegramApiException { if (getChatMember == null) { throw new TelegramApiException("Parameter getChatMember can not be null"); @@ -157,6 +174,7 @@ public abstract class AbsSender { return sendApiMethod(getChatMember); } + @Deprecated public final Integer getChatMemberCount(GetChatMemberCount getChatMemberCount) throws TelegramApiException { if (getChatMemberCount == null) { throw new TelegramApiException("Parameter getChatMemberCount can not be null"); @@ -164,6 +182,7 @@ public abstract class AbsSender { return sendApiMethod(getChatMemberCount); } + @Deprecated public final Serializable editMessageText(EditMessageText editMessageText) throws TelegramApiException { if (editMessageText == null) { throw new TelegramApiException("Parameter editMessageText can not be null"); @@ -171,6 +190,7 @@ public abstract class AbsSender { return sendApiMethod(editMessageText); } + @Deprecated public final Serializable editMessageCaption(EditMessageCaption editMessageCaption) throws TelegramApiException { if (editMessageCaption == null) { throw new TelegramApiException("Parameter editMessageCaption can not be null"); @@ -178,6 +198,7 @@ public abstract class AbsSender { return sendApiMethod(editMessageCaption); } + @Deprecated public final Serializable editMessageReplyMarkup(EditMessageReplyMarkup editMessageReplyMarkup) throws TelegramApiException { if (editMessageReplyMarkup == null) { throw new TelegramApiException("Parameter editMessageReplyMarkup can not be null"); @@ -185,6 +206,7 @@ public abstract class AbsSender { return sendApiMethod(editMessageReplyMarkup); } + @Deprecated public final Boolean answerCallbackQuery(AnswerCallbackQuery answerCallbackQuery) throws TelegramApiException { if (answerCallbackQuery == null) { throw new TelegramApiException("Parameter answerCallbackQuery can not be null"); @@ -192,6 +214,7 @@ public abstract class AbsSender { return sendApiMethod(answerCallbackQuery); } + @Deprecated public final UserProfilePhotos getUserProfilePhotos(GetUserProfilePhotos getUserProfilePhotos) throws TelegramApiException { if (getUserProfilePhotos == null) { throw new TelegramApiException("Parameter getUserProfilePhotos can not be null"); @@ -200,6 +223,7 @@ public abstract class AbsSender { return sendApiMethod(getUserProfilePhotos); } + @Deprecated public final File getFile(GetFile getFile) throws TelegramApiException { if(getFile == null){ throw new TelegramApiException("Parameter getFile can not be null"); @@ -211,9 +235,7 @@ public abstract class AbsSender { } public final User getMe() throws TelegramApiException { - GetMe getMe = new GetMe(); - - return sendApiMethod(getMe); + return sendApiMethod(new GetMe()); } public final WebhookInfo getWebhookInfo() throws TelegramApiException { @@ -221,6 +243,7 @@ public abstract class AbsSender { return sendApiMethod(getWebhookInfo); } + @Deprecated public final Serializable setGameScore(SetGameScore setGameScore) throws TelegramApiException { if(setGameScore == null){ throw new TelegramApiException("Parameter setGameScore can not be null"); @@ -228,6 +251,7 @@ public abstract class AbsSender { return sendApiMethod(setGameScore); } + @Deprecated public final Serializable getGameHighScores(GetGameHighScores getGameHighScores) throws TelegramApiException { if(getGameHighScores == null){ throw new TelegramApiException("Parameter getGameHighScores can not be null"); @@ -235,6 +259,7 @@ public abstract class AbsSender { return sendApiMethod(getGameHighScores); } + @Deprecated public final Message sendGame(SendGame sendGame) throws TelegramApiException { if(sendGame == null){ throw new TelegramApiException("Parameter sendGame can not be null"); @@ -242,6 +267,7 @@ public abstract class AbsSender { return sendApiMethod(sendGame); } + @Deprecated public final Boolean deleteWebhook(DeleteWebhook deleteWebhook) throws TelegramApiException { if(deleteWebhook == null){ throw new TelegramApiException("Parameter deleteWebhook can not be null"); @@ -249,6 +275,7 @@ public abstract class AbsSender { return sendApiMethod(deleteWebhook); } + @Deprecated public final Message sendInvoice(SendInvoice sendInvoice) throws TelegramApiException { if(sendInvoice == null){ throw new TelegramApiException("Parameter sendInvoice can not be null"); @@ -256,6 +283,7 @@ public abstract class AbsSender { return sendApiMethod(sendInvoice); } + @Deprecated public final Boolean answerShippingQuery(AnswerShippingQuery answerShippingQuery) throws TelegramApiException { if(answerShippingQuery == null){ throw new TelegramApiException("Parameter answerShippingQuery can not be null"); @@ -263,6 +291,7 @@ public abstract class AbsSender { return sendApiMethod(answerShippingQuery); } + @Deprecated public final Boolean answerPreCheckoutQuery(AnswerPreCheckoutQuery answerPreCheckoutQuery) throws TelegramApiException { if(answerPreCheckoutQuery == null){ throw new TelegramApiException("Parameter answerPreCheckoutQuery can not be null"); @@ -270,6 +299,7 @@ public abstract class AbsSender { return sendApiMethod(answerPreCheckoutQuery); } + @Deprecated public final Boolean deleteMessage(DeleteMessage deleteMessage) throws TelegramApiException { if(deleteMessage == null){ throw new TelegramApiException("Parameter deleteMessage can not be null"); @@ -277,6 +307,7 @@ public abstract class AbsSender { return sendApiMethod(deleteMessage); } + @Deprecated public final Boolean deleteChatPhoto(DeleteChatPhoto deleteChatPhoto) throws TelegramApiException { if(deleteChatPhoto == null){ throw new TelegramApiException("Parameter deleteChatPhoto can not be null"); @@ -284,6 +315,7 @@ public abstract class AbsSender { return sendApiMethod(deleteChatPhoto); } + @Deprecated public final Boolean pinChatMessage(PinChatMessage pinChatMessage) throws TelegramApiException { if(pinChatMessage == null){ throw new TelegramApiException("Parameter pinChatMessage can not be null"); @@ -291,6 +323,7 @@ public abstract class AbsSender { return sendApiMethod(pinChatMessage); } + @Deprecated public final Boolean unpinChatMessage(UnpinChatMessage unpinChatMessage) throws TelegramApiException { if(unpinChatMessage == null){ throw new TelegramApiException("Parameter unpinChatMessage can not be null"); @@ -298,6 +331,7 @@ public abstract class AbsSender { return sendApiMethod(unpinChatMessage); } + @Deprecated public final Boolean promoteChatMember(PromoteChatMember promoteChatMember) throws TelegramApiException { if(promoteChatMember == null){ throw new TelegramApiException("Parameter promoteChatMember can not be null"); @@ -305,6 +339,7 @@ public abstract class AbsSender { return sendApiMethod(promoteChatMember); } + @Deprecated public final Boolean restrictChatMember(RestrictChatMember restrictChatMember) throws TelegramApiException { if(restrictChatMember == null){ throw new TelegramApiException("Parameter restrictChatMember can not be null"); @@ -312,6 +347,7 @@ public abstract class AbsSender { return sendApiMethod(restrictChatMember); } + @Deprecated public final Boolean setChatDescription(SetChatDescription setChatDescription) throws TelegramApiException { if(setChatDescription == null){ throw new TelegramApiException("Parameter setChatDescription can not be null"); @@ -319,6 +355,7 @@ public abstract class AbsSender { return sendApiMethod(setChatDescription); } + @Deprecated public final Boolean setChatTitle(SetChatTitle setChatTitle) throws TelegramApiException { if(setChatTitle == null){ throw new TelegramApiException("Parameter setChatTitle can not be null"); @@ -328,6 +365,7 @@ public abstract class AbsSender { // Send Requests Async + @Deprecated public final void sendMessageAsync(SendMessage sendMessage, SentCallback sentCallback) throws TelegramApiException { if (sendMessage == null) { throw new TelegramApiException("Parameter sendMessage can not be null"); @@ -340,6 +378,7 @@ public abstract class AbsSender { sendApiMethodAsync(sendMessage, sentCallback); } + @Deprecated public final void answerInlineQueryAsync(AnswerInlineQuery answerInlineQuery, SentCallback sentCallback) throws TelegramApiException { if (answerInlineQuery == null) { throw new TelegramApiException("Parameter answerInlineQuery can not be null"); @@ -352,6 +391,7 @@ public abstract class AbsSender { sendApiMethodAsync(answerInlineQuery, sentCallback); } + @Deprecated public final void sendChatActionAsync(SendChatAction sendChatAction, SentCallback sentCallback) throws TelegramApiException { if (sendChatAction == null) { throw new TelegramApiException("Parameter sendChatAction can not be null"); @@ -364,6 +404,7 @@ public abstract class AbsSender { sendApiMethodAsync(sendChatAction, sentCallback); } + @Deprecated public final void forwardMessageAsync(ForwardMessage forwardMessage, SentCallback sentCallback) throws TelegramApiException { if (forwardMessage == null) { throw new TelegramApiException("Parameter forwardMessage can not be null"); @@ -376,6 +417,7 @@ public abstract class AbsSender { sendApiMethodAsync(forwardMessage, sentCallback); } + @Deprecated public final void sendLocationAsync(SendLocation sendLocation, SentCallback sentCallback) throws TelegramApiException { if (sendLocation == null) { throw new TelegramApiException("Parameter sendLocation can not be null"); @@ -388,6 +430,7 @@ public abstract class AbsSender { sendApiMethodAsync(sendLocation, sentCallback); } + @Deprecated public final void sendVenueAsync(SendVenue sendVenue, SentCallback sentCallback) throws TelegramApiException { if (sendVenue == null) { throw new TelegramApiException("Parameter sendVenue can not be null"); @@ -400,6 +443,7 @@ public abstract class AbsSender { sendApiMethodAsync(sendVenue, sentCallback); } + @Deprecated public final void sendContactAsync(SendContact sendContact, SentCallback sentCallback) throws TelegramApiException { if (sendContact == null) { throw new TelegramApiException("Parameter sendContact can not be null"); @@ -411,6 +455,7 @@ public abstract class AbsSender { sendApiMethodAsync(sendContact, sentCallback); } + @Deprecated public final void kickMemberAsync(KickChatMember kickChatMember, SentCallback sentCallback) throws TelegramApiException { if (kickChatMember == null) { throw new TelegramApiException("Parameter kickChatMember can not be null"); @@ -422,6 +467,7 @@ public abstract class AbsSender { sendApiMethodAsync(kickChatMember, sentCallback); } + @Deprecated public final void unbanMemberAsync(UnbanChatMember unbanChatMember, SentCallback sentCallback) throws TelegramApiException { if (unbanChatMember == null) { throw new TelegramApiException("Parameter unbanChatMember can not be null"); @@ -433,6 +479,7 @@ public abstract class AbsSender { sendApiMethodAsync(unbanChatMember, sentCallback); } + @Deprecated public final void leaveChatAsync(LeaveChat leaveChat, SentCallback sentCallback) throws TelegramApiException { if (leaveChat == null) { throw new TelegramApiException("Parameter leaveChat can not be null"); @@ -443,6 +490,7 @@ public abstract class AbsSender { sendApiMethodAsync(leaveChat, sentCallback); } + @Deprecated public final void getChatAsync(GetChat getChat, SentCallback sentCallback) throws TelegramApiException { if (getChat == null) { throw new TelegramApiException("Parameter getChat can not be null"); @@ -453,6 +501,7 @@ public abstract class AbsSender { sendApiMethodAsync(getChat, sentCallback); } + @Deprecated public final void exportChatInviteLinkAsync(ExportChatInviteLink exportChatInviteLink, SentCallback sentCallback) throws TelegramApiException { if (exportChatInviteLink == null) { throw new TelegramApiException("Parameter exportChatInviteLink can not be null"); @@ -463,6 +512,7 @@ public abstract class AbsSender { sendApiMethodAsync(exportChatInviteLink, sentCallback); } + @Deprecated public final void getChatAdministratorsAsync(GetChatAdministrators getChatAdministrators, SentCallback> sentCallback) throws TelegramApiException { if (getChatAdministrators == null) { throw new TelegramApiException("Parameter getChatAdministrators can not be null"); @@ -473,6 +523,7 @@ public abstract class AbsSender { sendApiMethodAsync(getChatAdministrators, sentCallback); } + @Deprecated public final void getChatMemberAsync(GetChatMember getChatMember, SentCallback sentCallback) throws TelegramApiException { if (getChatMember == null) { throw new TelegramApiException("Parameter getChatMember can not be null"); @@ -483,6 +534,7 @@ public abstract class AbsSender { sendApiMethodAsync(getChatMember, sentCallback); } + @Deprecated public final void getChatMemberCountAsync(GetChatMemberCount getChatMemberCount, SentCallback sentCallback) throws TelegramApiException { if (getChatMemberCount == null) { throw new TelegramApiException("Parameter getChatMemberCount can not be null"); @@ -494,6 +546,7 @@ public abstract class AbsSender { sendApiMethodAsync(getChatMemberCount, sentCallback); } + @Deprecated public final void editMessageTextAsync(EditMessageText editMessageText, SentCallback sentCallback) throws TelegramApiException { if (editMessageText == null) { throw new TelegramApiException("Parameter editMessageText can not be null"); @@ -505,6 +558,7 @@ public abstract class AbsSender { sendApiMethodAsync(editMessageText, sentCallback); } + @Deprecated public final void editMessageCaptionAsync(EditMessageCaption editMessageCaption, SentCallback sentCallback) throws TelegramApiException { if (editMessageCaption == null) { throw new TelegramApiException("Parameter editMessageCaption can not be null"); @@ -516,6 +570,7 @@ public abstract class AbsSender { sendApiMethodAsync(editMessageCaption, sentCallback); } + @Deprecated public final void editMessageReplyMarkup(EditMessageReplyMarkup editMessageReplyMarkup, SentCallback sentCallback) throws TelegramApiException { if (editMessageReplyMarkup == null) { throw new TelegramApiException("Parameter editMessageReplyMarkup can not be null"); @@ -527,6 +582,7 @@ public abstract class AbsSender { sendApiMethodAsync(editMessageReplyMarkup, sentCallback); } + @Deprecated public final void answerCallbackQueryAsync(AnswerCallbackQuery answerCallbackQuery, SentCallback sentCallback) throws TelegramApiException { if (answerCallbackQuery == null) { throw new TelegramApiException("Parameter answerCallbackQuery can not be null"); @@ -538,6 +594,7 @@ public abstract class AbsSender { sendApiMethodAsync(answerCallbackQuery, sentCallback); } + @Deprecated public final void getUserProfilePhotosAsync(GetUserProfilePhotos getUserProfilePhotos, SentCallback sentCallback) throws TelegramApiException { if (getUserProfilePhotos == null) { throw new TelegramApiException("Parameter getUserProfilePhotos can not be null"); @@ -549,6 +606,7 @@ public abstract class AbsSender { sendApiMethodAsync(getUserProfilePhotos, sentCallback); } + @Deprecated public final void getFileAsync(GetFile getFile, SentCallback sentCallback) throws TelegramApiException { if (getFile == null) { throw new TelegramApiException("Parameter getFile can not be null"); @@ -564,19 +622,17 @@ public abstract class AbsSender { if (sentCallback == null) { throw new TelegramApiException("Parameter sentCallback can not be null"); } - GetMe getMe = new GetMe(); - sendApiMethodAsync(getMe, sentCallback); + sendApiMethodAsync(new GetMe(), sentCallback); } public final void getWebhookInfoAsync(SentCallback sentCallback) throws TelegramApiException { if (sentCallback == null) { throw new TelegramApiException("Parameter sentCallback can not be null"); } - - GetWebhookInfo getWebhookInfo = new GetWebhookInfo(); - sendApiMethodAsync(getWebhookInfo, sentCallback); + sendApiMethodAsync(new GetWebhookInfo(), sentCallback); } + @Deprecated public final void setGameScoreAsync(SetGameScore setGameScore, SentCallback sentCallback) throws TelegramApiException { if (setGameScore == null) { throw new TelegramApiException("Parameter setGameScore can not be null"); @@ -587,6 +643,7 @@ public abstract class AbsSender { sendApiMethodAsync(setGameScore, sentCallback); } + @Deprecated public final void getGameHighScoresAsync(GetGameHighScores getGameHighScores, SentCallback> sentCallback) throws TelegramApiException { if (getGameHighScores == null) { throw new TelegramApiException("Parameter getGameHighScores can not be null"); @@ -597,6 +654,7 @@ public abstract class AbsSender { sendApiMethodAsync(getGameHighScores, sentCallback); } + @Deprecated public final void sendGameAsync(SendGame sendGame, SentCallback sentCallback) throws TelegramApiException { if (sendGame == null) { throw new TelegramApiException("Parameter sendGame can not be null"); @@ -607,6 +665,7 @@ public abstract class AbsSender { sendApiMethodAsync(sendGame, sentCallback); } + @Deprecated public final void deleteWebhook(DeleteWebhook deleteWebhook, SentCallback sentCallback) throws TelegramApiException { if (deleteWebhook == null) { throw new TelegramApiException("Parameter deleteWebhook can not be null"); @@ -617,6 +676,7 @@ public abstract class AbsSender { sendApiMethodAsync(deleteWebhook, sentCallback); } + @Deprecated public final void sendInvoice(SendInvoice sendInvoice, SentCallback sentCallback) throws TelegramApiException { if (sendInvoice == null) { throw new TelegramApiException("Parameter sendInvoice can not be null"); @@ -627,6 +687,7 @@ public abstract class AbsSender { sendApiMethodAsync(sendInvoice, sentCallback); } + @Deprecated public final void answerShippingQuery(AnswerShippingQuery answerShippingQuery, SentCallback sentCallback) throws TelegramApiException { if (answerShippingQuery == null) { throw new TelegramApiException("Parameter answerShippingQuery can not be null"); @@ -637,6 +698,7 @@ public abstract class AbsSender { sendApiMethodAsync(answerShippingQuery, sentCallback); } + @Deprecated public final void answerPreCheckoutQuery(AnswerPreCheckoutQuery answerPreCheckoutQuery, SentCallback sentCallback) throws TelegramApiException { if (answerPreCheckoutQuery == null) { throw new TelegramApiException("Parameter answerPreCheckoutQuery can not be null"); @@ -647,6 +709,7 @@ public abstract class AbsSender { sendApiMethodAsync(answerPreCheckoutQuery, sentCallback); } + @Deprecated public final void deleteMessage(DeleteMessage deleteMessage, SentCallback sentCallback) throws TelegramApiException { if (deleteMessage == null) { throw new TelegramApiException("Parameter deleteMessage can not be null"); @@ -657,6 +720,7 @@ public abstract class AbsSender { sendApiMethodAsync(deleteMessage, sentCallback); } + @Deprecated public final void deleteChatPhoto(DeleteChatPhoto deleteChatPhoto, SentCallback sentCallback) throws TelegramApiException { if (deleteChatPhoto == null) { throw new TelegramApiException("Parameter deleteChatPhoto can not be null"); @@ -667,6 +731,7 @@ public abstract class AbsSender { sendApiMethodAsync(deleteChatPhoto, sentCallback); } + @Deprecated public final void pinChatMessage(PinChatMessage pinChatMessage, SentCallback sentCallback) throws TelegramApiException { if (pinChatMessage == null) { throw new TelegramApiException("Parameter pinChatMessage can not be null"); @@ -677,6 +742,7 @@ public abstract class AbsSender { sendApiMethodAsync(pinChatMessage, sentCallback); } + @Deprecated public final void unpinChatMessage(UnpinChatMessage unpinChatMessage, SentCallback sentCallback) throws TelegramApiException { if (unpinChatMessage == null) { throw new TelegramApiException("Parameter unpinChatMessage can not be null"); @@ -687,6 +753,7 @@ public abstract class AbsSender { sendApiMethodAsync(unpinChatMessage, sentCallback); } + @Deprecated public final void promoteChatMember(PromoteChatMember promoteChatMember, SentCallback sentCallback) throws TelegramApiException { if (promoteChatMember == null) { throw new TelegramApiException("Parameter promoteChatMember can not be null"); @@ -697,6 +764,7 @@ public abstract class AbsSender { sendApiMethodAsync(promoteChatMember, sentCallback); } + @Deprecated public final void restrictChatMember(RestrictChatMember restrictChatMember, SentCallback sentCallback) throws TelegramApiException { if (restrictChatMember == null) { throw new TelegramApiException("Parameter restrictChatMember can not be null"); @@ -707,6 +775,7 @@ public abstract class AbsSender { sendApiMethodAsync(restrictChatMember, sentCallback); } + @Deprecated public final void setChatDescription(SetChatDescription setChatDescription, SentCallback sentCallback) throws TelegramApiException { if (setChatDescription == null) { throw new TelegramApiException("Parameter setChatDescription can not be null"); @@ -717,6 +786,7 @@ public abstract class AbsSender { sendApiMethodAsync(setChatDescription, sentCallback); } + @Deprecated public final void setChatTitle(SetChatTitle setChatTitle, SentCallback sentCallback) throws TelegramApiException { if (setChatTitle == null) { throw new TelegramApiException("Parameter setChatTitle can not be null"); @@ -763,6 +833,30 @@ public abstract class AbsSender { */ public abstract Boolean setChatPhoto(SetChatPhoto setChatPhoto) throws TelegramApiException; + /** + * Adds a new sticker to a set (https://core.telegram.org/bots/api#addStickerToSet) + * @param addStickerToSet Information of the sticker to set + * @return If success, true is returned + * @throws TelegramApiException If there is any error adding the sticker to the set + */ + public abstract Boolean addStickerToSet(AddStickerToSet addStickerToSet) throws TelegramApiException; + + /** + * Creates a new sticker set (https://core.telegram.org/bots/api#createNewStickerSet) + * @param createNewStickerSet Information of the sticker set to create + * @return If success, true is returned + * @throws TelegramApiException If there is any error creating the new sticker set + */ + public abstract Boolean createNewStickerSet(CreateNewStickerSet createNewStickerSet) throws TelegramApiException; + + /** + * Upload a new file as sticker (https://core.telegram.org/bots/api#uploadStickerFile) + * @param uploadStickerFile Information of the file to upload as sticker + * @return If success, true is returned + * @throws TelegramApiException If there is any error uploading the new file + */ + public abstract File uploadStickerFile(UploadStickerFile uploadStickerFile) throws TelegramApiException; + // Simplified methods protected abstract , Callback extends SentCallback> void sendApiMethodAsync(Method method, Callback callback); diff --git a/telegrambots/pom.xml b/telegrambots/pom.xml index b24cff82..80d06cd4 100644 --- a/telegrambots/pom.xml +++ b/telegrambots/pom.xml @@ -5,7 +5,7 @@ 4.0.0 org.telegram telegrambots - 3.1.2 + 3.2 jar Telegram Bots @@ -66,7 +66,7 @@ 2.8.7 2.8.0 2.5 - 3.1.2 + 3.2 diff --git a/telegrambots/src/main/java/org/telegram/telegrambots/bots/DefaultAbsSender.java b/telegrambots/src/main/java/org/telegram/telegrambots/bots/DefaultAbsSender.java index 2faca1f2..6327b6cf 100644 --- a/telegrambots/src/main/java/org/telegram/telegrambots/bots/DefaultAbsSender.java +++ b/telegrambots/src/main/java/org/telegram/telegrambots/bots/DefaultAbsSender.java @@ -17,6 +17,9 @@ import org.apache.http.util.EntityUtils; import org.telegram.telegrambots.api.methods.BotApiMethod; import org.telegram.telegrambots.api.methods.groupadministration.SetChatPhoto; import org.telegram.telegrambots.api.methods.send.*; +import org.telegram.telegrambots.api.methods.stickers.AddStickerToSet; +import org.telegram.telegrambots.api.methods.stickers.CreateNewStickerSet; +import org.telegram.telegrambots.api.methods.stickers.UploadStickerFile; import org.telegram.telegrambots.api.objects.File; import org.telegram.telegrambots.api.objects.Message; import org.telegram.telegrambots.exceptions.TelegramApiException; @@ -478,6 +481,100 @@ public abstract class DefaultAbsSender extends AbsSender { } } + + @Override + public Boolean addStickerToSet(AddStickerToSet addStickerToSet) throws TelegramApiException { + assertParamNotNull(addStickerToSet, "addStickerToSet"); + addStickerToSet.validate(); + try { + String url = getBaseUrl() + AddStickerToSet.PATH; + HttpPost httppost = configuredHttpPost(url); + MultipartEntityBuilder builder = MultipartEntityBuilder.create(); + builder.addTextBody(AddStickerToSet.USERID_FIELD, addStickerToSet.getUserId().toString(), TEXT_PLAIN_CONTENT_TYPE); + builder.addTextBody(AddStickerToSet.NAME_FIELD, addStickerToSet.getName(), TEXT_PLAIN_CONTENT_TYPE); + builder.addTextBody(AddStickerToSet.EMOJIS_FIELD, addStickerToSet.getEmojis(), TEXT_PLAIN_CONTENT_TYPE); + if (addStickerToSet.isNewPngSticker()) { + if (addStickerToSet.getPngStickerFile() != null) { + builder.addBinaryBody(AddStickerToSet.PNGSTICKER_FIELD, addStickerToSet.getPngStickerFile()); + } else if (addStickerToSet.getPngStickerStream() != null) { + builder.addBinaryBody(AddStickerToSet.PNGSTICKER_FIELD, addStickerToSet.getPngStickerStream(), ContentType.APPLICATION_OCTET_STREAM, addStickerToSet.getPngStickerName()); + } else { + builder.addBinaryBody(AddStickerToSet.PNGSTICKER_FIELD, new java.io.File(addStickerToSet.getPngSticker()), ContentType.create("image/png"), addStickerToSet.getPngStickerName()); + } + } else { + builder.addTextBody(AddStickerToSet.PNGSTICKER_FIELD, addStickerToSet.getPngSticker()); + } + if (addStickerToSet.getMaskPosition() != null) { + builder.addTextBody(AddStickerToSet.MASKPOSITION_FIELD, objectMapper.writeValueAsString(addStickerToSet.getMaskPosition()), TEXT_PLAIN_CONTENT_TYPE); + } + HttpEntity multipart = builder.build(); + httppost.setEntity(multipart); + + return addStickerToSet.deserializeResponse(sendHttpPostRequest(httppost)); + } catch (IOException e) { + throw new TelegramApiException("Unable to add sticker to set", e); + } + } + + @Override + public Boolean createNewStickerSet(CreateNewStickerSet createNewStickerSet) throws TelegramApiException { + assertParamNotNull(createNewStickerSet, "createNewStickerSet"); + createNewStickerSet.validate(); + try { + String url = getBaseUrl() + CreateNewStickerSet.PATH; + HttpPost httppost = configuredHttpPost(url); + MultipartEntityBuilder builder = MultipartEntityBuilder.create(); + builder.addTextBody(CreateNewStickerSet.USERID_FIELD, createNewStickerSet.getUserId().toString(), TEXT_PLAIN_CONTENT_TYPE); + builder.addTextBody(CreateNewStickerSet.NAME_FIELD, createNewStickerSet.getName(), TEXT_PLAIN_CONTENT_TYPE); + builder.addTextBody(CreateNewStickerSet.TITLE_FIELD, createNewStickerSet.getTitle(), TEXT_PLAIN_CONTENT_TYPE); + builder.addTextBody(CreateNewStickerSet.EMOJIS_FIELD, createNewStickerSet.getEmojis(), TEXT_PLAIN_CONTENT_TYPE); + builder.addTextBody(CreateNewStickerSet.CONTAINSMASKS_FIELD, createNewStickerSet.getContainsMasks().toString()); + if (createNewStickerSet.isNewPngSticker()) { + if (createNewStickerSet.getPngStickerFile() != null) { + builder.addBinaryBody(CreateNewStickerSet.PNGSTICKER_FIELD, createNewStickerSet.getPngStickerFile()); + } else if (createNewStickerSet.getPngStickerStream() != null) { + builder.addBinaryBody(CreateNewStickerSet.PNGSTICKER_FIELD, createNewStickerSet.getPngStickerStream(), ContentType.APPLICATION_OCTET_STREAM, createNewStickerSet.getPngStickerName()); + } else { + builder.addBinaryBody(CreateNewStickerSet.PNGSTICKER_FIELD, new java.io.File(createNewStickerSet.getPngSticker()), ContentType.create("image/png"), createNewStickerSet.getPngStickerName()); + } + } else { + builder.addTextBody(CreateNewStickerSet.PNGSTICKER_FIELD, createNewStickerSet.getPngSticker()); + } + if (createNewStickerSet.getMaskPosition() != null) { + builder.addTextBody(CreateNewStickerSet.MASKPOSITION_FIELD, objectMapper.writeValueAsString(createNewStickerSet.getMaskPosition()), TEXT_PLAIN_CONTENT_TYPE); + } + HttpEntity multipart = builder.build(); + httppost.setEntity(multipart); + + return createNewStickerSet.deserializeResponse(sendHttpPostRequest(httppost)); + } catch (IOException e) { + throw new TelegramApiException("Unable to create new sticker set", e); + } + } + + @Override + public File uploadStickerFile(UploadStickerFile uploadStickerFile) throws TelegramApiException { + assertParamNotNull(uploadStickerFile, "uploadStickerFile"); + uploadStickerFile.validate(); + try { + String url = getBaseUrl() + UploadStickerFile.PATH; + HttpPost httppost = configuredHttpPost(url); + MultipartEntityBuilder builder = MultipartEntityBuilder.create(); + builder.addTextBody(UploadStickerFile.USERID_FIELD, uploadStickerFile.getUserId().toString(), TEXT_PLAIN_CONTENT_TYPE); + if (uploadStickerFile.getNewPngStickerFile() != null) { + builder.addBinaryBody(UploadStickerFile.PNGSTICKER_FIELD, uploadStickerFile.getNewPngStickerFile()); + } else if (uploadStickerFile.getNewPngStickerStream() != null) { + builder.addBinaryBody(UploadStickerFile.PNGSTICKER_FIELD, uploadStickerFile.getNewPngStickerStream(), ContentType.APPLICATION_OCTET_STREAM, uploadStickerFile.getNewPngStickerName()); + } + HttpEntity multipart = builder.build(); + httppost.setEntity(multipart); + + return uploadStickerFile.deserializeResponse(sendHttpPostRequest(httppost)); + } catch (IOException e) { + throw new TelegramApiException("Unable to upload new sticker file", e); + } + } + // Simplified methods @Override