Рефактор

src/main/java/ru/ldeloff/servermonitorbot/controller/TelegramBotController.java

@@ -0,0 +1,98 @@
+package ru.ldeloff.servermonitorbot.controller;
+
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Service;
+import org.telegram.telegrambots.bots.TelegramLongPollingBot;
+import org.telegram.telegrambots.meta.api.methods.send.SendMessage;
+import org.telegram.telegrambots.meta.api.objects.Update;
+import org.telegram.telegrambots.meta.exceptions.TelegramApiException;
+import ru.ldeloff.servermonitorbot.model.TelegramBot;
+import ru.ldeloff.servermonitorbot.repository.SshRepository;
+import ru.ldeloff.servermonitorbot.service.TelegramBotService;
+import ru.ldeloff.servermonitorbot.utils.ui.TelegramBotKeyboard;
+import ru.ldeloff.servermonitorbot.utils.ui.uname.UnameChatButtonAggregate;
+
+@Service
+@Slf4j
+public class TelegramBotController extends TelegramLongPollingBot {
+
+    final TelegramBot telegramBot;
+    final SshRepository sshRepository;
+    final TelegramBotKeyboard telegramBotKeyboard;
+    final UnameChatButtonAggregate unameChatButtonAggregate;
+    final TelegramBotService telegramBotService;
+
+    public TelegramBotController(TelegramBot telegramBot, SshRepository sshRepository, TelegramBotKeyboard telegramBotKeyboard, UnameChatButtonAggregate unameChatButtonAggregate, TelegramBotService telegramBotService) {
+        this.telegramBot = telegramBot;
+        this.sshRepository = sshRepository;
+        this.telegramBotKeyboard = telegramBotKeyboard;
+        this.unameChatButtonAggregate = unameChatButtonAggregate;
+        this.telegramBotService = telegramBotService;
+    }
+
+    @Override
+    public void onUpdateReceived(Update update) {
+        if (update.hasMessage()) {
+            if (update.getMessage().hasText()) {
+                String messageText = update.getMessage().getText();
+                switch (messageText) {
+                    case "/start" -> {
+                        log.info("Получена команда /start");
+                        telegramBotService.switchToMainMenu(update, this);
+                    }
+                    case "Статус" -> {
+                        log.info("Получена команда 'Статус'");
+                        telegramBotService.getStatusSessions(update, this);
+                    }
+                    case "uname" -> {
+                        log.info("Получена команда 'uname'");
+                        telegramBotService.sendUnameAggregate(update, this);
+                    }
+                    default -> {
+                        log.warn("Неизвестная команда:" + messageText);
+                        telegramBotService.switchToMainMenu(update, this);
+                    }
+                }
+            }
+        } else if (update.hasCallbackQuery()) {
+            String messageText = update.getCallbackQuery().getData();
+            String [] tags = messageText.split(":");
+            switch (tags[0]) {
+                case "uname":
+                    if (tags.length > 1) {
+                        switch (tags[1]) {
+                            default -> {
+                                log.warn("Неверный формат команды:" + messageText);
+                                telegramBotService.switchToMainMenu(update, this);
+                                break;
+                            }
+                        }
+                    } else {
+                        log.warn("Неверный формат команды:" + messageText);
+                        telegramBotService.switchToMainMenu(update, this);
+                    }
+                    break;
+                default :
+                    log.warn("Неизвестная команда:" + messageText);
+                    telegramBotService.switchToMainMenu(update, this);
+                    break;
+            }
+        }
+    }
+
+    @Override
+    public String getBotUsername() {
+        return telegramBot.getBotUsername();
+    }
+
+    @Override
+    public String getBotToken() {
+        return telegramBot.getBotToken();
+    }
+
+    @Override
+    public void onClosing() {
+        super.onClosing();
+        sshRepository.disconnectSessions();
+    }
+}

src/main/java/ru/ldeloff/servermonitorbot/init/SshConnect.java

@@ -3,18 +3,18 @@ package ru.ldeloff.servermonitorbot.init;
 import org.springframework.boot.ApplicationArguments;
 import org.springframework.boot.ApplicationRunner;
 import org.springframework.stereotype.Component;
-import ru.ldeloff.servermonitorbot.service.SshService;
+import ru.ldeloff.servermonitorbot.repository.SshRepository;
 
 @Component
 public class SshConnect implements ApplicationRunner {
-    final SshService sshService;
+    final SshRepository sshRepository;
 
-    public SshConnect(SshService sshService) {
+    public SshConnect(SshRepository sshRepository) {
-        this.sshService = sshService;
+        this.sshRepository = sshRepository;
     }
 
     @Override
     public void run(ApplicationArguments args) throws Exception {
-        sshService.connectToAllServer();
+        sshRepository.connectToAllServer();
     }
 }

src/main/java/ru/ldeloff/servermonitorbot/init/StartBot.java

@@ -9,16 +9,16 @@ import org.springframework.stereotype.Component;
 import org.telegram.telegrambots.meta.TelegramBotsApi;
 import org.telegram.telegrambots.meta.exceptions.TelegramApiException;
 import org.telegram.telegrambots.updatesreceivers.DefaultBotSession;
-import ru.ldeloff.servermonitorbot.service.TelegramBotService;
+import ru.ldeloff.servermonitorbot.controller.TelegramBotController;
 
 @Slf4j
 @Component
 @NoArgsConstructor
 public class StartBot implements ApplicationRunner {
-    private TelegramBotService telegramBot;
+    private TelegramBotController telegramBot;
 
     @Autowired
-    public StartBot(TelegramBotService telegramBot) {
+    public StartBot(TelegramBotController telegramBot) {
         this.telegramBot = telegramBot;
     }
 

src/main/java/ru/ldeloff/servermonitorbot/repository/SshRepository.java

@@ -0,0 +1,16 @@
+package ru.ldeloff.servermonitorbot.repository;
+
+import com.jcraft.jsch.JSchException;
+import com.jcraft.jsch.Session;
+import org.telegram.telegrambots.meta.api.methods.send.SendMessage;
+import ru.ldeloff.servermonitorbot.model.SshServer;
+
+import java.util.List;
+
+public interface SshRepository {
+    void connectToAllServer();
+    Session connectToServer(SshServer sshServer) throws JSchException;
+    void disconnectSessions();
+    String getStatusSessions();
+    List<SshServer> getSshServers();
+}

src/main/java/ru/ldeloff/servermonitorbot/repository/SshRepositoryImpl.java

@@ -0,0 +1,78 @@
+package ru.ldeloff.servermonitorbot.repository;
+
+import com.jcraft.jsch.JSch;
+import com.jcraft.jsch.JSchException;
+import com.jcraft.jsch.Session;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Repository;
+import org.telegram.telegrambots.meta.api.methods.send.SendMessage;
+import ru.ldeloff.servermonitorbot.config.SshConfig;
+import ru.ldeloff.servermonitorbot.model.SshServer;
+
+import java.util.ArrayList;
+import java.util.List;
+
+@Slf4j
+@Repository
+public class SshRepositoryImpl implements SshRepository {
+
+    private final List<SshServer> sshServers;
+
+    @Autowired
+    public SshRepositoryImpl(SshConfig sshConfig) {
+        this.sshServers = sshConfig.getServers();
+    }
+
+    private List<Session> sessions = new ArrayList<>();
+
+    @Override
+    public void connectToAllServer() {
+        sshServers.forEach(sshServer -> {
+            try {
+                Session session = connectToServer(sshServer);
+                sshServer.setSession(session);
+                log.info("Успешно подключён к " + sshServer.getHost());
+                sessions.add(session);
+            } catch (JSchException e) {
+                log.warn("Не удалось соединиться с " + sshServer.getHost() + ": " + e.getMessage());
+            }
+        });
+    }
+
+    @Override
+    public Session connectToServer(SshServer sshServer) throws JSchException {
+        Session session = new JSch().getSession(sshServer.getUser(),
+                sshServer.getHost(),
+                sshServer.getPort());
+        session.setPassword(sshServer.getPassword());
+        session.setConfig("StrictHostKeyChecking", "no");
+        session.connect();
+        return session;
+    }
+
+    @Override
+    public void disconnectSessions() {
+        if (!sessions.isEmpty()) {
+            sessions.forEach(Session::disconnect);
+            sessions.forEach(sessions::remove);
+        }
+    }
+
+    @Override
+    public String getStatusSessions() {
+        StringBuilder text = new StringBuilder("Статус соединения: \n");
+        sshServers.forEach(server -> {
+            text.append(server.getName())
+                    .append(": ")
+                    .append(server.getSession().isConnected() ? "OK" : "отключён")
+                    .append("\n");
+        });
+        return String.valueOf(text);
+    }
+
+    @Override
+    public List<SshServer> getSshServers() {
+        return sshServers;
+    }
+}

src/main/java/ru/ldeloff/servermonitorbot/service/SshService.java

@@ -1,17 +1,5 @@
 package ru.ldeloff.servermonitorbot.service;
 
-import com.jcraft.jsch.JSchException;
-import com.jcraft.jsch.Session;
-import org.telegram.telegrambots.meta.api.methods.send.SendMessage;
-import ru.ldeloff.servermonitorbot.model.SshServer;
-
-import java.util.List;
 
 public interface SshService {
-    void connectToAllServer();
-    Session connectToServer(SshServer sshServer) throws JSchException;
-    void disconnectSessions();
-    SendMessage getStatusSessions(Long chatId);
-
-    List<SshServer> getSshServers();
 }

src/main/java/ru/ldeloff/servermonitorbot/service/SshServiceImpl.java

@@ -1,81 +1,8 @@
 package ru.ldeloff.servermonitorbot.service;
 
-import com.jcraft.jsch.JSch;
-import com.jcraft.jsch.JSchException;
-import com.jcraft.jsch.Session;
-import lombok.extern.slf4j.Slf4j;
-import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
-import org.telegram.telegrambots.meta.api.methods.send.SendMessage;
-import ru.ldeloff.servermonitorbot.config.SshConfig;
-import ru.ldeloff.servermonitorbot.model.SshServer;
 
-import java.util.ArrayList;
-import java.util.List;
-
-@Slf4j
 @Service
-public class SshServiceImpl implements SshService{
+public class SshServiceImpl implements  SshService {
 
-    private final List<SshServer> sshServers;
-
-    @Autowired
-    public SshServiceImpl(SshConfig sshConfig) {
-        this.sshServers = sshConfig.getServers();
-    }
-
-    private List<Session> sessions = new ArrayList<>();
-
-    @Override
-    public void connectToAllServer() {
-        sshServers.forEach(sshServer -> {
-            try {
-                Session session = connectToServer(sshServer);
-                sshServer.setSession(session);
-                log.info("Успешно подключён к " + sshServer.getHost());
-                sessions.add(session);
-            } catch (JSchException e) {
-                log.warn("Не удалось соединиться с " + sshServer.getHost() + ": " + e.getMessage());
-            }
-        });
-    }
-
-    @Override
-    public Session connectToServer(SshServer sshServer) throws JSchException {
-        Session session = new JSch().getSession(sshServer.getUser(),
-                sshServer.getHost(),
-                sshServer.getPort());
-        session.setPassword(sshServer.getPassword());
-        session.setConfig("StrictHostKeyChecking", "no");
-        session.connect();
-        return session;
-    }
-
-    @Override
-    public void disconnectSessions() {
-        if (!sessions.isEmpty()) {
-            sessions.forEach(Session::disconnect);
-            sessions.forEach(sessions::remove);
-        }
-    }
-
-    @Override
-    public SendMessage getStatusSessions(Long chatId) {
-        StringBuilder text = new StringBuilder("Статус соединения: \n");
-        sshServers.forEach(server -> {
-            text.append(server.getName())
-                    .append(": ")
-                    .append(server.getSession().isConnected() ? "OK" : "отключён")
-                    .append("\n");
-        });
-        SendMessage message = new SendMessage();
-        message.setText(String.valueOf(text));
-        message.setChatId(chatId);
-        return message;
-    }
-
-    @Override
-    public List<SshServer> getSshServers() {
-        return sshServers;
-    }
 }

src/main/java/ru/ldeloff/servermonitorbot/service/TelegramBotService.java

@@ -1,92 +1,11 @@
 package ru.ldeloff.servermonitorbot.service;
 
-import lombok.extern.slf4j.Slf4j;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.stereotype.Service;
-import org.telegram.telegrambots.bots.TelegramLongPollingBot;
-import org.telegram.telegrambots.meta.api.methods.send.SendMessage;
 import org.telegram.telegrambots.meta.api.objects.Update;
-import org.telegram.telegrambots.meta.exceptions.TelegramApiException;
+import ru.ldeloff.servermonitorbot.controller.TelegramBotController;
-import ru.ldeloff.servermonitorbot.model.TelegramBot;
-import ru.ldeloff.servermonitorbot.service.ui.TelegramBotKeyboard;
-import ru.ldeloff.servermonitorbot.service.ui.uname.UnameChatButton;
 
-@Service
+public interface TelegramBotService {
-@Slf4j
-public class TelegramBotService extends TelegramLongPollingBot {
 
-    final TelegramBot telegramBot;
+    void switchToMainMenu(Update update, TelegramBotController bot);
-    final SshService sshService;
+    void getStatusSessions(Update update, TelegramBotController bot);
-    final TelegramBotKeyboard telegramBotKeyboard;
+    void sendUnameAggregate(Update update, TelegramBotController bot);
-    final UnameChatButton unameChatButton;
-
-
-    @Autowired
-    public TelegramBotService(TelegramBot telegramBot, SshService sshService, TelegramBotKeyboard telegramBotKeyboard, UnameChatButton unameChatButton) {
-        this.telegramBot = telegramBot;
-        this.sshService = sshService;
-        this.telegramBotKeyboard = telegramBotKeyboard;
-        this.unameChatButton = unameChatButton;
-    }
-
-    @Override
-    public void onUpdateReceived(Update update) {
-        if (update.hasMessage()) {
-            if (update.getMessage().hasText()) {
-                SendMessage message = new SendMessage();
-                String messageText = update.getMessage().getText();
-                long chatId = update.getMessage().getChatId();
-                switch (messageText) {
-                    case "/start":
-                        message.setText("Привет: " + update.getMessage().getChat().getUserName());
-                        message.setChatId(chatId);
-                        message.setReplyMarkup(telegramBotKeyboard.initKeyboardButtons());
-                        sendMessage(message);
-                        log.info("Получена команда /start");
-                        break;
-                    case "Статус":
-                        sendMessage(sshService.getStatusSessions(chatId));
-                        log.info("Получена команда 'Статус'");
-                        break;
-                    case "uname":
-                        sendMessage(unameChatButton.initMenu(chatId));
-                        log.info("Получена команда 'uname'");
-                        break;
-                    default:
-                        message.setText("unknown command:" + messageText);
-                        message.setChatId(chatId);
-                        message.setReplyMarkup(telegramBotKeyboard.initKeyboardButtons());
-                        sendMessage(message);
-                        log.warn("Неизвестная команда:" + messageText);
-                }
-            }
-        } else if (update.hasCallbackQuery()) {
-            System.out.println(update.getCallbackQuery().getData()); // TODO
-        }
-    }
-
-    private void sendMessage(SendMessage message) {
-        try {
-            execute(message);
-        } catch (TelegramApiException e) {
-            e.printStackTrace();
-            log.warn(e.getMessage());
-        }
-    }
-
-    @Override
-    public String getBotUsername() {
-        return telegramBot.getBotUsername();
-    }
-
-    @Override
-    public String getBotToken() {
-        return telegramBot.getBotToken();
-    }
-
-    @Override
-    public void onClosing() {
-        super.onClosing();
-        sshService.disconnectSessions();
-    }
 }

src/main/java/ru/ldeloff/servermonitorbot/service/TelegramBotServiceImpl.java

@@ -0,0 +1,63 @@
+package ru.ldeloff.servermonitorbot.service;
+
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Service;
+import org.telegram.telegrambots.meta.api.methods.send.SendMessage;
+import org.telegram.telegrambots.meta.api.objects.Update;
+import org.telegram.telegrambots.meta.exceptions.TelegramApiException;
+import ru.ldeloff.servermonitorbot.controller.TelegramBotController;
+import ru.ldeloff.servermonitorbot.repository.SshRepository;
+import ru.ldeloff.servermonitorbot.utils.ui.TelegramBotKeyboard;
+import ru.ldeloff.servermonitorbot.utils.ui.uname.UnameChatButtonAggregate;
+
+@Slf4j
+@Service
+public class TelegramBotServiceImpl implements TelegramBotService {
+    final TelegramBotKeyboard telegramBotKeyboard;
+    final SshRepository sshRepository;
+    final UnameChatButtonAggregate unameChatButtonAggregate;
+
+    public TelegramBotServiceImpl(TelegramBotKeyboard telegramBotKeyboard, SshRepository sshRepository, UnameChatButtonAggregate unameChatButtonAggregate) {
+        this.telegramBotKeyboard = telegramBotKeyboard;
+        this.sshRepository = sshRepository;
+        this.unameChatButtonAggregate = unameChatButtonAggregate;
+    }
+    @Override
+    public void switchToMainMenu(Update update, TelegramBotController bot) {
+        SendMessage message = new SendMessage();
+        long chatId = 0L;
+        try {
+            chatId = update.getMessage().getChatId();
+        } catch (Exception e) {
+            chatId = update.getCallbackQuery().getMessage().getChatId();
+
+        }
+        message.setText("Неверная команда и или формат. Попробуем сначала.");
+        message.setChatId(chatId);
+        sendMessage(telegramBotKeyboard.uiForm(message), bot);
+    }
+    @Override
+    public void getStatusSessions(Update update, TelegramBotController bot) {
+        SendMessage message = new SendMessage();
+        long chatId = update.getMessage().getChatId();
+        message.setText(String.valueOf(sshRepository.getStatusSessions()));
+        message.setChatId(chatId);
+        sendMessage(message, bot);
+    }
+    @Override
+    public void sendUnameAggregate(Update update, TelegramBotController bot) {
+        SendMessage message = new SendMessage();
+        long chatId = update.getMessage().getChatId();
+        message.setText(String.valueOf(sshRepository.getStatusSessions()));
+        message.setChatId(chatId);
+        sendMessage(unameChatButtonAggregate.uiForm(message), bot);
+    }
+    private void sendMessage(SendMessage message, TelegramBotController bot) {
+        try {
+            bot.execute(message);
+        } catch (TelegramApiException e) {
+            e.printStackTrace();
+            log.warn(e.getMessage());
+        }
+    }
+}

src/main/java/ru/ldeloff/servermonitorbot/utils/ui/TelegramBotKeyboard.java

@@ -1,30 +1,25 @@
-package ru.ldeloff.servermonitorbot.service.ui;
+package ru.ldeloff.servermonitorbot.utils.ui;
 
-import lombok.extern.slf4j.Slf4j;
 import org.springframework.stereotype.Component;
-import org.springframework.stereotype.Service;
 import org.telegram.telegrambots.meta.api.methods.send.SendMessage;
-import org.telegram.telegrambots.meta.api.objects.replykeyboard.InlineKeyboardMarkup;
 import org.telegram.telegrambots.meta.api.objects.replykeyboard.ReplyKeyboardMarkup;
-import org.telegram.telegrambots.meta.api.objects.replykeyboard.buttons.InlineKeyboardButton;
 import org.telegram.telegrambots.meta.api.objects.replykeyboard.buttons.KeyboardButton;
 import org.telegram.telegrambots.meta.api.objects.replykeyboard.buttons.KeyboardRow;
 
 
 import java.util.ArrayList;
-import java.util.List;
 
-@Service
+@Component
-public class TelegramBotKeyboard {
+public class TelegramBotKeyboard implements UiFormer {
     private final String STATUS = "Статус";
     private final String UNAME = "uname";
-    public ReplyKeyboardMarkup initKeyboardButtons()
+
-    {
+    @Override
+    public SendMessage uiForm(SendMessage message) {
         ReplyKeyboardMarkup replyKeyboardMarkup = new ReplyKeyboardMarkup();
         replyKeyboardMarkup.setResizeKeyboard(true); //подгоняем размер
         replyKeyboardMarkup.setOneTimeKeyboard(false); //скрываем после использования
 
-
         ArrayList<KeyboardRow> keyboardRows = new ArrayList<>();
 
         KeyboardRow keyboardRow = new KeyboardRow();
@@ -34,6 +29,7 @@ public class TelegramBotKeyboard {
         keyboardRow.add(new KeyboardButton(UNAME));
 
         replyKeyboardMarkup.setKeyboard(keyboardRows);
-        return replyKeyboardMarkup;
+        message.setReplyMarkup(replyKeyboardMarkup);
+        return message;
     }
 }

src/main/java/ru/ldeloff/servermonitorbot/utils/ui/UiFormer.java

@@ -0,0 +1,7 @@
+package ru.ldeloff.servermonitorbot.utils.ui;
+
+import org.telegram.telegrambots.meta.api.methods.send.SendMessage;
+
+public interface UiFormer {
+    SendMessage uiForm(SendMessage message);
+}

src/main/java/ru/ldeloff/servermonitorbot/utils/ui/uname/UnameChatButtonAggregate.java

@@ -1,36 +1,33 @@
-package ru.ldeloff.servermonitorbot.service.ui.uname;
+package ru.ldeloff.servermonitorbot.utils.ui.uname;
 
 import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.stereotype.Service;
+import org.springframework.stereotype.Component;
 import org.telegram.telegrambots.meta.api.methods.send.SendMessage;
 import org.telegram.telegrambots.meta.api.objects.replykeyboard.InlineKeyboardMarkup;
 import org.telegram.telegrambots.meta.api.objects.replykeyboard.buttons.InlineKeyboardButton;
-import ru.ldeloff.servermonitorbot.model.SshServer;
+import ru.ldeloff.servermonitorbot.repository.SshRepository;
-import ru.ldeloff.servermonitorbot.service.SshService;
+import ru.ldeloff.servermonitorbot.utils.ui.UiFormer;
 
 import java.util.ArrayList;
 import java.util.List;
 
-@Service
+@Component
-public class UnameChatButton {
+public class UnameChatButtonAggregate implements UiFormer {
 
-    private final SshService sshService;
+    private final SshRepository sshRepository;
 
     @Autowired
-    public UnameChatButton(SshService sshService) {
+    public UnameChatButtonAggregate(SshRepository sshRepository) {
-        this.sshService = sshService;
+        this.sshRepository = sshRepository;
     }
 
-    public SendMessage initMenu(long chatId) {
+    @Override
-        SendMessage message = new SendMessage();
+    public SendMessage uiForm(SendMessage message) {
-        message.setChatId(chatId);
-        message.setText("Сервер:");
-
         List<List<InlineKeyboardButton>> keyboard = new ArrayList<>();
 
         InlineKeyboardMarkup inlineKeyboardMarkup = new InlineKeyboardMarkup();
 
-        sshService.getSshServers().forEach(sshServer -> {
+        sshRepository.getSshServers().forEach(sshServer -> {
             List<InlineKeyboardButton> keyboardRow = new ArrayList<>();
             InlineKeyboardButton inlineKeyboardButton = new InlineKeyboardButton();
             inlineKeyboardButton.setText(sshServer.getName());
@@ -45,7 +42,6 @@ public class UnameChatButton {
         keyboardRow.add(inlineKeyboardButton);
         keyboard.add(keyboardRow);
 
-
         inlineKeyboardMarkup.setKeyboard(keyboard);
         message.setReplyMarkup(inlineKeyboardMarkup);