тест коммита

Dockerfile

@@ -1,11 +0,0 @@
-# Используем официальный образ OpenJDK 17 как базовый образ
-FROM openjdk:17
-
-# Установка рабочей директории внутри контейнера
-WORKDIR /app
-
-# Копируем JAR-файл приложения из локальной директории внутрь контейнера
-COPY ServerMonitorBot-0.0.1-SNAPSHOT.jar app.jar
-
-# Команда для запуска Spring Boot приложения при старте контейнера
-CMD ["java", "-jar", "app.jar"]

Jenkinsfile_CD

@@ -1,71 +0,0 @@
-pipeline {
-    agent {
-        docker {
-            image 'maven:3.9.5-eclipse-temurin-17'
-            args '-v /root/.m2:/root/.m2'
-        }
-    }
-
-    environment {
-       SSH_HOST = credentials('ROCK_PI_5_SSH_HOST')
-       SSH_PORT = credentials('ROCK_PI_5_SSH_PORT')
-       SSH_USER = credentials('ROCK_PI_5_SSH_USER')
-       SSH_PASS = credentials('ROCK_PI_5_SSH_PASS')
-       PATH_TO_DEV_FOLDER = credentials('SERVERMONITORBOT_PATH_TO_DEV_FOLDER')
-       IMAGE_NAME = 'servermonitorbot'
-       IMAGE_VERSION = 'latest'
-    }
-
-    stages {
-        stage('Init container') {
-            steps {
-                sh 'apt-get update && apt-get install -y sshpass openssh-client'
-            }
-        }
-        stage('Build') {
-            steps {
-                withCredentials([file(credentialsId: 'SERVERMONITORBOT_APPLICATION_YAML', variable: 'application_yaml')]) {
-                   sh "cp -f \$application_yaml src/main/resources/application.yml"
-                }
-                sh 'mvn -B -DskipTests -X clean package spring-boot:repackage'
-            }
-        }
-        stage('Stop container') {
-            steps {
-                sh """
-                    sshpass -p ${SSH_PASS} ssh -o StrictHostKeyChecking=no ${SSH_USER}@${SSH_HOST} -p ${SSH_PORT} 'cd ${PATH_TO_DEV_FOLDER} && docker compose down'
-                """
-            }
-        }
-        stage('Remove old image') {
-            steps {
-                sh """
-                    sshpass -p ${SSH_PASS} ssh -o StrictHostKeyChecking=no ${SSH_USER}@${SSH_HOST} -p ${SSH_PORT} 'docker image rm -f ${IMAGE_NAME}-app:${IMAGE_VERSION} || true'
-                """
-            }
-        }
-        stage('Deploy') {
-            steps {
-                script {
-                    sh """
-                        sshpass -p ${SSH_PASS} ssh -o StrictHostKeyChecking=no ${SSH_USER}@${SSH_HOST} -p ${SSH_PORT} 'mkdir -p ${PATH_TO_DEV_FOLDER}'
-                        sshpass -p ${SSH_PASS} ssh -o StrictHostKeyChecking=no ${SSH_USER}@${SSH_HOST} -p ${SSH_PORT} 'rm -f ${PATH_TO_DEV_FOLDER}/{*.*}'
-                        sshpass -p ${SSH_PASS} scp -o StrictHostKeyChecking=no -P ${SSH_PORT} target/*.jar ${SSH_USER}@${SSH_HOST}:${PATH_TO_DEV_FOLDER}/
-                        sshpass -p ${SSH_PASS} scp -o StrictHostKeyChecking=no -P ${SSH_PORT} Dockerfile ${SSH_USER}@${SSH_HOST}:${PATH_TO_DEV_FOLDER}/
-                        sshpass -p ${SSH_PASS} scp -o StrictHostKeyChecking=no -P ${SSH_PORT} docker-compose.yml ${SSH_USER}@${SSH_HOST}:${PATH_TO_DEV_FOLDER}/
-                        sshpass -p ${SSH_PASS} ssh -o StrictHostKeyChecking=no ${SSH_USER}@${SSH_HOST} -p ${SSH_PORT} 'cd ${PATH_TO_DEV_FOLDER} && docker build --no-cache -t ${IMAGE_NAME}:${IMAGE_VERSION} .'
-                        sshpass -p ${SSH_PASS} ssh -o StrictHostKeyChecking=no ${SSH_USER}@${SSH_HOST} -p ${SSH_PORT} 'cd ${PATH_TO_DEV_FOLDER} && docker compose up -d'
-                    """
-                }
-            }
-        }
-        stage('Remove useless images') {
-            steps {
-                sh """
-                    sshpass -p ${SSH_PASS} ssh -o StrictHostKeyChecking=no ${SSH_USER}@${SSH_HOST} -p ${SSH_PORT} 'docker image prune --all --force'
-                """
-            }
-        }
-    }
-}
-

Jenkinsfile_CI

@@ -1,15 +0,0 @@
-pipeline {
-    agent {
-        docker {
-            image 'maven:3.9.5-eclipse-temurin-17'
-            args '-v /root/.m2:/root/.m2'
-        }
-    }
-    stages {
-        stage('Build') {
-            steps {
-                sh 'mvn -B -DskipTests -X clean package spring-boot:repackage'
-            }
-        }
-    }
-}

docker-compose.yml

@@ -1,23 +0,0 @@
-version: '3'
-services:
-  app:
-    build:
-      context: .
-    depends_on:
-      - db
-    restart: always
-    networks:
-      default:
-
-  db:
-    image: postgres:latest
-    environment:
-      POSTGRES_USER: servermonitorbot
-      POSTGRES_PASSWORD: servermonitorbot
-      POSTGRES_DB: servermonitorbot
-    restart: always
-    networks:
-      default:
-
-networks:
-  default:

pom.xml

@@ -15,11 +15,6 @@
     <description>ServerMonitorBot</description>
     <properties>
         <java.version>17</java.version>
-        <flyway.version>9.16.0</flyway.version>
-        <db.url>${database.url}</db.url>
-        <db.user>${database.username}</db.user>
-        <db.password>${database.password}</db.password>
-        <start-class>ru.ldeloff.servermonitorbot.ServerMonitorBotApplication</start-class>
     </properties>
     <dependencies>
         <dependency>
@@ -45,7 +40,7 @@
         <dependency>
             <groupId>org.telegram</groupId>
             <artifactId>telegrambots</artifactId>
-            <version>6.8.0</version>
+            <version>6.7.0</version>
         </dependency>
         <dependency>
             <groupId>com.jcraft</groupId>
@@ -57,13 +52,12 @@
             <artifactId>spring-boot-starter-data-jpa</artifactId>
         </dependency>
         <dependency>
-            <groupId>org.postgresql</groupId>
+            <groupId>org.liquibase</groupId>
-            <artifactId>postgresql</artifactId>
+            <artifactId>liquibase-core</artifactId>
         </dependency>
         <dependency>
-            <groupId>org.flywaydb</groupId>
+            <groupId>org.postgresql</groupId>
-            <artifactId>flyway-core</artifactId>
+            <artifactId>postgresql</artifactId>
-            <version>${flyway.version}</version>
         </dependency>
     </dependencies>
 
@@ -81,39 +75,6 @@
                     </excludes>
                 </configuration>
             </plugin>
-            <plugin>
-                <groupId>org.flywaydb</groupId>
-                <artifactId>flyway-maven-plugin</artifactId>
-                <version>${flyway.version}</version>
-                <executions>
-                    <execution>
-                        <id>migrate</id>
-                        <phase>deploy</phase>
-                        <goals>
-                            <goal>migrate</goal>
-                        </goals>
-                    </execution>
-                </executions>
-                <configuration>
-                    <url>${database.url}</url>
-                    <user>${database.username}</user>
-                    <password>${database.password}</password>
-                    <locations>
-                        <location>classpath:db/migration</location>
-                    </locations>
-                </configuration>
-            </plugin>
-            <plugin>
-                <groupId>org.springframework.boot</groupId>
-                <artifactId>spring-boot-maven-plugin</artifactId>
-                <executions>
-                    <execution>
-                        <goals>
-                            <goal>repackage</goal>
-                        </goals>
-                    </execution>
-                </executions>
-            </plugin>
         </plugins>
     </build>
 

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

@@ -1,42 +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.objects.Message;
 import org.telegram.telegrambots.meta.api.objects.Update;
 import ru.ldeloff.servermonitorbot.model.TelegramBot;
 import ru.ldeloff.servermonitorbot.repository.SshRepository;
-import ru.ldeloff.servermonitorbot.service.command.CommandTemplate;
+import ru.ldeloff.servermonitorbot.service.command.FirstUseCommand;
+import ru.ldeloff.servermonitorbot.service.command.GetStatusSessions;
 import ru.ldeloff.servermonitorbot.service.command.SwitchToMainMenu;
-
+import ru.ldeloff.servermonitorbot.service.command.cputemp.CpuTempAggregateCommand;
-import java.util.Map;
+import ru.ldeloff.servermonitorbot.service.command.cputemp.CpuTempCommand;
+import ru.ldeloff.servermonitorbot.service.command.hddtemp.HddTempAggregateCommand;
+import ru.ldeloff.servermonitorbot.service.command.hddtemp.HddTempCommand;
+import ru.ldeloff.servermonitorbot.service.command.uname.UnameAggregateCommand;
+import ru.ldeloff.servermonitorbot.service.command.uname.UnameCommand;
 
 @Service
+@Slf4j
 @RequiredArgsConstructor
 public class TelegramBotController extends TelegramLongPollingBot {
-    private final Map<String, CommandTemplate> commands;
     final TelegramBot telegramBot;
     final SshRepository sshRepository;
+
+    final FirstUseCommand firstUseCommand;
+    final GetStatusSessions getStatusSessions;
+    final UnameAggregateCommand unameAggregateCommand;
     final SwitchToMainMenu switchToMainMenu;
+    final UnameCommand unameCommand;
+    final CpuTempAggregateCommand cpuTempAggregateCommand;
+    final CpuTempCommand cpuTempCommand;
+    final HddTempAggregateCommand hddTempAggregateCommand;
+    final HddTempCommand hddTempCommand;
+
     @Override
     public void onUpdateReceived(Update update) {
-        boolean result = false;
+        if (update.hasMessage()) {
-        for (Map.Entry<String, CommandTemplate> entry : commands.entrySet()) {
+            if (update.getMessage().hasText()) {
-            result = entry.getValue().execute(update, this);
+                String messageText = update.getMessage().getText();
-            if (result) {
+                switch (messageText) {
-                break;
+                    case "/start" -> {
+                        firstUseCommand.execute(update, this);
                     }
+                    case "Статус" -> {
+                        getStatusSessions.execute(update, this);
                     }
-        if (!result) {
+                    case "uname" -> {
-            Message message = update.getMessage();
+                        unameAggregateCommand.execute(update, this);
-            if (message!=null) {
-                message.setText("Not found");
                     }
-            update.setMessage(message);
+                    case "CPU.temp" -> {
+                        cpuTempAggregateCommand.execute(update, this);
+                    }
+                    case "HDD.temp" -> {
+                        hddTempAggregateCommand.execute(update, this);
+                    }
+                    default -> {
                         switchToMainMenu.execute(update, this);
                     }
                 }
+            }
+        } else if (update.hasCallbackQuery()) {
+            String [] tags = update.getCallbackQuery().getData().split(":");
+            if (tags.length > 1) {
+                switch (tags[0]) {
+                    case "uname" -> {
+                        unameCommand.execute(update, this);
+                    }
+                    case "CPU.temp" -> {
+                        cpuTempCommand.execute(update, this);
+                    }
+                    case "HDD.temp" -> {
+                        hddTempCommand.execute(update, this);
+                    }
+                    default -> {
+                        switchToMainMenu.execute(update, this);
+                    }
+                }
+            } else {
+                switchToMainMenu.execute(update, this);
+            }
+        }
+    }
     @Override
     public String getBotUsername() {
         return telegramBot.getBotUsername();

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

@@ -1,7 +0,0 @@
-package ru.ldeloff.servermonitorbot.init;
-
-public class AddCommands {
-    public static void fillCommandTable() {
-        
-    }
-}

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

@@ -7,47 +7,30 @@ import org.springframework.boot.ApplicationArguments;
 import org.springframework.boot.ApplicationRunner;
 import org.springframework.stereotype.Component;
 import org.telegram.telegrambots.meta.TelegramBotsApi;
-import org.telegram.telegrambots.meta.api.methods.send.SendMessage;
 import org.telegram.telegrambots.meta.exceptions.TelegramApiException;
 import org.telegram.telegrambots.updatesreceivers.DefaultBotSession;
 import ru.ldeloff.servermonitorbot.controller.TelegramBotController;
-import ru.ldeloff.servermonitorbot.model.User;
-import ru.ldeloff.servermonitorbot.service.command.CommandTemplate;
-import ru.ldeloff.servermonitorbot.service.user.UserService;
-import ru.ldeloff.servermonitorbot.utils.ui.TelegramBotKeyboard;
-
-import static ru.ldeloff.servermonitorbot.init.AddCommands.fillCommandTable;
 
 @Slf4j
 @Component
 @NoArgsConstructor
 public class StartBot implements ApplicationRunner {
     private TelegramBotController telegramBot;
-    private TelegramBotKeyboard telegramBotKeyboard;
-    private UserService userService;
 
     @Autowired
-    public StartBot(TelegramBotController telegramBot, TelegramBotKeyboard telegramBotKeyboard, UserService userService) {
+    public StartBot(TelegramBotController telegramBot) {
         this.telegramBot = telegramBot;
-        this.telegramBotKeyboard = telegramBotKeyboard;
-        this.userService = userService;
     }
+
     @Override
     public void run(ApplicationArguments args) {
         try {
-            fillCommandTable();
             TelegramBotsApi botsApi = new TelegramBotsApi(DefaultBotSession.class);
             botsApi.registerBot(telegramBot);
-            userService.getAllUsers().forEach(this::SendInitMessage);
             log.info("Бот запущен");
         } catch (TelegramApiException e) {
+            e.printStackTrace();
             log.error(e.getMessage());
         }
     }
-    private void SendInitMessage(User user) {
-        SendMessage answer = new SendMessage();
-        answer.setChatId(user.getTelegramId());
-        answer.setText("Бот перезапущен");
-        CommandTemplate.sendMessage(telegramBotKeyboard.uiForm(answer), telegramBot);
-    }
 }

src/main/java/ru/ldeloff/servermonitorbot/model/Command.java

@@ -7,7 +7,7 @@ import lombok.Setter;
 
 @Getter
 @Setter
-public class SshCommand {
+public class Command {
     @NotNull
     private String command;
     @NotNull
@@ -17,7 +17,7 @@ public class SshCommand {
     private SshServer sshServer;
     private String response;
 
-    public SshCommand(String command, int timeout, SshServer sshServer) {
+    public Command(String command, int timeout, SshServer sshServer) {
         this.command = command;
         this.timeout = timeout;
         this.sshServer = sshServer;

src/main/java/ru/ldeloff/servermonitorbot/model/CommandList.java

@@ -1,28 +0,0 @@
-package ru.ldeloff.servermonitorbot.model;
-
-
-import jakarta.annotation.PostConstruct;
-import lombok.Getter;
-import lombok.RequiredArgsConstructor;
-import org.springframework.stereotype.Component;
-import ru.ldeloff.servermonitorbot.service.command.CommandTemplate;
-import ru.ldeloff.servermonitorbot.utils.CommandUtil;
-
-import java.util.HashMap;
-import java.util.Map;
-
-@Component
-@RequiredArgsConstructor
-public class CommandList {
-    private final Map<String, CommandTemplate> services;
-    @Getter
-    private HashMap<String, Long> commands;
-    @PostConstruct
-    private void setCommands() {
-        commands = new HashMap<>();
-        for (Map.Entry<String, CommandTemplate> entry : services.entrySet()) {
-            commands.put(entry.getValue().getName(), entry.getValue().getExpectedRole());
-        }
-        CommandUtil.setCommands(commands);
-    }
-}

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

@@ -5,13 +5,14 @@ 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.beans.factory.annotation.Value;
 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.*;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Objects;
 
 @Slf4j
 @Repository
@@ -19,15 +20,12 @@ public class SshRepositoryImpl implements SshRepository {
 
     private final List<SshServer> sshServers;
 
-    @Value("${ssh.timeout:5000}")
-    private int TIMEOUT;
-
     @Autowired
     public SshRepositoryImpl(SshConfig sshConfig) {
         this.sshServers = sshConfig.getServers();
     }
 
-    private Set<Session> sessions = new HashSet<>();
+    private List<Session> sessions = new ArrayList<>();
 
     @Override
     public void connectToAllServer() {
@@ -36,6 +34,7 @@ public class SshRepositoryImpl implements SshRepository {
                 Session session = connectToServer(sshServer);
                 sshServer.setSession(session);
                 log.info("Успешно подключён к " + sshServer.getHost());
+                sessions.add(session);
             } catch (JSchException e) {
                 log.warn("Не удалось соединиться с " + sshServer.getHost() + ": " + e.getMessage());
             }
@@ -49,9 +48,7 @@ public class SshRepositoryImpl implements SshRepository {
                 sshServer.getPort());
         session.setPassword(sshServer.getPassword());
         session.setConfig("StrictHostKeyChecking", "no");
-        session.setTimeout(TIMEOUT);
         session.connect();
-        sessions.add(session);
         return session;
     }
 
@@ -65,7 +62,7 @@ public class SshRepositoryImpl implements SshRepository {
 
     @Override
     public String getStatusSessions() {
-        StringBuilder text = new StringBuilder("Статус соединения (может выполняться долго): \n");
+        StringBuilder text = new StringBuilder("Статус соединения: \n");
         sshServers.forEach(server -> {
             text.append(server.getName())
                     .append(": ")
@@ -82,27 +79,10 @@ public class SshRepositoryImpl implements SshRepository {
 
     private String checkStatusServer(SshServer server) {
         if (Objects.isNull(server.getSession())) {
-            try {
-                connectToServer(server);
-                return "OK";
-            } catch (JSchException e) {
-                log.warn("Не удалось соединиться с " + server.getHost() + ": " + e.getMessage());
             return "нет соединения";
-            }
-        }
-
-        if (server.getSession().isConnected()) {
-            return "OK";
         } else {
-            try {
+            return server.getSession().isConnected() ? "OK" : "отключён";
-                connectToServer(server);
-                return "OK";
-            } catch (JSchException e) {
-                log.warn("Не удалось соединиться с " + server.getHost() + ": " + e.getMessage());
-                return "потеряно соединение";
         }
     }
 
 }
-
-}

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

@@ -1,15 +1,10 @@
 package ru.ldeloff.servermonitorbot.repository;
 
-import jakarta.validation.constraints.NotNull;
-import org.springframework.data.domain.Example;
 import org.springframework.data.jpa.repository.JpaRepository;
 import org.springframework.stereotype.Repository;
 import ru.ldeloff.servermonitorbot.model.User;
 
-import java.util.List;
-
 @Repository
 public interface UserRepository extends JpaRepository<User, Long> {
     User getByTelegramId(long id);
-    @NotNull List<User> findAll();
 }

src/main/java/ru/ldeloff/servermonitorbot/service/command/CommandTemplate.java

@@ -1,158 +1,53 @@
 package ru.ldeloff.servermonitorbot.service.command;
 
-import lombok.Getter;
+import lombok.Data;
 import lombok.RequiredArgsConstructor;
-import lombok.Setter;
 import lombok.extern.slf4j.Slf4j;
 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.SshServer;
 import ru.ldeloff.servermonitorbot.model.User;
 import ru.ldeloff.servermonitorbot.service.role.RoleService;
-import ru.ldeloff.servermonitorbot.service.ssh.SshService;
 import ru.ldeloff.servermonitorbot.service.user.UserService;
-import ru.ldeloff.servermonitorbot.utils.SshServerUtils;
-import ru.ldeloff.servermonitorbot.utils.ui.ServerListButtons;
-
-import java.util.Arrays;
-import java.util.List;
-import java.util.Objects;
 
+@Data
 @Slf4j
 @RequiredArgsConstructor
 public abstract class CommandTemplate {
-    private final UserService userService;
+    final UserService userService;
-    private final RoleService roleService;
+    final RoleService roleService;
-    private final ServerListButtons serverListButtons;
+    long expectedRole = 2L;
-    private final SshService sshService;
+    public abstract SendMessage actionForAuth(User user, SendMessage message);
-    @Getter
-    @Setter
-    private long expectedRole = 1L;
-    @Getter
-    @Setter
-    private String name;
 
-    public boolean execute(Update update, TelegramBotController bot) {
+    public SendMessage actionForNotAuth(User user, SendMessage message) {
-        if (!isExecute(update)) {
+        message.setText("У пользователя " + user.getLogin() + " (" + user.getTelegramId()
-            return false;
+                + ") недостаточно прав для выполнения этой команды");
+        return message;
     }
-
+    public void execute(Update update, TelegramBotController bot) {
         User user = getUser(update);
         String message = getMessage(update);
         SendMessage answer = new SendMessage();
         answer.setChatId(user.getTelegramId());
         answer.setText(message);
-
+        if (user.getRole().getId() <= expectedRole) {
-        if (!isAuth(update)) {
+            logSuccess(user, message);
+            sendMessage(actionForAuth(user, answer), bot);
+        } else {
             logNotAuth(user, message);
             sendMessage(actionForNotAuth(user, answer), bot);
-            return true;
-        }
-
-        String type = checkTypeCommand(update);
-        switch (type) {
-            case "aggregate":
-                logSuccess(user, message);
-                sendMessage(executeAggregate(user, answer), bot);
-                return true;
-            case "command":
-                logSuccess(user, message);
-                sendMessage(executeCommand(user, answer), bot);
-                return true;
-            default:
-                return false;
         }
     }
-
+    protected void logSuccess(User user, String message) {
-    // Методы для проверки команды
-    private boolean isExecute(Update update) {
-        if (update.hasMessage()) {
-            if (update.getMessage().hasText()) {
-                String messageText = update.getMessage().getText();
-                if (Objects.equals(messageText, name)) {
-                    log.debug("Команда " + messageText + " будет выполнена");
-                    return true;
-                }
-            }
-        } else if (update.hasCallbackQuery()) {
-            String [] tags = update.getCallbackQuery().getData().split(":");
-            if (tags.length > 1) {
-                if (Objects.equals(tags[0], name)) {
-                    log.debug("Команда " + tags[0] + " будет выполнена");
-                    return true;
-                }
-            } else {
-                log.debug("Команда не будет выполнена");
-                return false;
-            }
-        }
-        log.debug("Команда не будет выполнена");
-        return false;
-    }
-    private String checkTypeCommand(Update update) {
-        if (update.hasMessage()) {
-            if (update.getMessage().hasText()) {
-                return "aggregate";
-            }
-        } else if (update.hasCallbackQuery()) {
-            String [] tags = update.getCallbackQuery().getData().split(":");
-            if (tags.length > 1) {
-                return "command";
-            } else {
-                return "error";
-            }
-        }
-        return "error";
-    }
-    private boolean isAuth(Update update) {
-        User user = getUser(update);
-        return user.getRole().getId() <= expectedRole;
-    }
-
-    // Методы при верных условиях
-    void logSuccess(User user, String message) {
         log.info("Получена команда '" + message + "' от " + user.getLogin()
                 + " (" + user.getTelegramId() + "). OK");
     }
-    SendMessage executeAggregate(User user, SendMessage message) {
+    protected void logNotAuth(User user, String message) {
-        return serverListButtons.uiForm(message);
-    }
-    SendMessage executeCommand(User user, SendMessage message) {
-        String [] tags = Arrays.stream(message.getText().split(":"))
-                .map(String::trim)
-                .toArray(String[]::new);
-
-        if (tags[1].equals("all")) {
-            message.setText(executeCommandAllHost());
-        } else {
-            message.setText(Objects.requireNonNull(executeCommandSpecificHost(tags[1])));
-        }
-        return message;
-    }
-    private String executeCommandAllHost() {
-        List<SshServer> servers = SshServerUtils.filterGoodServers(sshService.getSshServers());
-        StringBuilder response = new StringBuilder();
-        servers.forEach(server -> response.append(executeCommandSpecificHost(server.getName())).append("\n"));
-        return response.toString();
-    }
-    public abstract String executeCommandSpecificHost(String serverName);
-
-    // Методы при неверных условиях
-    void logNotAuth(User user, String message) {
         log.warn("Получена команда '" + message + "' от " + user.getLogin()
                 + " (" + user.getTelegramId() + "). Нет прав");
     }
-    private SendMessage actionForNotAuth(User user, SendMessage message) {
+    private User getUser(Update update) {
-        message.setText("У пользователя " + user.getLogin() + " (" + user.getTelegramId()
-                + ") недостаточно прав для выполнения этой команды");
-        return message;
-    }
-
-    // Общее
-    // TODO: вынести в UpdateUtils
-    User getUser(Update update) {
         long id = -1L;
         String login = null;
         if (update.hasMessage()) {
@@ -171,7 +66,8 @@ public abstract class CommandTemplate {
         user.setLogin(login);
         return user;
     }
-    String getMessage(Update update) {
+
+    private String getMessage(Update update) {
         if (update.hasMessage()) {
             return update.getMessage().getText();
         } else if (update.hasCallbackQuery()) {
@@ -180,8 +76,7 @@ public abstract class CommandTemplate {
         return "";
     }
 
-    // TODO: вынести
+    private void sendMessage(SendMessage message, TelegramBotController bot) {
-    public static void sendMessage(SendMessage message, TelegramBotController bot) {
         try {
             bot.execute(message);
         } catch (TelegramApiException e) {

src/main/java/ru/ldeloff/servermonitorbot/service/command/CpuTempCommand.java

@@ -1,43 +0,0 @@
-package ru.ldeloff.servermonitorbot.service.command;
-
-import lombok.extern.slf4j.Slf4j;
-import org.springframework.stereotype.Service;
-import ru.ldeloff.servermonitorbot.model.SshCommand;
-import ru.ldeloff.servermonitorbot.model.SshServer;
-import ru.ldeloff.servermonitorbot.service.role.RoleService;
-import ru.ldeloff.servermonitorbot.service.ssh.SshService;
-import ru.ldeloff.servermonitorbot.service.user.UserService;
-import ru.ldeloff.servermonitorbot.utils.ui.ServerListButtons;
-
-import java.util.Objects;
-import java.util.Optional;
-
-@Service
-@Slf4j
-public class CpuTempCommand extends CommandTemplate {
-    final SshService sshService;
-    public CpuTempCommand(UserService userService, RoleService roleService, SshService sshService, ServerListButtons serverListButtons) {
-        super(userService, roleService, serverListButtons, sshService);
-        this.sshService = sshService;
-        setName("CPU.temp");
-    }
-
-    @Override
-    public String executeCommandSpecificHost(String serverName) {
-        Optional<SshServer> server = sshService.getSshServers()
-                .stream()
-                .filter(x -> x.getName().equals(serverName))
-                .findFirst();
-        if (server.isPresent()) {
-            SshCommand result = sshService.execute(new SshCommand("cat /sys/class/thermal/thermal_zone0/temp", 100, server.get()));
-            return server.get().getName() + ": \n" +
-                    (Objects.isNull(result.getResponse()) ? "ошибка при выполнении команды" :
-                            String.format("%.1f",
-                                    Double.parseDouble(result.getResponse().replaceAll("\n", ""))/1000))
-                    + "°C";
-        } else {
-            log.error("Ошибка при выполнении команды 'CPUtemp'. Искомый сервер (" + serverName + ") не найден");
-            return null;
-        }
-    }
-}

src/main/java/ru/ldeloff/servermonitorbot/service/command/FirstUseCommand.java

@@ -2,36 +2,22 @@ package ru.ldeloff.servermonitorbot.service.command;
 
 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.User;
 import ru.ldeloff.servermonitorbot.service.role.RoleService;
-import ru.ldeloff.servermonitorbot.service.ssh.SshService;
 import ru.ldeloff.servermonitorbot.service.user.UserService;
-import ru.ldeloff.servermonitorbot.utils.ui.ServerListButtons;
 import ru.ldeloff.servermonitorbot.utils.ui.TelegramBotKeyboard;
 
 @Service
 public class FirstUseCommand extends CommandTemplate {
     final TelegramBotKeyboard telegramBotKeyboard;
 
-    public FirstUseCommand(UserService userService,
+    public FirstUseCommand(UserService userService, RoleService roleService, TelegramBotKeyboard telegramBotKeyboard) {
-                           RoleService roleService,
+        super(userService, roleService);
-                           SshService sshService,
-                           ServerListButtons serverListButtons,
-                           TelegramBotKeyboard telegramBotKeyboard) {
-        super(userService, roleService, serverListButtons, sshService);
         this.telegramBotKeyboard = telegramBotKeyboard;
-        setName("/start");
     }
-
     @Override
-    public SendMessage executeAggregate(User user, SendMessage message) {
+    public SendMessage actionForAuth(User user, SendMessage message) {
         message.setText("Добро пожаловать " + user.getLogin() + "!");
         return telegramBotKeyboard.uiForm(message);
     }
-
-    @Override
-    public String executeCommandSpecificHost(String serverName) {
-        return null;
-    }
 }

src/main/java/ru/ldeloff/servermonitorbot/service/command/GetStatusSessions.java

@@ -6,22 +6,18 @@ import ru.ldeloff.servermonitorbot.model.User;
 import ru.ldeloff.servermonitorbot.service.role.RoleService;
 import ru.ldeloff.servermonitorbot.service.ssh.SshService;
 import ru.ldeloff.servermonitorbot.service.user.UserService;
-import ru.ldeloff.servermonitorbot.utils.ui.ServerListButtons;
 
 @Service
 public class GetStatusSessions extends CommandTemplate {
     final SshService sshService;
-    public GetStatusSessions(UserService userService, RoleService roleService, SshService sshService, ServerListButtons serverListButtons) {
+
-        super(userService, roleService, serverListButtons, sshService);
+    public GetStatusSessions(UserService userService, RoleService roleService, SshService sshService) {
+        super(userService, roleService);
         this.sshService = sshService;
-        setName("Статус");
     }
+
     @Override
-    public SendMessage executeAggregate(User user, SendMessage message) {
+    public SendMessage actionForAuth(User user, SendMessage message) {
         return sshService.getStatusSessions(message);
     }
-    @Override
-    public String executeCommandSpecificHost(String serverName) {
-        return null;
-    }
 }

src/main/java/ru/ldeloff/servermonitorbot/service/command/HddTempCommand.java

@@ -1,39 +0,0 @@
-package ru.ldeloff.servermonitorbot.service.command;
-
-import lombok.extern.slf4j.Slf4j;
-import org.springframework.stereotype.Service;
-import ru.ldeloff.servermonitorbot.model.SshCommand;
-import ru.ldeloff.servermonitorbot.model.SshServer;
-import ru.ldeloff.servermonitorbot.service.role.RoleService;
-import ru.ldeloff.servermonitorbot.service.ssh.SshService;
-import ru.ldeloff.servermonitorbot.service.user.UserService;
-import ru.ldeloff.servermonitorbot.utils.ui.ServerListButtons;
-
-import java.util.Objects;
-import java.util.Optional;
-
-@Service
-@Slf4j
-public class HddTempCommand extends CommandTemplate {
-    final SshService sshService;
-    public HddTempCommand(UserService userService, RoleService roleService, SshService sshService, ServerListButtons serverListButtons) {
-        super(userService, roleService, serverListButtons, sshService);
-        this.sshService = sshService;
-        setName("HDD.temp");
-    }
-    @Override
-    public String executeCommandSpecificHost(String serverName) {
-        Optional<SshServer> server = sshService.getSshServers()
-                .stream()
-                .filter(x -> x.getName().equals(serverName))
-                .findFirst();
-        if (server.isPresent()) {
-            SshCommand result = sshService.execute(new SshCommand("hddtemp /dev/sd*", 500, server.get()));
-            return server.get().getName() + ": \n" +
-                    (Objects.isNull(result.getResponse()) ? "ошибка при выполнении команды" : result.getResponse());
-        } else {
-            log.error("Ошибка при выполнении команды 'hddtemp'. Искомый сервер (" + serverName + ") не найден");
-            return null;
-        }
-    }
-}

src/main/java/ru/ldeloff/servermonitorbot/service/command/MdadmStatusCommand.java

@@ -1,84 +0,0 @@
-package ru.ldeloff.servermonitorbot.service.command;
-
-import lombok.extern.slf4j.Slf4j;
-import org.springframework.stereotype.Service;
-import ru.ldeloff.servermonitorbot.model.SshCommand;
-import ru.ldeloff.servermonitorbot.model.SshServer;
-import ru.ldeloff.servermonitorbot.service.role.RoleService;
-import ru.ldeloff.servermonitorbot.service.ssh.SshService;
-import ru.ldeloff.servermonitorbot.service.user.UserService;
-import ru.ldeloff.servermonitorbot.utils.ui.ServerListButtons;
-
-import java.util.*;
-
-@Service
-@Slf4j
-public class MdadmStatusCommand extends CommandTemplate {
-    final SshService sshService;
-    public MdadmStatusCommand(UserService userService, RoleService roleService, SshService sshService, ServerListButtons serverListButtons) {
-        super(userService, roleService, serverListButtons, sshService);
-        this.sshService = sshService;
-        setName("MDADM");
-    }
-    @Override
-    public String executeCommandSpecificHost(String serverName) {
-        Optional<SshServer> server = sshService.getSshServers()
-                .stream()
-                .filter(x -> x.getName().equals(serverName))
-                .findFirst();
-        if (server.isPresent()) {
-            // узнаю скок рейдов
-            SshCommand sshCommandRaid = sshService.execute(new SshCommand("mdadm --detail --scan", 500, server.get()));
-            List<String> raidNames = parseRaidNames(sshCommandRaid);
-            // Для каждого рейда надо выяснить статус
-            StringBuilder result = new StringBuilder();
-            raidNames.forEach(raid -> {
-                result.append(raid).append(":\n");
-                SshCommand sshCommandHdd = sshService.execute(new SshCommand("mdadm --detail " + raid, 500, server.get()));
-                List<String> hdds = parseHddState(sshCommandHdd);
-                hdds.forEach(hdd -> result.append(hdd).append("\n"));
-            });
-            return server.get().getName() + ": \n" + result;
-        } else {
-            log.error("Ошибка при выполнении команды 'mdadm'. Искомый сервер (" + serverName + ") не найден");
-            return null;
-        }
-    }
-    private List<String> parseRaidNames(SshCommand result) {
-        List<String> names = new ArrayList<>();
-        Arrays.stream(result.getResponse().split("\n"))
-                .map(line -> line.split(" "))
-                .filter(lineArray -> lineArray.length >= 2)
-                .map(lineArray -> lineArray[1])
-                .forEach(names::add);
-        return names;
-    }
-    private List<String> parseHddState(SshCommand result) {
-        List<String> names = new ArrayList<>();
-        names.add("Number Name State");
-
-        String[] lines = result.getResponse().split("\n");
-
-        boolean foundHeader = false;
-
-        for (String line : lines) {
-            if (!foundHeader) {
-                if ( line.contains("Number") &&
-                        line.contains("Major") &&
-                        line.contains("Minor") &&
-                        line.contains("RaidDevice") )  {
-                    foundHeader = true;
-                }
-            } else {
-                List<String> elements = Arrays.stream(line.split(" "))
-                        .filter(x -> !Objects.equals(x, "")).toList();
-
-                names.add(elements.get(0) + ", "
-                        + elements.get(6) + ", "
-                        + elements.get(4) + " "
-                        + elements.get(5));
-            }
-        }
-        return names;
-    }
-}

src/main/java/ru/ldeloff/servermonitorbot/service/command/SwitchToMainMenu.java

@@ -3,13 +3,9 @@ package ru.ldeloff.servermonitorbot.service.command;
 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.controller.TelegramBotController;
 import ru.ldeloff.servermonitorbot.model.User;
 import ru.ldeloff.servermonitorbot.service.role.RoleService;
-import ru.ldeloff.servermonitorbot.service.ssh.SshService;
 import ru.ldeloff.servermonitorbot.service.user.UserService;
-import ru.ldeloff.servermonitorbot.utils.ui.ServerListButtons;
 import ru.ldeloff.servermonitorbot.utils.ui.TelegramBotKeyboard;
 
 @Service
@@ -17,31 +13,23 @@ import ru.ldeloff.servermonitorbot.utils.ui.TelegramBotKeyboard;
 public class SwitchToMainMenu extends CommandTemplate {
     final TelegramBotKeyboard telegramBotKeyboard;
 
-    public SwitchToMainMenu(UserService userService,
+    public SwitchToMainMenu(UserService userService, RoleService roleService, TelegramBotKeyboard telegramBotKeyboard) {
-                            RoleService roleService,
+        super(userService, roleService);
-                            SshService sshService,
-                            ServerListButtons serverListButtons,
-                            TelegramBotKeyboard telegramBotKeyboard) {
-        super(userService, roleService, serverListButtons, sshService);
         this.telegramBotKeyboard = telegramBotKeyboard;
-        setName("Not found");
     }
     @Override
-    public String executeCommandSpecificHost(String serverName) {
+    public SendMessage actionForAuth(User user, SendMessage message) {
-        return null;
+        message.setText("Неверная команда. Попробуем сначала.");
+        return telegramBotKeyboard.uiForm(message);
     }
-
     @Override
-    void logSuccess(User user, String message) {
+    public void logSuccess(User user, String message) {
         log.warn("Получена несуществующая команда '" + message + "' от " + user.getLogin()
                 + " (" + user.getTelegramId() + "). OK");
     }
     @Override
-    SendMessage executeAggregate(User user, SendMessage message) {
+    public void logNotAuth(User user, String message) {
-        SendMessage answer = new SendMessage();
+        log.warn("Получена несуществующая команда '" + message + "' от " + user.getLogin()
-        answer.setChatId(user.getTelegramId());
+                + " (" + user.getTelegramId() + "). Нет прав");
-        answer.setText("Неверная команда. Попробуем сначала.");
-        return telegramBotKeyboard.uiForm(answer);
     }
-
 }

src/main/java/ru/ldeloff/servermonitorbot/service/command/UnameCommand.java

@@ -1,39 +0,0 @@
-package ru.ldeloff.servermonitorbot.service.command;
-
-import lombok.extern.slf4j.Slf4j;
-import org.springframework.stereotype.Service;
-import ru.ldeloff.servermonitorbot.model.SshCommand;
-import ru.ldeloff.servermonitorbot.model.SshServer;
-import ru.ldeloff.servermonitorbot.service.role.RoleService;
-import ru.ldeloff.servermonitorbot.service.ssh.SshService;
-import ru.ldeloff.servermonitorbot.service.user.UserService;
-import ru.ldeloff.servermonitorbot.utils.ui.ServerListButtons;
-
-import java.util.Objects;
-import java.util.Optional;
-
-@Service
-@Slf4j
-public class UnameCommand extends CommandTemplate {
-    final SshService sshService;
-    public UnameCommand(UserService userService, RoleService roleService, SshService sshService, ServerListButtons serverListButtons) {
-        super(userService, roleService, serverListButtons, sshService);
-        this.sshService = sshService;
-        setName("uname");
-    }
-    @Override
-    public String executeCommandSpecificHost(String serverName) {
-        Optional<SshServer> server = sshService.getSshServers()
-                .stream()
-                .filter(x -> x.getName().equals(serverName))
-                .findFirst();
-        if (server.isPresent()) {
-            SshCommand result = sshService.execute(new SshCommand("uname -a", 100, server.get()));
-            return server.get().getName() + ": " +
-                    (Objects.isNull(result.getResponse()) ? "ошибка при выполнении команды" : result.getResponse());
-        } else {
-            log.error("Ошибка при выполнении команды 'uname'. Искомый сервер (" + serverName + ") не найден");
-            return null;
-        }
-    }
-}

src/main/java/ru/ldeloff/servermonitorbot/service/command/cputemp/CpuTempAggregateCommand.java

@@ -0,0 +1,24 @@
+package ru.ldeloff.servermonitorbot.service.command.cputemp;
+
+import org.springframework.stereotype.Service;
+import org.telegram.telegrambots.meta.api.methods.send.SendMessage;
+import ru.ldeloff.servermonitorbot.model.User;
+import ru.ldeloff.servermonitorbot.service.command.CommandTemplate;
+import ru.ldeloff.servermonitorbot.service.role.RoleService;
+import ru.ldeloff.servermonitorbot.service.user.UserService;
+import ru.ldeloff.servermonitorbot.utils.ui.uname.ServerListButtons;
+
+@Service
+public class CpuTempAggregateCommand extends CommandTemplate {
+    final ServerListButtons serverListButtons;
+
+    public CpuTempAggregateCommand(UserService userService, RoleService roleService, ServerListButtons serverListButtons) {
+        super(userService, roleService);
+        this.serverListButtons = serverListButtons;
+    }
+
+    @Override
+    public SendMessage actionForAuth(User user, SendMessage message) {
+        return serverListButtons.uiForm(message);
+    }
+}

src/main/java/ru/ldeloff/servermonitorbot/service/command/cputemp/CpuTempCommand.java

@@ -0,0 +1,67 @@
+package ru.ldeloff.servermonitorbot.service.command.cputemp;
+
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Service;
+import org.telegram.telegrambots.meta.api.methods.send.SendMessage;
+import ru.ldeloff.servermonitorbot.model.Command;
+import ru.ldeloff.servermonitorbot.model.SshServer;
+import ru.ldeloff.servermonitorbot.model.User;
+import ru.ldeloff.servermonitorbot.service.command.CommandTemplate;
+import ru.ldeloff.servermonitorbot.service.role.RoleService;
+import ru.ldeloff.servermonitorbot.service.ssh.SshService;
+import ru.ldeloff.servermonitorbot.service.user.UserService;
+import ru.ldeloff.servermonitorbot.utils.SshServerUtils;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.Objects;
+import java.util.Optional;
+
+@Service
+@Slf4j
+public class CpuTempCommand extends CommandTemplate {
+    final SshService sshService;
+    public CpuTempCommand(UserService userService, RoleService roleService, SshService sshService) {
+        super(userService, roleService);
+        this.sshService = sshService;
+    }
+
+    @Override
+    public SendMessage actionForAuth(User user, SendMessage message) {
+        String [] tags = Arrays.stream(message.getText().split(":"))
+                .map(String::trim)
+                .toArray(String[]::new);
+
+        if (tags[1].equals("all")) {
+            message.setText(hddTempAllHost());
+        } else {
+            message.setText(Objects.requireNonNull(hddTempSpecificHost(tags[1])));
+        }
+        return message;
+    }
+
+    private String hddTempAllHost() {
+        List<SshServer> servers = SshServerUtils.filterGoodServers(sshService.getSshServers());
+        StringBuilder response = new StringBuilder();
+        servers.forEach(server -> response.append(hddTempSpecificHost(server.getName())).append("\n"));
+        return response.toString();
+    }
+
+    private String hddTempSpecificHost(String serverName) {
+        Optional<SshServer> server = sshService.getSshServers()
+                .stream()
+                .filter(x -> x.getName().equals(serverName))
+                .findFirst();
+        if (server.isPresent()) {
+            Command result = sshService.execute(new Command("cat /sys/class/thermal/thermal_zone0/temp", 100, server.get()));
+            return server.get().getName() + ": \n" +
+                    (Objects.isNull(result.getResponse()) ? "ошибка при выполнении команды" :
+                            String.format("%.1f",
+                                    Double.parseDouble(result.getResponse().replaceAll("\n", ""))/1000))
+                    + "°C";
+        } else {
+            log.error("Ошибка при выполнении команды 'CPUtemp'. Искомый сервер (" + serverName + ") не найден");
+            return null;
+        }
+    }
+}

src/main/java/ru/ldeloff/servermonitorbot/service/command/hddtemp/HddTempAggregateCommand.java

@@ -0,0 +1,24 @@
+package ru.ldeloff.servermonitorbot.service.command.hddtemp;
+
+import org.springframework.stereotype.Service;
+import org.telegram.telegrambots.meta.api.methods.send.SendMessage;
+import ru.ldeloff.servermonitorbot.model.User;
+import ru.ldeloff.servermonitorbot.service.command.CommandTemplate;
+import ru.ldeloff.servermonitorbot.service.role.RoleService;
+import ru.ldeloff.servermonitorbot.service.user.UserService;
+import ru.ldeloff.servermonitorbot.utils.ui.uname.ServerListButtons;
+
+@Service
+public class HddTempAggregateCommand extends CommandTemplate {
+    final ServerListButtons serverListButtons;
+
+    public HddTempAggregateCommand(UserService userService, RoleService roleService, ServerListButtons serverListButtons) {
+        super(userService, roleService);
+        this.serverListButtons = serverListButtons;
+    }
+
+    @Override
+    public SendMessage actionForAuth(User user, SendMessage message) {
+        return serverListButtons.uiForm(message);
+    }
+}

src/main/java/ru/ldeloff/servermonitorbot/service/command/hddtemp/HddTempCommand.java

@@ -0,0 +1,64 @@
+package ru.ldeloff.servermonitorbot.service.command.hddtemp;
+
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Service;
+import org.telegram.telegrambots.meta.api.methods.send.SendMessage;
+import ru.ldeloff.servermonitorbot.model.Command;
+import ru.ldeloff.servermonitorbot.model.SshServer;
+import ru.ldeloff.servermonitorbot.model.User;
+import ru.ldeloff.servermonitorbot.service.command.CommandTemplate;
+import ru.ldeloff.servermonitorbot.service.role.RoleService;
+import ru.ldeloff.servermonitorbot.service.ssh.SshService;
+import ru.ldeloff.servermonitorbot.service.user.UserService;
+import ru.ldeloff.servermonitorbot.utils.SshServerUtils;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.Objects;
+import java.util.Optional;
+
+@Service
+@Slf4j
+public class HddTempCommand extends CommandTemplate {
+    final SshService sshService;
+    public HddTempCommand(UserService userService, RoleService roleService, SshService sshService) {
+        super(userService, roleService);
+        this.sshService = sshService;
+    }
+
+    @Override
+    public SendMessage actionForAuth(User user, SendMessage message) {
+        String [] tags = Arrays.stream(message.getText().split(":"))
+                .map(String::trim)
+                .toArray(String[]::new);
+
+        if (tags[1].equals("all")) {
+            message.setText(hddTempAllHost());
+        } else {
+            message.setText(Objects.requireNonNull(hddTempSpecificHost(tags[1])));
+        }
+        return message;
+    }
+
+    private String hddTempAllHost() {
+        List<SshServer> servers = SshServerUtils.filterGoodServers(sshService.getSshServers());
+        StringBuilder response = new StringBuilder();
+        servers.forEach(server -> response.append(hddTempSpecificHost(server.getName())).append("\n"));
+        return response.toString();
+    }
+
+    private String hddTempSpecificHost(String serverName) {
+        Optional<SshServer> server = sshService.getSshServers()
+                .stream()
+                .filter(x -> x.getName().equals(serverName))
+                .findFirst();
+        if (server.isPresent()) {
+            Command result = sshService.execute(new Command("hddtemp /dev/sd*", 500, server.get()));
+            return server.get().getName() + ": \n" +
+                    (Objects.isNull(result.getResponse()) ? "ошибка при выполнении команды" : result.getResponse());
+        } else {
+            log.error("Ошибка при выполнении команды 'hddtemp'. Искомый сервер (" + serverName + ") не найден");
+            return null;
+        }
+    }
+}

src/main/java/ru/ldeloff/servermonitorbot/service/command/uname/UnameAggregateCommand.java

@@ -0,0 +1,24 @@
+package ru.ldeloff.servermonitorbot.service.command.uname;
+
+import org.springframework.stereotype.Service;
+import org.telegram.telegrambots.meta.api.methods.send.SendMessage;
+import ru.ldeloff.servermonitorbot.model.User;
+import ru.ldeloff.servermonitorbot.service.command.CommandTemplate;
+import ru.ldeloff.servermonitorbot.service.role.RoleService;
+import ru.ldeloff.servermonitorbot.service.user.UserService;
+import ru.ldeloff.servermonitorbot.utils.ui.uname.ServerListButtons;
+
+@Service
+public class UnameAggregateCommand extends CommandTemplate {
+    final ServerListButtons serverListButtons;
+
+    public UnameAggregateCommand(UserService userService, RoleService roleService, ServerListButtons serverListButtons) {
+        super(userService, roleService);
+        this.serverListButtons = serverListButtons;
+    }
+
+    @Override
+    public SendMessage actionForAuth(User user, SendMessage message) {
+        return serverListButtons.uiForm(message);
+    }
+}

src/main/java/ru/ldeloff/servermonitorbot/service/command/uname/UnameCommand.java

@@ -0,0 +1,63 @@
+package ru.ldeloff.servermonitorbot.service.command.uname;
+
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Service;
+import org.telegram.telegrambots.meta.api.methods.send.SendMessage;
+import ru.ldeloff.servermonitorbot.model.Command;
+import ru.ldeloff.servermonitorbot.model.SshServer;
+import ru.ldeloff.servermonitorbot.model.User;
+import ru.ldeloff.servermonitorbot.service.command.CommandTemplate;
+import ru.ldeloff.servermonitorbot.service.role.RoleService;
+import ru.ldeloff.servermonitorbot.service.ssh.SshService;
+import ru.ldeloff.servermonitorbot.service.user.UserService;
+import ru.ldeloff.servermonitorbot.utils.SshServerUtils;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.Objects;
+import java.util.Optional;
+
+@Service
+@Slf4j
+public class UnameCommand extends CommandTemplate {
+    final SshService sshService;
+    public UnameCommand(UserService userService, RoleService roleService, SshService sshService) {
+        super(userService, roleService);
+        this.sshService = sshService;
+    }
+    @Override
+    public SendMessage actionForAuth(User user, SendMessage message) {
+        String [] tags = Arrays.stream(message.getText().split(":"))
+                .map(String::trim)
+                .toArray(String[]::new);
+
+        if (tags[1].equals("all")) {
+            message.setText(unameAllHost());
+        } else {
+            message.setText(Objects.requireNonNull(unameSpecificHost(tags[1])));
+        }
+        return message;
+    }
+
+    private String unameAllHost() {
+        List<SshServer> servers = SshServerUtils.filterGoodServers(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()) {
+            Command result = sshService.execute(new Command("uname -a", 100, server.get()));
+            return server.get().getName() + ": " +
+                    (Objects.isNull(result.getResponse()) ? "ошибка при выполнении команды" : result.getResponse());
+        } else {
+            log.error("Ошибка при выполнении команды 'uname'. Искомый сервер (" + serverName + ") не найден");
+            return null;
+        }
+    }
+}

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

@@ -2,7 +2,7 @@ package ru.ldeloff.servermonitorbot.service.ssh;
 
 
 import org.telegram.telegrambots.meta.api.methods.send.SendMessage;
-import ru.ldeloff.servermonitorbot.model.SshCommand;
+import ru.ldeloff.servermonitorbot.model.Command;
 import ru.ldeloff.servermonitorbot.model.SshServer;
 
 import java.util.List;
@@ -11,6 +11,6 @@ public interface SshService {
     SendMessage getStatusSessions(SendMessage update);
 
     List<SshServer> getSshServers();
-    SshCommand execute(SshCommand sshCommand);
+    Command execute(Command command);
-    List<SshCommand> execute(List<SshCommand> sshCommands);
+    List<Command> execute(List<Command> commands);
 }

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

@@ -7,7 +7,7 @@ import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.stereotype.Service;
 import org.telegram.telegrambots.meta.api.methods.send.SendMessage;
-import ru.ldeloff.servermonitorbot.model.SshCommand;
+import ru.ldeloff.servermonitorbot.model.Command;
 import ru.ldeloff.servermonitorbot.model.SshServer;
 import ru.ldeloff.servermonitorbot.repository.SshRepository;
 
@@ -31,21 +31,21 @@ public class SshServiceImpl implements SshService {
     }
 
     @Override
-    public SshCommand execute(SshCommand sshCommand) {
+    public Command execute(Command command) {
-        List<SshCommand> sshCommands = new ArrayList<>();
+        List<Command> commands = new ArrayList<>();
-        sshCommands.add(sshCommand);
+        commands.add(command);
-        return execute(sshCommands).get(0);
+        return execute(commands).get(0);
     }
 
     @Override
-    public List<SshCommand> execute(List<SshCommand> sshCommands) {
+    public List<Command> execute(List<Command> commands) {
-        Session session = sshCommands.get(0).getSshServer().getSession(); // подразумевается, что в листе с командами сервер один и тот же
+        Session session = commands.get(0).getSshServer().getSession(); // подразумевается, что в листе с командами сервер один и тот же
         ChannelExec channel = null;
         try {
             channel = (ChannelExec) session.openChannel("exec");
             ChannelExec finalChannel = channel;
 
-            sshCommands.forEach(command -> {
+            commands.forEach(command -> {
                 try {
                     finalChannel.setCommand(command.getCommand());
                     ByteArrayOutputStream responseStream = new ByteArrayOutputStream();
@@ -69,6 +69,6 @@ public class SshServiceImpl implements SshService {
                 channel.disconnect();
             }
         }
-        return sshCommands;
+        return commands;
     }
 }

src/main/java/ru/ldeloff/servermonitorbot/service/user/UserService.java

@@ -2,12 +2,8 @@ package ru.ldeloff.servermonitorbot.service.user;
 
 import ru.ldeloff.servermonitorbot.model.User;
 
-import java.util.List;
-
 public interface UserService {
     User saveOrUpdateUser(User user);
 
     User getByTelegramId(Long id);
-
-    List<User> getAllUsers();
 }

src/main/java/ru/ldeloff/servermonitorbot/service/user/UserServiceImpl.java

@@ -6,8 +6,6 @@ import org.springframework.stereotype.Service;
 import ru.ldeloff.servermonitorbot.model.User;
 import ru.ldeloff.servermonitorbot.repository.UserRepository;
 
-import java.util.List;
-
 @Service
 @RequiredArgsConstructor
 @Slf4j
@@ -28,7 +26,4 @@ public class UserServiceImpl implements UserService {
     public User getByTelegramId(Long id) {
         return userRepository.getByTelegramId(id);
     }
-
-    @Override
-    public List<User> getAllUsers() {return userRepository.findAll(); }
 }

src/main/java/ru/ldeloff/servermonitorbot/utils/CommandUtil.java

@@ -1,15 +0,0 @@
-package ru.ldeloff.servermonitorbot.utils;
-
-import lombok.Getter;
-import lombok.Setter;
-import lombok.experimental.UtilityClass;
-
-import java.util.HashMap;
-
-@UtilityClass
-public class CommandUtil {
-
-    @Setter
-    @Getter
-    private HashMap<String, Long> commands;
-}

src/main/java/ru/ldeloff/servermonitorbot/utils/RoleChecker.java

@@ -1,19 +0,0 @@
-package ru.ldeloff.servermonitorbot.utils;
-
-import lombok.RequiredArgsConstructor;
-import org.springframework.stereotype.Component;
-import org.telegram.telegrambots.meta.api.methods.send.SendMessage;
-import ru.ldeloff.servermonitorbot.model.Role;
-import ru.ldeloff.servermonitorbot.model.User;
-import ru.ldeloff.servermonitorbot.service.user.UserService;
-
-@RequiredArgsConstructor
-@Component
-public class RoleChecker {
-    final UserService userService;
-    public Role getRole(SendMessage sendMessage) {
-        String chatId = sendMessage.getChatId();
-        User user = userService.getByTelegramId(Long.parseLong(chatId));
-        return user.getRole();
-    }
-}

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

@@ -1,63 +1,40 @@
 package ru.ldeloff.servermonitorbot.utils.ui;
 
-import lombok.RequiredArgsConstructor;
 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 ru.ldeloff.servermonitorbot.model.CommandList;
-import ru.ldeloff.servermonitorbot.model.Role;
-import ru.ldeloff.servermonitorbot.service.command.CommandTemplate;
-import ru.ldeloff.servermonitorbot.utils.CommandUtil;
-import ru.ldeloff.servermonitorbot.utils.RoleChecker;
 
 
 import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.Map;
 
 @Component
-@RequiredArgsConstructor
 public class TelegramBotKeyboard implements UiFormer {
-    private final RoleChecker roleChecker;
+    private final String STATUS = "Статус";
+    private final String UNAME = "uname";
+    private final String CPU_TEMP = "CPU.temp";
+    private final String HDD_TEMP = "HDD.temp";
+
+
     @Override
     public SendMessage uiForm(SendMessage message) {
         ReplyKeyboardMarkup replyKeyboardMarkup = new ReplyKeyboardMarkup();
         replyKeyboardMarkup.setResizeKeyboard(true);
         replyKeyboardMarkup.setOneTimeKeyboard(false);
 
-        ArrayList<KeyboardRow> keyboardRows = formKeyboard(
+        ArrayList<KeyboardRow> keyboardRows = new ArrayList<>();
-                roleChecker.getRole(message).getId());
+
+        KeyboardRow keyboardRow = new KeyboardRow();
+        keyboardRows.add(keyboardRow);
+
+        keyboardRow.add(new KeyboardButton(STATUS));
+        keyboardRow.add(new KeyboardButton(UNAME));
+        keyboardRow.add(new KeyboardButton(CPU_TEMP));
+        keyboardRow.add(new KeyboardButton(HDD_TEMP));
 
         replyKeyboardMarkup.setKeyboard(keyboardRows);
         message.setReplyMarkup(replyKeyboardMarkup);
         return message;
     }
-
-    private ArrayList<KeyboardRow> formKeyboard(long role) {
-        HashMap<String, Long> commands = CommandUtil.getCommands();
-        if (role < 3) {
-            commands.remove("/start");
-            commands.remove("Not found");
-        }
-        int buttonOnLine = 3;
-
-        ArrayList<KeyboardRow> keyboardRows = new ArrayList<>();
-        KeyboardRow keyboardRow = new KeyboardRow();
-
-        for (Map.Entry<String, Long> entry : commands.entrySet()) {
-            if (role <= entry.getValue()) {
-                keyboardRow.add(new KeyboardButton(entry.getKey()));
-            }
-            if (keyboardRow.size()>=buttonOnLine) {
-                keyboardRows.add(keyboardRow);
-                keyboardRow = new KeyboardRow();
-            }
-        }
-        if (keyboardRow.size() > 0) {
-            keyboardRows.add(keyboardRow);
-        }
-        return keyboardRows;
-    }
 }

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

@@ -1,13 +1,11 @@
-package ru.ldeloff.servermonitorbot.utils.ui;
+package ru.ldeloff.servermonitorbot.utils.ui.uname;
 
 import lombok.RequiredArgsConstructor;
 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.Role;
 import ru.ldeloff.servermonitorbot.service.ssh.SshService;
-import ru.ldeloff.servermonitorbot.utils.RoleChecker;
 import ru.ldeloff.servermonitorbot.utils.ui.UiFormer;
 
 import java.util.ArrayList;
@@ -23,6 +21,7 @@ public class ServerListButtons implements UiFormer {
     @Override
     public SendMessage uiForm(SendMessage message) {
         List<List<InlineKeyboardButton>> keyboard = new ArrayList<>();
+
         InlineKeyboardMarkup inlineKeyboardMarkup = new InlineKeyboardMarkup();
 
         sshService.getSshServers().forEach(sshServer -> {

src/main/resources/application.yml

@@ -2,14 +2,20 @@ spring:
   application:
     name: ServerMonitorBot
   datasource:
-    url: jdbc:postgresql://db:5432/servermonitorbot
+    url: jdbc:postgresql://localhost:5432/servermonitorbot
     username: servermonitorbot
     password: servermonitorbot
   jpa:
     hibernate:
       ddl-auto: none
-  flyway:
+  liquibase:
-    locations: classpath:db/migration
+    enabled: true
+    change-log: classpath:db/scripts/changelog-master.xml
+    url: jdbc:postgresql://localhost:5432/servermonitorbot
+    user: servermonitorbot
+    password: servermonitorbot
+    liquibase-schema: "liquibase"
+    default-schema: "servermonitorbot"
 bot:
   name: "ServerMonitorBot"
   token: "token"
@@ -17,7 +23,6 @@ bot:
     - telegramId: 123456789
       role: admin
 ssh:
-  timeout: 5000
   servers:
     -
       name: "Server Name"
@@ -25,12 +30,6 @@ ssh:
       port: 22
       user: "user"
       password: "pass"
-    -
-      name: "Server Name 2"
-      host: "url 2"
-      port: 22
-      user: "user 2"
-      password: "pass 2"
 
 
 

src/main/resources/db/scripts/changelog-master.xml

@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<databaseChangeLog
+        xmlns="http://www.liquibase.org/xml/ns/dbchangelog"
+        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+        xsi:schemaLocation="http://www.liquibase.org/xml/ns/dbchangelog http://www.liquibase.org/xml/ns/dbchangelog/dbchangelog-3.1.xsd">
+
+    <include file="release_0_0_1/changelog.xml" relativeToChangelogFile="true"/>
+
+
+</databaseChangeLog>

src/main/resources/db/scripts/release_0_0_1/changelog.xml

@@ -0,0 +1,16 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<databaseChangeLog
+        xmlns="http://www.liquibase.org/xml/ns/dbchangelog"
+        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+        xsi:schemaLocation="http://www.liquibase.org/xml/ns/dbchangelog http://www.liquibase.org/xml/ns/dbchangelog/dbchangelog-3.1.xsd">
+
+    <include file="scripts/01_create_table_users.sql" relativeToChangelogFile="true"/>
+    <include file="scripts/02_create_table_roles.sql" relativeToChangelogFile="true"/>
+    <include file="scripts/03_add_FK_users_to_roles.sql" relativeToChangelogFile="true"/>
+    <include file="scripts/04_add_roles.sql" relativeToChangelogFile="true"/>
+    <include file="scripts/05_add_anonymous_role.sql" relativeToChangelogFile="true"/>
+    <include file="scripts/06_refactor_users_table.sql" relativeToChangelogFile="true"/>
+    <include file="scripts/07_refactor_roles_table.sql" relativeToChangelogFile="true"/>
+    <include file="scripts/08_add_roles.sql" relativeToChangelogFile="true"/>
+
+</databaseChangeLog>

src/main/resources/db/scripts/release_0_0_1/scripts/01_create_table_users.sql

@@ -1,3 +1,5 @@
+--liquibase formatted sql
+
 --changeset L_DelOff:create_table_users rollbackSplitStatements:true
 --comment: Создание таблицы пользователей
 CREATE TABLE users

src/main/resources/db/scripts/release_0_0_1/scripts/02_create_table_roles.sql

@@ -1,3 +1,5 @@
+--liquibase formatted sql
+
 --changeset L_DelOff:create_table_roles rollbackSplitStatements:true
 --comment: Создание таблицы ролей
 CREATE TABLE roles