Hedgehog_server
/
ServerMonitorBot
3
0
Fork 0
Code Issues 14 Pull Requests Packages Projects 1 Releases Wiki Activity

Merge pull request 'feature/add-uname-command' (#4) from feature/add-uname-command into master 

Reviewed-on: L_DelOff/ServerMonitorBot#4
pull/5/head
L_DelOff 2023-08-08 21:02:32 +03:00
parent 26d9f83917 e6fac12e15
commit 0cfdd37702
15 changed files with 447 additions and 170 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

87
src/main/java/ru/ldeloff/servermonitorbot/controller/TelegramBotController.java Normal file
View File

@ -0,0 +1,87 @@
package ru.ldeloff.servermonitorbot.controller;
import lombok.RequiredArgsConstructor;
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
@RequiredArgsConstructor
public class TelegramBotController extends TelegramLongPollingBot {
final TelegramBot telegramBot;
final SshRepository sshRepository;
final TelegramBotKeyboard telegramBotKeyboard;
final UnameChatButtonAggregate unameChatButtonAggregate;
final 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.firstUse(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(":");
if (tags.length > 1) {
switch (tags[0]) {
case "uname":
log.info("Получена команда '" + messageText + "'");
telegramBotService.uname(update, this);
break;
default:
log.warn("Неизвестная команда:" + messageText);
telegramBotService.switchToMainMenu(update, this);
break;
}
} else {
log.warn("Неверный формат команды:" + messageText);
telegramBotService.switchToMainMenu(update, this);
}
}
}
@Override
public String getBotUsername() {
return telegramBot.getBotUsername();
}
@Override
public String getBotToken() {
return telegramBot.getBotToken();
}
@Override
public void onClosing() {
super.onClosing();
sshRepository.disconnectSessions();
}
}

10
src/main/java/ru/ldeloff/servermonitorbot/init/SshConnect.java
View File

@ -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) {
this.sshService = sshService;
public SshConnect(SshRepository sshRepository) {
this.sshRepository = sshRepository;
}
@Override
public void run(ApplicationArguments args) throws Exception {
sshService.connectToAllServer();
sshRepository.connectToAllServer();
}
}

7
src/main/java/ru/ldeloff/servermonitorbot/init/StartBot.java
View File

@ -9,17 +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.model.TelegramBot;
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;
}

8
src/main/java/ru/ldeloff/servermonitorbot/service/SshService.java → src/main/java/ru/ldeloff/servermonitorbot/repository/SshRepository.java
View File

@ -1,4 +1,4 @@
package ru.ldeloff.servermonitorbot.service;
package ru.ldeloff.servermonitorbot.repository;
import com.jcraft.jsch.JSchException;
import com.jcraft.jsch.Session;
@ -7,10 +7,10 @@ import ru.ldeloff.servermonitorbot.model.SshServer;
import java.util.List;
public interface SshService {
public interface SshRepository {
void connectToAllServer();
Session connectToServer(SshServer sshServer) throws JSchException;
void disconnectSessions();
SendMessage getStatusSessions(Long chatId);
String getStatusSessions();
List<SshServer> getSshServers();
}

22
src/main/java/ru/ldeloff/servermonitorbot/service/SshServiceImpl.java → src/main/java/ru/ldeloff/servermonitorbot/repository/SshRepositoryImpl.java
View File

@ -1,11 +1,11 @@
package ru.ldeloff.servermonitorbot.service;
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.Service;
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;
@ -14,13 +14,13 @@ import java.util.ArrayList;
import java.util.List;
@Slf4j
@Service
public class SshServiceImpl implements SshService{
@Repository
public class SshRepositoryImpl implements SshRepository {
private final List<SshServer> sshServers;
@Autowired
public SshServiceImpl(SshConfig sshConfig) {
public SshRepositoryImpl(SshConfig sshConfig) {
this.sshServers = sshConfig.getServers();
}
@ -60,7 +60,7 @@ public class SshServiceImpl implements SshService{
}
@Override
public SendMessage getStatusSessions(Long chatId) {
public String getStatusSessions() {
StringBuilder text = new StringBuilder("Статус соединения: \n");
sshServers.forEach(server -> {
text.append(server.getName())
@ -68,9 +68,11 @@ public class SshServiceImpl implements SshService{
.append(server.getSession().isConnected() ? "OK" : "отключён")
.append("\n");
});
SendMessage message = new SendMessage();
message.setText(String.valueOf(text));
message.setChatId(chatId);
return message;
return String.valueOf(text);
}
@Override
public List<SshServer> getSshServers() {
return sshServers;
}
}

93
src/main/java/ru/ldeloff/servermonitorbot/service/TelegramBotService.java
View File

@ -1,92 +1,13 @@
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.model.TelegramBot;
import ru.ldeloff.servermonitorbot.util.TelegramBotMenu;
import ru.ldeloff.servermonitorbot.controller.TelegramBotController;
@Service
@Slf4j
public class TelegramBotService extends TelegramLongPollingBot {
public interface TelegramBotService {
final TelegramBot telegramBot;
final SshService sshService;
final TelegramBotMenu telegramBotMenu;
@Autowired
public TelegramBotService(TelegramBot telegramBot, SshService sshService, TelegramBotMenu telegramBotMenu) {
this.telegramBot = telegramBot;
this.sshService = sshService;
this.telegramBotMenu = telegramBotMenu;
}
@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(telegramBotMenu.initKeyboard());
sendMessage(message);
log.info("Получена команда /start");
break;
case "Статус":
sendMessage(sshService.getStatusSessions(chatId));
log.info("Получена команда 'Статус'");
break;
default:
message.setText("unknown command:" + messageText);
message.setChatId(chatId);
message.setReplyMarkup(telegramBotMenu.initKeyboard());
sendMessage(message);
log.warn("Неизвестная команда:" + messageText);
}
}
} else if (update.hasCallbackQuery()) {
try {
SendMessage message = new SendMessage();
message.setText(update.getCallbackQuery().getData());
message.setChatId(update.getCallbackQuery().getMessage().getChatId());
execute(message);
} catch (TelegramApiException e) {
e.printStackTrace();
}
}
}
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();
}
void switchToMainMenu(Update update, TelegramBotController bot);
void getStatusSessions(Update update, TelegramBotController bot);
void sendUnameAggregate(Update update, TelegramBotController bot);
void uname(Update update, TelegramBotController bot);
void firstUse(Update update, TelegramBotController telegramBotController);
}

69
src/main/java/ru/ldeloff/servermonitorbot/service/TelegramBotServiceImpl.java Normal file
View File

@ -0,0 +1,69 @@
package ru.ldeloff.servermonitorbot.service;
import lombok.RequiredArgsConstructor;
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.service.ssh.SshService;
import ru.ldeloff.servermonitorbot.service.uname.UnameService;
import ru.ldeloff.servermonitorbot.utils.ui.TelegramBotKeyboard;
import ru.ldeloff.servermonitorbot.utils.ui.uname.UnameChatButtonAggregate;
@Slf4j
@Service
@RequiredArgsConstructor
public class TelegramBotServiceImpl implements TelegramBotService {
final TelegramBotKeyboard telegramBotKeyboard;
final UnameChatButtonAggregate unameChatButtonAggregate;
final UnameService unameService;
final SshService sshService;
@Override
public void firstUse(Update update, TelegramBotController bot) {
SendMessage message = new SendMessage();
long chatId = 0L;
chatId = update.getMessage().getChatId();
message.setText("Добро пожалвать " + update.getMessage().getChat().getUserName() + "!");
message.setChatId(chatId);
sendMessage(telegramBotKeyboard.uiForm(message), bot);
}
@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(sshService.getStatusSessions(update), bot);
}
@Override
public void sendUnameAggregate(Update update, TelegramBotController bot) {
sendMessage(unameService.sendUnameAggregate(update), bot);
}
@Override
public void uname(Update update, TelegramBotController bot) {
sendMessage(unameService.uname(update), bot);
}
private void sendMessage(SendMessage message, TelegramBotController bot) {
try {
bot.execute(message);
} catch (TelegramApiException e) {
e.printStackTrace();
log.warn(e.getMessage());
}
}
}

16
src/main/java/ru/ldeloff/servermonitorbot/service/ssh/SshService.java Normal file
View File

@ -0,0 +1,16 @@
package ru.ldeloff.servermonitorbot.service.ssh;
import org.telegram.telegrambots.meta.api.methods.send.SendMessage;
import org.telegram.telegrambots.meta.api.objects.Update;
import ru.ldeloff.servermonitorbot.model.SshServer;
import java.util.List;
public interface SshService {
SendMessage getStatusSessions(Update update);
List<SshServer> getSshServers();
String execute(String s, SshServer sshServer);
String execute(String s, SshServer sshServer, int timeout);
}

66
src/main/java/ru/ldeloff/servermonitorbot/service/ssh/SshServiceImpl.java Normal file
View File

@ -0,0 +1,66 @@
package ru.ldeloff.servermonitorbot.service.ssh;
import com.jcraft.jsch.ChannelExec;
import com.jcraft.jsch.JSchException;
import com.jcraft.jsch.Session;
import lombok.RequiredArgsConstructor;
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 ru.ldeloff.servermonitorbot.model.SshServer;
import ru.ldeloff.servermonitorbot.repository.SshRepository;
import java.io.ByteArrayOutputStream;
import java.util.List;
@Service
@Slf4j
@RequiredArgsConstructor
public class SshServiceImpl implements SshService {
final SshRepository sshRepository;
@Override
public SendMessage getStatusSessions(Update update) {
SendMessage message = new SendMessage();
long chatId = update.getMessage().getChatId();
message.setText(sshRepository.getStatusSessions());
message.setChatId(chatId);
return message;
}
@Override
public List<SshServer> getSshServers() {
return sshRepository.getSshServers();
}
@Override
public String execute(String s, SshServer sshServer) {
return execute(s, sshServer, 100);
}
@Override
public String execute(String s, SshServer sshServer, int timeout) {
Session session = sshServer.getSession();
ChannelExec channel = null;
try {
channel = (ChannelExec) session.openChannel("exec");
channel.setCommand(s);
ByteArrayOutputStream responseStream = new ByteArrayOutputStream();
channel.setOutputStream(responseStream);
channel.connect();
while (channel.isConnected()) {
Thread.sleep(timeout);
}
String responseString = new String(responseStream.toByteArray());
return responseString;
} catch (JSchException | InterruptedException e) {
log.error(e.getMessage());
return null;
} finally {
if (channel != null) {
channel.disconnect();
}
}
}
}

10
src/main/java/ru/ldeloff/servermonitorbot/service/uname/UnameService.java Normal file
View File

@ -0,0 +1,10 @@
package ru.ldeloff.servermonitorbot.service.uname;
import org.telegram.telegrambots.meta.api.methods.send.SendMessage;
import org.telegram.telegrambots.meta.api.objects.Update;
public interface UnameService {
SendMessage sendUnameAggregate(Update update);
SendMessage uname(Update update);
}

74
src/main/java/ru/ldeloff/servermonitorbot/service/uname/UnameServiceImpl.java Normal file
View File

@ -0,0 +1,74 @@
package ru.ldeloff.servermonitorbot.service.uname;
import lombok.RequiredArgsConstructor;
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 ru.ldeloff.servermonitorbot.model.SshServer;
import ru.ldeloff.servermonitorbot.service.ssh.SshService;
import ru.ldeloff.servermonitorbot.utils.ui.uname.UnameChatButtonAggregate;
import java.util.Arrays;
import java.util.List;
import java.util.Objects;
import java.util.Optional;
@Service
@RequiredArgsConstructor
@Slf4j
public class UnameServiceImpl implements UnameService {
final SshService sshService;
final UnameChatButtonAggregate unameChatButtonAggregate;
@Override
public SendMessage sendUnameAggregate(Update update) {
SendMessage message = new SendMessage();
long chatId = update.getMessage().getChatId();
message.setChatId(chatId);
return unameChatButtonAggregate.uiForm(message);
}
@Override
public SendMessage uname(Update update) {
String messageText = update.getCallbackQuery().getData();
String [] tags = Arrays.stream(messageText.split(":"))
.map(String::trim)
.toArray(String[]::new);
String result;
if (tags[1].equals("all")) {
result = unameAllHost();
} else {
result = unameSpecificHost(tags[1]);
}
SendMessage message = new SendMessage();
long chatId = update.getCallbackQuery().getMessage().getChatId();
message.setChatId(chatId);
message.setText(result);
return message;
}
private String unameAllHost() {
List<SshServer> servers = sshService.getSshServers();
StringBuilder response = new StringBuilder();
servers.forEach(server -> {
response.append(unameSpecificHost(server.getName())).append("\n");
});
return response.toString();
}
private String unameSpecificHost(String serverName) {
Optional<SshServer> server = sshService.getSshServers()
.stream()
.filter(x -> x.getName().equals(serverName))
.findFirst();
if (server.isPresent()) {
String result = sshService.execute("uname -a", server.get());
return server.get().getName() + ": " + (Objects.isNull(result) ? "ошибка при выполнении команды" : result);
} else {
log.error("Ошибка при выполнении команды 'uname'. Искомый сервер (" + serverName + ") не найден");
return null;
}
}
}

61
src/main/java/ru/ldeloff/servermonitorbot/util/TelegramBotMenu.java
View File

@ -1,61 +0,0 @@
package ru.ldeloff.servermonitorbot.util;
import lombok.extern.slf4j.Slf4j;
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.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;
@Slf4j
@Component
public class TelegramBotMenu {
private final String STATUS = "Статус";
public ReplyKeyboardMarkup initKeyboard()
{
//Создаем объект будущей клавиатуры и выставляем нужные настройки
ReplyKeyboardMarkup replyKeyboardMarkup = new ReplyKeyboardMarkup();
replyKeyboardMarkup.setResizeKeyboard(true); //подгоняем размер
replyKeyboardMarkup.setOneTimeKeyboard(false); //скрываем после использования
//Создаем список с рядами кнопок
ArrayList<KeyboardRow> keyboardRows = new ArrayList<>();
//Создаем один ряд кнопок и добавляем его в список
KeyboardRow keyboardRow = new KeyboardRow();
keyboardRows.add(keyboardRow);
//Добавляем одну кнопку с текстом "Просвяти" наш ряд
keyboardRow.add(new KeyboardButton(STATUS));
//добавляем лист с одним рядом кнопок в главный объект
replyKeyboardMarkup.setKeyboard(keyboardRows);
return replyKeyboardMarkup;
}
public SendMessage mainMenu(long chatId) {
SendMessage message = new SendMessage();
message.setChatId(chatId);
message.setText("Choose an option:");
InlineKeyboardMarkup inlineKeyboardMarkup = new InlineKeyboardMarkup();
List<InlineKeyboardButton> keyboardRow = new ArrayList<>();
InlineKeyboardButton inlineKeyboardButton = new InlineKeyboardButton();
inlineKeyboardButton.setText(STATUS);
inlineKeyboardButton.setCallbackData("Button \"" + STATUS + "\" has been pressed");
keyboardRow.add(inlineKeyboardButton);
List<List<InlineKeyboardButton>> keyboard = new ArrayList<>();
keyboard.add(keyboardRow);
inlineKeyboardMarkup.setKeyboard(keyboard);
message.setReplyMarkup(inlineKeyboardMarkup);
return message;
}
}

35
src/main/java/ru/ldeloff/servermonitorbot/utils/ui/TelegramBotKeyboard.java Normal file
View File

@ -0,0 +1,35 @@
package ru.ldeloff.servermonitorbot.utils.ui;
import org.springframework.stereotype.Component;
import org.telegram.telegrambots.meta.api.methods.send.SendMessage;
import org.telegram.telegrambots.meta.api.objects.replykeyboard.ReplyKeyboardMarkup;
import org.telegram.telegrambots.meta.api.objects.replykeyboard.buttons.KeyboardButton;
import org.telegram.telegrambots.meta.api.objects.replykeyboard.buttons.KeyboardRow;
import java.util.ArrayList;
@Component
public class TelegramBotKeyboard implements UiFormer {
private final String STATUS = "Статус";
private final String UNAME = "uname";
@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();
keyboardRows.add(keyboardRow);
keyboardRow.add(new KeyboardButton(STATUS));
keyboardRow.add(new KeyboardButton(UNAME));
replyKeyboardMarkup.setKeyboard(keyboardRows);
message.setReplyMarkup(replyKeyboardMarkup);
return message;
}
}

7
src/main/java/ru/ldeloff/servermonitorbot/utils/ui/UiFormer.java Normal file
View File

@ -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);
}

52
src/main/java/ru/ldeloff/servermonitorbot/utils/ui/uname/UnameChatButtonAggregate.java Normal file
View File

@ -0,0 +1,52 @@
package ru.ldeloff.servermonitorbot.utils.ui.uname;
import lombok.RequiredArgsConstructor;
import org.springframework.beans.factory.annotation.Autowired;
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.repository.SshRepository;
import ru.ldeloff.servermonitorbot.service.ssh.SshService;
import ru.ldeloff.servermonitorbot.utils.ui.UiFormer;
import java.util.ArrayList;
import java.util.List;
@Component
@RequiredArgsConstructor
public class UnameChatButtonAggregate implements UiFormer {
private final SshService sshService;
@Override
public SendMessage uiForm(SendMessage message) {
List<List<InlineKeyboardButton>> keyboard = new ArrayList<>();
InlineKeyboardMarkup inlineKeyboardMarkup = new InlineKeyboardMarkup();
sshService.getSshServers().forEach(sshServer -> {
List<InlineKeyboardButton> keyboardRow = new ArrayList<>();
InlineKeyboardButton inlineKeyboardButton = new InlineKeyboardButton();
inlineKeyboardButton.setText(sshServer.getName());
inlineKeyboardButton.setCallbackData("uname: " + sshServer.getName());
keyboardRow.add(inlineKeyboardButton);
keyboard.add(keyboardRow);
});
if (sshService.getSshServers().size() > 1) {
List<InlineKeyboardButton> keyboardRow = new ArrayList<>();
InlineKeyboardButton inlineKeyboardButton = new InlineKeyboardButton();
inlineKeyboardButton.setText("Все сервера");
inlineKeyboardButton.setCallbackData("uname: all");
keyboardRow.add(inlineKeyboardButton);
keyboard.add(keyboardRow);
}
inlineKeyboardMarkup.setKeyboard(keyboard);
message.setReplyMarkup(inlineKeyboardMarkup);
message.setText("Выполнить uname для");
return message;
}
}