api: telegram bot refactoring

2 files changed, 120 insertions, 138 deletions

diff --git a/juick-api/src/main/java/com/juick/api/TelegramBotManager.java b/juick-api/src/main/java/com/juick/api/TelegramBotManager.java
index 5523349f..a75804bb 100644
--- a/juick-api/src/main/java/com/juick/api/TelegramBotManager.java
+++ b/juick-api/src/main/java/com/juick/api/TelegramBotManager.java
@@ -19,15 +19,23 @@ package com.juick.api;
 
 import com.juick.User;
 import com.juick.server.component.MessageEvent;
+import com.juick.server.util.HttpUtils;
 import com.juick.service.MessagesService;
 import com.juick.service.SubscriptionService;
 import com.juick.service.TelegramService;
 import com.juick.service.UserService;
+import com.pengrad.telegrambot.BotUtils;
 import com.pengrad.telegrambot.Callback;
 import com.pengrad.telegrambot.TelegramBot;
+import com.pengrad.telegrambot.model.Message;
+import com.pengrad.telegrambot.model.MessageEntity;
+import com.pengrad.telegrambot.model.PhotoSize;
+import com.pengrad.telegrambot.model.Update;
 import com.pengrad.telegrambot.model.request.ParseMode;
+import com.pengrad.telegrambot.request.GetFile;
 import com.pengrad.telegrambot.request.SendMessage;
 import com.pengrad.telegrambot.request.SetWebhook;
+import com.pengrad.telegrambot.response.GetFileResponse;
 import com.pengrad.telegrambot.response.SendResponse;
 import org.apache.commons.lang3.StringUtils;
 import org.slf4j.Logger;
@@ -35,12 +43,18 @@ import org.slf4j.LoggerFactory;
 import org.springframework.beans.factory.annotation.Value;
 import org.springframework.context.ApplicationListener;
 import org.springframework.stereotype.Component;
+import org.springframework.web.util.UriComponents;
+import org.springframework.web.util.UriComponentsBuilder;
 
 import javax.annotation.Nonnull;
 import javax.annotation.PostConstruct;
 import javax.inject.Inject;
 import java.io.IOException;
+import java.net.URL;
+import java.util.Arrays;
+import java.util.Comparator;
 import java.util.List;
+import java.util.Optional;
 
 import static com.juick.formatters.PlainTextFormatter.formatPost;
 import static com.juick.formatters.PlainTextFormatter.formatUrl;
@@ -64,6 +78,10 @@ public class TelegramBotManager implements ApplicationListener<MessageEvent> {
     private SubscriptionService subscriptionService;
     @Inject
     private UserService userService;
+    @Inject
+    private ApiServer apiServer;
+    @Value("${upload_tmp_dir:/var/www/juick.com/i/tmp/}")
+    private String tmpDir;
 
     private static final String MSG_LINK = "🔗";
 
@@ -84,7 +102,108 @@ public class TelegramBotManager implements ApplicationListener<MessageEvent> {
         }
     }
 
+    public void processUpdate(String data) throws Exception {
+        Update update = BotUtils.parseUpdate(data);
+        Message message = update.message();
+        if (update.message() == null) {
+            message = update.editedMessage();
+            if (message == null) {
+                logger.error("error parsing telegram update: {}", update);
+                return;
+            }
+        }
+        User user_from = userService.getUserByUID(telegramService.getUser(message.chat().id())).orElse(new User());
+        logger.info("Found juick user {}", user_from.getUid());
 
+        List<Long> chats = telegramService.getChats();
+        String username = message.from().username();
+        if (username == null) {
+            username = message.from().firstName();
+        }
+        if (!chats.contains(message.chat().id())) {
+            telegramService.addChat(message.chat().id());
+            logger.info("added chat with {}", username);
+            telegramService.createTelegramUser(message.from().id(), username);
+            telegramSignupNotify(message.from().id().longValue(), userService.getSignUpHashByTelegramID(message.from().id().longValue(), username));
+        } else {
+            if (user_from.getUid() == 0) {
+                telegramSignupNotify(message.from().id().longValue(), userService.getSignUpHashByTelegramID(message.from().id().longValue(), username));
+            } else {
+                String attachment = StringUtils.EMPTY;
+                if (message.photo() != null) {
+                    String fileId = Arrays.stream(message.photo()).max(Comparator.comparingInt(PhotoSize::fileSize))
+                            .orElse(new PhotoSize()).fileId();
+                    if (StringUtils.isNotEmpty(fileId)) {
+                        GetFile request = new GetFile(fileId);
+                        GetFileResponse response = bot.execute(request);
+                        logger.info("got file {}", response.file());
+                        URL fileURL = new URL(bot.getFullFilePath(response.file()));
+                        attachment = HttpUtils.downloadImage(fileURL, tmpDir);
+                        logger.info("received {}", attachment);
+                    }
+                }
+                String text = message.text();
+                if (StringUtils.isBlank(text)) {
+                    text = message.caption();
+                }
+                if (StringUtils.isBlank(text)) {
+                    text = StringUtils.EMPTY;
+                }
+                if (StringUtils.isNotEmpty(text) || StringUtils.isNotEmpty(attachment)) {
+                    if (text.equalsIgnoreCase("/login") || text.equalsIgnoreCase("/start")
+                            || text.equalsIgnoreCase("/help")) {
+                        String msgUrl = "http://juick.com/login?" + userService.getHashByUID(user_from.getUid());
+                        String msg = String.format("Hi, %s!\nYou can post messages and images to Juick there.\n" +
+                                "Tap to [log into website](%s) to get more info", user_from.getName(), msgUrl);
+                        telegramNotify(message.from().id().longValue(), msg);
+                    } else {
+                        Message replyMessage = message.replyToMessage();
+                        if (replyMessage != null) {
+                            if (replyMessage.entities() != null) {
+                                Optional<MessageEntity> juickLink = Arrays.stream(replyMessage.entities())
+                                        .filter(this::isJuickLink)
+                                        .findFirst();
+                                if (juickLink.isPresent()) {
+                                    if (StringUtils.isNotEmpty(juickLink.get().url())) {
+                                        UriComponents uriComponents = UriComponentsBuilder.fromUriString(
+                                                juickLink.get().url()).build();
+                                        String path = uriComponents.getPath();
+                                        if (StringUtils.isNotEmpty(path) && path.length() > 1) {
+                                            int mid = Integer.valueOf(path.substring(1));
+                                            String prefix = String.format("#%d ", mid);
+                                            if (StringUtils.isNotEmpty(uriComponents.getFragment())) {
+                                                int rid = Integer.valueOf(uriComponents.getFragment());
+                                                prefix = String.format("#%d/%d ", mid, rid);
+                                            }
+                                            apiServer.processMessage(user_from, prefix + text, attachment);
+                                            telegramNotify(message.from().id().longValue(), "Reply sent");
+                                        } else {
+                                            logger.warn("invalid path: {}", path);
+                                        }
+                                    } else {
+                                        logger.warn("invalid entity: {}", juickLink);
+                                    }
+                                } else {
+                                    telegramNotify(message.from().id().longValue(),
+                                            "Can not reply to this message", replyMessage.messageId());
+                                }
+                            } else {
+                                telegramNotify(message.from().id().longValue(),
+                                        "Can not reply to this message", replyMessage.messageId());
+                            }
+                        } else {
+                            apiServer.processMessage(user_from, text, attachment);
+                            telegramNotify(message.from().id().longValue(), "Message sent");
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    private boolean isJuickLink(MessageEntity e) {
+        return e.offset() == 0 && e.type().equals(MessageEntity.Type.text_link) && e.length() == 2;
+    }
 
     @Override
     public void onApplicationEvent(@Nonnull MessageEvent event) {
@@ -169,8 +288,4 @@ public class TelegramBotManager implements ApplicationListener<MessageEvent> {
             }
         });
     }
-
-    public TelegramBot getBot() {
-        return bot;
-    }
 }
diff --git a/juick-api/src/main/java/com/juick/api/controllers/TelegramWebhook.java b/juick-api/src/main/java/com/juick/api/controllers/TelegramWebhook.java
index 034a8acf..31e7b4ea 100644
--- a/juick-api/src/main/java/com/juick/api/controllers/TelegramWebhook.java
+++ b/juick-api/src/main/java/com/juick/api/controllers/TelegramWebhook.java
@@ -17,42 +17,18 @@
 
 package com.juick.api.controllers;
 
-import com.juick.User;
-import com.juick.api.ApiServer;
 import com.juick.api.TelegramBotManager;
-import com.juick.server.util.HttpUtils;
-import com.juick.service.TelegramService;
-import com.juick.service.UserService;
-import com.pengrad.telegrambot.BotUtils;
-import com.pengrad.telegrambot.model.Message;
-import com.pengrad.telegrambot.model.MessageEntity;
-import com.pengrad.telegrambot.model.PhotoSize;
-import com.pengrad.telegrambot.model.Update;
-import com.pengrad.telegrambot.request.GetFile;
-import com.pengrad.telegrambot.response.GetFileResponse;
 import org.apache.commons.io.IOUtils;
-import org.apache.commons.lang3.StringUtils;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-import org.springframework.beans.factory.annotation.Value;
 import org.springframework.http.HttpStatus;
 import org.springframework.web.bind.annotation.RequestMapping;
 import org.springframework.web.bind.annotation.RequestMethod;
 import org.springframework.web.bind.annotation.ResponseStatus;
 import org.springframework.web.bind.annotation.RestController;
-import org.springframework.web.util.UriComponents;
-import org.springframework.web.util.UriComponentsBuilder;
 import springfox.documentation.annotations.ApiIgnore;
 
 import javax.inject.Inject;
 import java.io.InputStream;
-import java.io.InputStreamReader;
-import java.net.URL;
 import java.nio.charset.StandardCharsets;
-import java.util.Arrays;
-import java.util.Comparator;
-import java.util.List;
-import java.util.Optional;
 
 /**
  * Created by vt on 24/11/2016.
@@ -60,122 +36,13 @@ import java.util.Optional;
 @ApiIgnore
 @RestController
 public class TelegramWebhook {
-    private static Logger logger = LoggerFactory.getLogger(TelegramWebhook.class);
-    @Inject
-    private UserService usersService;
-    @Inject
-    private TelegramService telegramService;
     @Inject
     private TelegramBotManager telegramBotManager;
-    @Inject
-    private ApiServer apiServer;
-    @Value("${upload_tmp_dir:/var/www/juick.com/i/tmp/}")
-    private String tmpDir;
-
 
     @RequestMapping(value = "/tlgmbtwbhk", method = RequestMethod.POST)
     @ResponseStatus(value = HttpStatus.OK)
     public void processUpdate(InputStream body) throws Exception {
         String data = IOUtils.toString(body, StandardCharsets.UTF_8);
-        logger.info("got telegram msg: {}", data);
-        Update update = BotUtils.parseUpdate(data);
-        Message message = update.message();
-        if (update.message() == null) {
-            message = update.editedMessage();
-            if (message == null) {
-                logger.error("error parsing telegram update: {}", update);
-                return;
-            }
-        }
-        User user_from = usersService.getUserByUID(telegramService.getUser(message.chat().id())).orElse(new User());
-        logger.info("Found juick user {}", user_from.getUid());
-
-        List<Long> chats = telegramService.getChats();
-        String username = message.from().username();
-        if (username == null) {
-            username = message.from().firstName();
-        }
-        if (!chats.contains(message.chat().id())) {
-            telegramService.addChat(message.chat().id());
-            logger.info("added chat with {}", username);
-            telegramService.createTelegramUser(message.from().id(), username);
-            telegramBotManager.telegramSignupNotify(message.from().id().longValue(), usersService.getSignUpHashByTelegramID(message.from().id().longValue(), username));
-        } else {
-            if (user_from.getUid() == 0) {
-                telegramBotManager.telegramSignupNotify(message.from().id().longValue(), usersService.getSignUpHashByTelegramID(message.from().id().longValue(), username));
-            } else {
-                String attachment = StringUtils.EMPTY;
-                if (message.photo() != null) {
-                    String fileId = Arrays.stream(message.photo()).max(Comparator.comparingInt(PhotoSize::fileSize))
-                            .orElse(new PhotoSize()).fileId();
-                    if (StringUtils.isNotEmpty(fileId)) {
-                        GetFile request = new GetFile(fileId);
-                        GetFileResponse response = telegramBotManager.getBot().execute(request);
-                        logger.info("got file {}", response.file());
-                        URL fileURL = new URL(telegramBotManager.getBot().getFullFilePath(response.file()));
-                        attachment = HttpUtils.downloadImage(fileURL, tmpDir);
-                        logger.info("received {}", attachment);
-                    }
-                }
-                String text = message.text();
-                if (StringUtils.isBlank(text)) {
-                    text = message.caption();
-                }
-                if (StringUtils.isBlank(text)) {
-                    text = StringUtils.EMPTY;
-                }
-                if (StringUtils.isNotEmpty(text) || StringUtils.isNotEmpty(attachment)) {
-                    if (text.equalsIgnoreCase("/login") || text.equalsIgnoreCase("/start")
-                            || text.equalsIgnoreCase("/help")) {
-                        String msgUrl = "http://juick.com/login?" + usersService.getHashByUID(user_from.getUid());
-                        String msg = String.format("Hi, %s!\nYou can post messages and images to Juick there.\n" +
-                                "Tap to [log into website](%s) to get more info", user_from.getName(), msgUrl);
-                        telegramBotManager.telegramNotify(message.from().id().longValue(), msg);
-                    } else {
-                        Message replyMessage = message.replyToMessage();
-                        if (replyMessage != null) {
-                            if (replyMessage.entities() != null) {
-                                Optional<MessageEntity> juickLink = Arrays.stream(replyMessage.entities())
-                                        .filter(this::isJuickLink)
-                                        .findFirst();
-                                if (juickLink.isPresent()) {
-                                    if (StringUtils.isNotEmpty(juickLink.get().url())) {
-                                        UriComponents uriComponents = UriComponentsBuilder.fromUriString(
-                                                juickLink.get().url()).build();
-                                        String path = uriComponents.getPath();
-                                        if (StringUtils.isNotEmpty(path) && path.length() > 1) {
-                                            int mid = Integer.valueOf(path.substring(1));
-                                            String prefix = String.format("#%d ", mid);
-                                            if (StringUtils.isNotEmpty(uriComponents.getFragment())) {
-                                                int rid = Integer.valueOf(uriComponents.getFragment());
-                                                prefix = String.format("#%d/%d ", mid, rid);
-                                            }
-                                            apiServer.processMessage(user_from, prefix + text, attachment);
-                                            telegramBotManager.telegramNotify(message.from().id().longValue(), "Reply sent");
-                                        } else {
-                                            logger.warn("invalid path: {}", path);
-                                        }
-                                    } else {
-                                        logger.warn("invalid entity: {}", juickLink);
-                                    }
-                                } else {
-                                    telegramBotManager.telegramNotify(message.from().id().longValue(),
-                                            "Can not reply to this message", replyMessage.messageId());
-                                }
-                            } else {
-                                telegramBotManager.telegramNotify(message.from().id().longValue(),
-                                        "Can not reply to this message", replyMessage.messageId());
-                            }
-                        } else {
-                            apiServer.processMessage(user_from, text, attachment);
-                            telegramBotManager.telegramNotify(message.from().id().longValue(), "Message sent");
-                        }
-                    }
-                }
-            }
-        }
-    }
-    boolean isJuickLink(MessageEntity e) {
-        return e.offset() == 0 && e.type().equals(MessageEntity.Type.text_link) && e.length() == 2;
+        telegramBotManager.processUpdate(data);
     }
 }