Merge pull request 'feature/task-30-docker' (#31) from feature/task-30-docker into master

Reviewed-on: #31

Dockerfile

@@ -0,0 +1,11 @@
+# Используем официальный образ 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

@@ -0,0 +1,64 @@
+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('Prune images pre') {
+            steps {
+                sh """
+                    sshpass -p ${SSH_PASS} ssh -o StrictHostKeyChecking=no ${SSH_USER}@${SSH_HOST} -p ${SSH_PORT} 'docker image prune --all --force'
+                """
+            }
+        }
+        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('Prune images post') {
+            steps {
+                sh """
+                    sshpass -p ${SSH_PASS} ssh -o StrictHostKeyChecking=no ${SSH_USER}@${SSH_HOST} -p ${SSH_PORT} 'docker image prune --all --force'
+                """
+            }
+        }
+    }
+}
+

Jenkinsfile_CI

@@ -0,0 +1,15 @@
+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

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

pom.xml

@@ -5,7 +5,7 @@
     <parent>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-parent</artifactId>
-        <version>3.1.2</version>
+        <version>3.1.3</version>
         <relativePath/> <!-- lookup parent from repository -->
     </parent>
     <groupId>ru.ldeloff</groupId>
@@ -15,6 +15,11 @@
     <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>
@@ -40,7 +45,7 @@
         <dependency>
             <groupId>org.telegram</groupId>
             <artifactId>telegrambots</artifactId>
-            <version>6.7.0</version>
+            <version>6.8.0</version>
         </dependency>
         <dependency>
             <groupId>com.jcraft</groupId>
@@ -51,14 +56,15 @@
             <groupId>org.springframework.boot</groupId>
             <artifactId>spring-boot-starter-data-jpa</artifactId>
         </dependency>
-        <dependency>
-            <groupId>org.liquibase</groupId>
-            <artifactId>liquibase-core</artifactId>
-        </dependency>
         <dependency>
             <groupId>org.postgresql</groupId>
             <artifactId>postgresql</artifactId>
         </dependency>
+        <dependency>
+            <groupId>org.flywaydb</groupId>
+            <artifactId>flyway-core</artifactId>
+            <version>${flyway.version}</version>
+        </dependency>
     </dependencies>
 
     <build>
@@ -75,6 +81,39 @@
                     </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/config/SshConfig.java

@@ -1,5 +1,8 @@
 package ru.ldeloff.servermonitorbot.config;
 
+import lombok.Getter;
+import lombok.RequiredArgsConstructor;
+import lombok.Setter;
 import org.springframework.boot.context.properties.ConfigurationProperties;
 import org.springframework.context.annotation.Configuration;
 import ru.ldeloff.servermonitorbot.model.SshServer;
@@ -8,14 +11,8 @@ import java.util.List;
 
 @Configuration
 @ConfigurationProperties(prefix = "ssh")
+@Getter
+@Setter
 public class SshConfig {
     private List<SshServer> servers;
-
-    public List<SshServer> getServers() {
-        return servers;
-    }
-
-    public void setServers(List<SshServer> servers) {
-        this.servers = servers;
-    }
 }

src/main/java/ru/ldeloff/servermonitorbot/config/UserConfig.java

@@ -0,0 +1,17 @@
+package ru.ldeloff.servermonitorbot.config;
+
+import lombok.Getter;
+import lombok.Setter;
+import org.springframework.boot.context.properties.ConfigurationProperties;
+import org.springframework.context.annotation.Configuration;
+import ru.ldeloff.servermonitorbot.model.dto.InitUserDto;
+
+import java.util.List;
+
+@Configuration
+@ConfigurationProperties(prefix = "bot")
+@Getter
+@Setter
+public class UserConfig {
+    private List<InitUserDto> users;
+}

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

@@ -4,23 +4,35 @@ 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;
+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 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 {
-
     final TelegramBot telegramBot;
     final SshRepository sshRepository;
-    final TelegramBotService telegramBotService;
+
+    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) {
@@ -29,61 +41,55 @@ public class TelegramBotController extends TelegramLongPollingBot {
                 String messageText = update.getMessage().getText();
                 switch (messageText) {
                     case "/start" -> {
-                        log.info("Получена команда '" + messageText
-                                + "' от " + update.getMessage().getChat().getUserName());
-                        telegramBotService.firstUse(update, this);
+                        firstUseCommand.execute(update, this);
                     }
                     case "Статус" -> {
-                        log.info("Получена команда '" + messageText
-                                + "' от " + update.getMessage().getChat().getUserName());
-                        telegramBotService.getStatusSessions(update, this);
+                        getStatusSessions.execute(update, this);
                     }
                     case "uname" -> {
-                        log.info("Получена команда '" + messageText
-                                + "' от " + update.getMessage().getChat().getUserName());
-                        telegramBotService.sendUnameAggregate(update, this);
+                        unameAggregateCommand.execute(update, this);
+                    }
+                    case "CPU.temp" -> {
+                        cpuTempAggregateCommand.execute(update, this);
+                    }
+                    case "HDD.temp" -> {
+                        hddTempAggregateCommand.execute(update, this);
                     }
                     default -> {
-                        log.warn("Неизвестная команда '" + messageText
-                                + "' от " + update.getMessage().getChat().getUserName());
-                        telegramBotService.switchToMainMenu(update, this);
+                        switchToMainMenu.execute(update, this);
                     }
                 }
             }
         } else if (update.hasCallbackQuery()) {
-            String messageText = update.getCallbackQuery().getData();
-            String [] tags = messageText.split(":");
+            String [] tags = update.getCallbackQuery().getData().split(":");
             if (tags.length > 1) {
                 switch (tags[0]) {
-                    case "uname":
-                        log.info("Получена команда '" + messageText
-                                + "' от " + update.getCallbackQuery().getMessage().getChat().getUserName());
-                        telegramBotService.uname(update, this);
-                        break;
-                    default:
-                        log.warn("Неизвестная команда '" + messageText
-                                + "' от " + update.getCallbackQuery().getMessage().getChat().getUserName());
-                        telegramBotService.switchToMainMenu(update, this);
-                        break;
+                    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 {
-                    log.warn("Неверный формат команды '" + messageText
-                            + "' от " + update.getCallbackQuery().getMessage().getChat().getUserName());
-                    telegramBotService.switchToMainMenu(update, this);
+                switchToMainMenu.execute(update, this);
             }
         }
     }
-
     @Override
     public String getBotUsername() {
         return telegramBot.getBotUsername();
     }
-
     @Override
     public String getBotToken() {
         return telegramBot.getBotToken();
     }
-
     @Override
     public void onClosing() {
         super.onClosing();

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

@@ -0,0 +1,34 @@
+package ru.ldeloff.servermonitorbot.init;
+
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.ApplicationArguments;
+import org.springframework.boot.ApplicationRunner;
+import org.springframework.stereotype.Component;
+import ru.ldeloff.servermonitorbot.config.UserConfig;
+import ru.ldeloff.servermonitorbot.mapper.UserMapper;
+import ru.ldeloff.servermonitorbot.model.User;
+import ru.ldeloff.servermonitorbot.model.dto.InitUserDto;
+import ru.ldeloff.servermonitorbot.service.user.UserService;
+
+import java.util.List;
+
+@Component
+public class AddUsers implements ApplicationRunner {
+    final List<InitUserDto> initUsers;
+    final UserService userService;
+    final UserMapper userMapper;
+
+    @Autowired
+    public AddUsers(UserConfig userConfig, UserService userService, UserMapper userMapper) {
+        this.initUsers = userConfig.getUsers();
+        this.userService = userService;
+        this.userMapper = userMapper;
+    }
+
+    @Override
+    public void run(ApplicationArguments args) throws Exception {
+        initUsers.forEach(initUserDto -> {
+            User user = userService.saveOrUpdateUser(userMapper.dtoToUser(initUserDto));
+        });
+    }
+}

src/main/java/ru/ldeloff/servermonitorbot/mapper/UserMapper.java

@@ -0,0 +1,22 @@
+package ru.ldeloff.servermonitorbot.mapper;
+
+import org.springframework.stereotype.Component;
+import ru.ldeloff.servermonitorbot.model.User;
+import ru.ldeloff.servermonitorbot.model.dto.InitUserDto;
+import ru.ldeloff.servermonitorbot.service.role.RoleService;
+
+@Component
+public class UserMapper {
+    final RoleService roleService;
+
+    public UserMapper(RoleService roleService) {
+        this.roleService = roleService;
+    }
+
+    public User dtoToUser(InitUserDto initUserDto) {
+        User user = new User();
+        user.setTelegramId(initUserDto.getTelegramId());
+        user.setRole(roleService.findRoleByName(initUserDto.getRole()));
+        return user;
+    }
+}

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

@@ -12,6 +12,6 @@ public class Role {
     @GeneratedValue(strategy = GenerationType.IDENTITY)
     private long id;
 
-    @Column(name = "role")
-    private String role;
+    @Column(name = "name")
+    private String name;
 }

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

@@ -12,10 +12,13 @@ public class User {
     @GeneratedValue(strategy = GenerationType.IDENTITY)
     private Long id;
 
-    @Column(name = "login")
-    private Long login;
+    @Column(name = "telegram_id")
+    private Long telegramId;
 
     @ManyToOne
-    @JoinColumn(name = "id_role")
+    @JoinColumn(name = "role_id")
     private Role role;
+
+    @Transient
+    private String login;
 }

src/main/java/ru/ldeloff/servermonitorbot/model/dto/InitUserDto.java

@@ -0,0 +1,14 @@
+package ru.ldeloff.servermonitorbot.model.dto;
+
+import jakarta.validation.constraints.NotNull;
+import lombok.Data;
+import org.springframework.stereotype.Component;
+
+@Data
+@Component
+public class InitUserDto {
+    @NotNull
+    private long telegramId;
+    @NotNull
+    private String role;
+}

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

@@ -0,0 +1,13 @@
+package ru.ldeloff.servermonitorbot.repository;
+
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.stereotype.Repository;
+import ru.ldeloff.servermonitorbot.model.Role;
+
+import java.util.Optional;
+
+@Repository
+public interface RoleRepository extends JpaRepository<Role, Long> {
+    Optional<Role> findRoleByName(String name);
+    Optional<Role> findRoleById(Long id);
+}

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

@@ -0,0 +1,10 @@
+package ru.ldeloff.servermonitorbot.repository;
+
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.stereotype.Repository;
+import ru.ldeloff.servermonitorbot.model.User;
+
+@Repository
+public interface UserRepository extends JpaRepository<User, Long> {
+    User getByTelegramId(long id);
+}

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

@@ -1,13 +0,0 @@
-package ru.ldeloff.servermonitorbot.service;
-
-import org.telegram.telegrambots.meta.api.objects.Update;
-import ru.ldeloff.servermonitorbot.controller.TelegramBotController;
-
-public interface TelegramBotService {
-
-    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);
-}

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

@@ -1,69 +0,0 @@
-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());
-        }
-    }
-}

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

@@ -0,0 +1,87 @@
+package ru.ldeloff.servermonitorbot.service.command;
+
+import lombok.Data;
+import lombok.RequiredArgsConstructor;
+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.User;
+import ru.ldeloff.servermonitorbot.service.role.RoleService;
+import ru.ldeloff.servermonitorbot.service.user.UserService;
+
+@Data
+@Slf4j
+@RequiredArgsConstructor
+public abstract class CommandTemplate {
+    final UserService userService;
+    final RoleService roleService;
+    long expectedRole = 2L;
+    public abstract SendMessage actionForAuth(User user, SendMessage message);
+
+    public SendMessage actionForNotAuth(User user, SendMessage message) {
+        message.setText("У пользователя " + user.getLogin() + " (" + user.getTelegramId()
+                + ") недостаточно прав для выполнения этой команды");
+        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) {
+            logSuccess(user, message);
+            sendMessage(actionForAuth(user, answer), bot);
+        } else {
+            logNotAuth(user, message);
+            sendMessage(actionForNotAuth(user, answer), bot);
+        }
+    }
+    protected void logSuccess(User user, String message) {
+        log.info("Получена команда '" + message + "' от " + user.getLogin()
+                + " (" + user.getTelegramId() + "). OK");
+    }
+    protected void logNotAuth(User user, String message) {
+        log.warn("Получена команда '" + message + "' от " + user.getLogin()
+                + " (" + user.getTelegramId() + "). Нет прав");
+    }
+    private User getUser(Update update) {
+        long id = -1L;
+        String login = null;
+        if (update.hasMessage()) {
+            id = update.getMessage().getChat().getId();
+            login = update.getMessage().getChat().getUserName();
+        } else if (update.hasCallbackQuery()) {
+            id = update.getCallbackQuery().getMessage().getChat().getId();
+            login = update.getCallbackQuery().getMessage().getChat().getUserName();
+        }
+        User user = userService.getByTelegramId(id);
+        if (user == null) {
+            user = new User();
+            user.setTelegramId(id);
+            user.setRole(roleService.findRoleById(3L));
+        }
+        user.setLogin(login);
+        return user;
+    }
+
+    private String getMessage(Update update) {
+        if (update.hasMessage()) {
+            return update.getMessage().getText();
+        } else if (update.hasCallbackQuery()) {
+            return update.getCallbackQuery().getData();
+        }
+        return "";
+    }
+
+    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/service/command/FirstUseCommand.java

@@ -0,0 +1,23 @@
+package ru.ldeloff.servermonitorbot.service.command;
+
+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.role.RoleService;
+import ru.ldeloff.servermonitorbot.service.user.UserService;
+import ru.ldeloff.servermonitorbot.utils.ui.TelegramBotKeyboard;
+
+@Service
+public class FirstUseCommand extends CommandTemplate {
+    final TelegramBotKeyboard telegramBotKeyboard;
+
+    public FirstUseCommand(UserService userService, RoleService roleService, TelegramBotKeyboard telegramBotKeyboard) {
+        super(userService, roleService);
+        this.telegramBotKeyboard = telegramBotKeyboard;
+    }
+    @Override
+    public SendMessage actionForAuth(User user, SendMessage message) {
+        message.setText("Добро пожаловать " + user.getLogin() + "!");
+        return telegramBotKeyboard.uiForm(message);
+    }
+}

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

@@ -0,0 +1,23 @@
+package ru.ldeloff.servermonitorbot.service.command;
+
+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.role.RoleService;
+import ru.ldeloff.servermonitorbot.service.ssh.SshService;
+import ru.ldeloff.servermonitorbot.service.user.UserService;
+
+@Service
+public class GetStatusSessions extends CommandTemplate {
+    final SshService sshService;
+
+    public GetStatusSessions(UserService userService, RoleService roleService, SshService sshService) {
+        super(userService, roleService);
+        this.sshService = sshService;
+    }
+
+    @Override
+    public SendMessage actionForAuth(User user, SendMessage message) {
+        return sshService.getStatusSessions(message);
+    }
+}

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

@@ -0,0 +1,35 @@
+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 ru.ldeloff.servermonitorbot.model.User;
+import ru.ldeloff.servermonitorbot.service.role.RoleService;
+import ru.ldeloff.servermonitorbot.service.user.UserService;
+import ru.ldeloff.servermonitorbot.utils.ui.TelegramBotKeyboard;
+
+@Service
+@Slf4j
+public class SwitchToMainMenu extends CommandTemplate {
+    final TelegramBotKeyboard telegramBotKeyboard;
+
+    public SwitchToMainMenu(UserService userService, RoleService roleService, TelegramBotKeyboard telegramBotKeyboard) {
+        super(userService, roleService);
+        this.telegramBotKeyboard = telegramBotKeyboard;
+    }
+    @Override
+    public SendMessage actionForAuth(User user, SendMessage message) {
+        message.setText("Неверная команда. Попробуем сначала.");
+        return telegramBotKeyboard.uiForm(message);
+    }
+    @Override
+    public void logSuccess(User user, String message) {
+        log.warn("Получена несуществующая команда '" + message + "' от " + user.getLogin()
+                + " (" + user.getTelegramId() + "). OK");
+    }
+    @Override
+    public void logNotAuth(User user, String message) {
+        log.warn("Получена несуществующая команда '" + message + "' от " + user.getLogin()
+                + " (" + user.getTelegramId() + "). Нет прав");
+    }
+}

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

@@ -1,15 +1,16 @@
-package ru.ldeloff.servermonitorbot.service.uname;
+package ru.ldeloff.servermonitorbot.service.command.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.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 ru.ldeloff.servermonitorbot.utils.ui.uname.UnameChatButtonAggregate;
 
 import java.util.Arrays;
 import java.util.List;
@@ -17,46 +18,32 @@ import java.util.Objects;
 import java.util.Optional;
 
 @Service
-@RequiredArgsConstructor
 @Slf4j
-public class UnameServiceImpl implements UnameService {
+public class UnameCommand extends CommandTemplate {
     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);
+    public UnameCommand(UserService userService, RoleService roleService, SshService sshService) {
+        super(userService, roleService);
+        this.sshService = sshService;
     }
     @Override
-    public SendMessage uname(Update update) {
-        String messageText = update.getCallbackQuery().getData();
-
-        String [] tags = Arrays.stream(messageText.split(":"))
+    public SendMessage actionForAuth(User user, SendMessage message) {
+        String [] tags = Arrays.stream(message.getText().split(":"))
                 .map(String::trim)
                 .toArray(String[]::new);
 
-        String result;
         if (tags[1].equals("all")) {
-            result = unameAllHost();
+            message.setText(unameAllHost());
         } else {
-            result = unameSpecificHost(tags[1]);
+            message.setText(Objects.requireNonNull(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 = SshServerUtils.filterGoodServers(sshService.getSshServers());
-       StringBuilder response = new StringBuilder();
-       servers.forEach(server -> {
-           response.append(unameSpecificHost(server.getName())).append("\n");
-       });
-       return response.toString();
+        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) {

src/main/java/ru/ldeloff/servermonitorbot/service/role/RoleService.java

@@ -0,0 +1,9 @@
+package ru.ldeloff.servermonitorbot.service.role;
+
+import ru.ldeloff.servermonitorbot.model.Role;
+
+public interface RoleService {
+    Role findRoleByName(String name);
+
+    Role findRoleById(Long id);
+}

src/main/java/ru/ldeloff/servermonitorbot/service/role/RoleServiceImpl.java

@@ -0,0 +1,28 @@
+package ru.ldeloff.servermonitorbot.service.role;
+
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Service;
+import ru.ldeloff.servermonitorbot.model.Role;
+import ru.ldeloff.servermonitorbot.repository.RoleRepository;
+
+import java.util.Locale;
+import java.util.Optional;
+
+@Service
+@RequiredArgsConstructor
+public class RoleServiceImpl implements RoleService {
+    private final RoleRepository roleRepository;
+
+    @Override
+    public Role findRoleByName(String name) {
+        Optional<Role> role = roleRepository.findRoleByName(name.toUpperCase(Locale.ROOT));
+        //noinspection OptionalGetWithoutIsPresent
+        return role.orElseGet(() -> roleRepository.findRoleByName("ANONYMOUS").get());
+    }
+
+    @Override
+    public Role findRoleById(Long id) {
+        Optional<Role> role = roleRepository.findRoleById(id);
+        return role.orElseGet(() -> roleRepository.findRoleByName("ANONYMOUS").get());
+    }
+}

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

@@ -2,14 +2,14 @@ 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.Command;
 import ru.ldeloff.servermonitorbot.model.SshServer;
 
 import java.util.List;
 
 public interface SshService {
-    SendMessage getStatusSessions(Update update);
+    SendMessage getStatusSessions(SendMessage update);
+
     List<SshServer> getSshServers();
     Command execute(Command command);
     List<Command> execute(List<Command> commands);

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

@@ -7,7 +7,6 @@ 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.Command;
 import ru.ldeloff.servermonitorbot.model.SshServer;
 import ru.ldeloff.servermonitorbot.repository.SshRepository;
@@ -19,14 +18,11 @@ import java.util.List;
 @Service
 @Slf4j
 @RequiredArgsConstructor
-public class SshServiceImpl implements  SshService {
+public class SshServiceImpl implements SshService {
     final SshRepository sshRepository;
     @Override
-    public SendMessage getStatusSessions(Update update) {
-        SendMessage message = new SendMessage();
-        long chatId = update.getMessage().getChatId();
+    public SendMessage getStatusSessions(SendMessage message) {
         message.setText(sshRepository.getStatusSessions());
-        message.setChatId(chatId);
         return message;
     }
     @Override

src/main/java/ru/ldeloff/servermonitorbot/service/uname/UnameService.java

@@ -1,10 +0,0 @@
-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);
-}

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

@@ -0,0 +1,9 @@
+package ru.ldeloff.servermonitorbot.service.user;
+
+import ru.ldeloff.servermonitorbot.model.User;
+
+public interface UserService {
+    User saveOrUpdateUser(User user);
+
+    User getByTelegramId(Long id);
+}

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

@@ -0,0 +1,29 @@
+package ru.ldeloff.servermonitorbot.service.user;
+
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Service;
+import ru.ldeloff.servermonitorbot.model.User;
+import ru.ldeloff.servermonitorbot.repository.UserRepository;
+
+@Service
+@RequiredArgsConstructor
+@Slf4j
+public class UserServiceImpl implements UserService {
+
+    final UserRepository userRepository;
+
+    @Override
+    public User saveOrUpdateUser(User user) {
+        User existUser = userRepository.getByTelegramId(user.getTelegramId());
+        if (existUser != null) {
+            user.setId(existUser.getId());
+        }
+        return userRepository.save(user);
+    }
+
+    @Override
+    public User getByTelegramId(Long id) {
+        return userRepository.getByTelegramId(id);
+    }
+}

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

@@ -13,12 +13,15 @@ import java.util.ArrayList;
 public class TelegramBotKeyboard implements UiFormer {
     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); //скрываем после использования
+        replyKeyboardMarkup.setResizeKeyboard(true);
+        replyKeyboardMarkup.setOneTimeKeyboard(false);
 
         ArrayList<KeyboardRow> keyboardRows = new ArrayList<>();
 
@@ -27,6 +30,8 @@ public class TelegramBotKeyboard implements UiFormer {
 
         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);

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

@@ -1,12 +1,10 @@
 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;
 
@@ -16,7 +14,7 @@ import java.util.Objects;
 
 @Component
 @RequiredArgsConstructor
-public class UnameChatButtonAggregate implements UiFormer {
+public class ServerListButtons implements UiFormer {
 
     private final SshService sshService;
 
@@ -32,7 +30,7 @@ public class UnameChatButtonAggregate implements UiFormer {
                     List<InlineKeyboardButton> keyboardRow = new ArrayList<>();
                     InlineKeyboardButton inlineKeyboardButton = new InlineKeyboardButton();
                     inlineKeyboardButton.setText(sshServer.getName());
-                    inlineKeyboardButton.setCallbackData("uname: " + sshServer.getName());
+                    inlineKeyboardButton.setCallbackData(message.getText() + ": " + sshServer.getName());
                     keyboardRow.add(inlineKeyboardButton);
                     keyboard.add(keyboardRow);
                 }
@@ -43,14 +41,14 @@ public class UnameChatButtonAggregate implements UiFormer {
             List<InlineKeyboardButton> keyboardRow = new ArrayList<>();
             InlineKeyboardButton inlineKeyboardButton = new InlineKeyboardButton();
             inlineKeyboardButton.setText("Все сервера");
-            inlineKeyboardButton.setCallbackData("uname: all");
+            inlineKeyboardButton.setCallbackData(message.getText() + ": all");
             keyboardRow.add(inlineKeyboardButton);
             keyboard.add(keyboardRow);
         }
 
         inlineKeyboardMarkup.setKeyboard(keyboard);
         message.setReplyMarkup(inlineKeyboardMarkup);
-        message.setText("Выполнить uname для");
+        message.setText("Выполнить " + message.getText() + " для");
 
         return message;
     }

src/main/resources/application.yml

@@ -2,23 +2,20 @@ spring:
   application:
     name: ServerMonitorBot
   datasource:
-    url: jdbc:postgresql://localhost:5432/servermonitorbot
+    url: jdbc:postgresql://db:5432/servermonitorbot
     username: servermonitorbot
     password: servermonitorbot
   jpa:
     hibernate:
       ddl-auto: none
-  liquibase:
-    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"
+  flyway:
+    locations: classpath:db/migration
 bot:
   name: "ServerMonitorBot"
   token: "token"
+  users:
+    - telegramId: 123456789
+      role: admin
 ssh:
   servers:
     -

src/main/resources/db/migration/V001__create_table_users.sql

@@ -1,10 +1,8 @@
---liquibase formatted sql
-
 --changeset L_DelOff:create_table_users rollbackSplitStatements:true
 --comment: Создание таблицы пользователей
 CREATE TABLE users
 (
-    id       integer        PRIMARY KEY,
+    id       SERIAL        PRIMARY KEY,
     login    VARCHAR(128),
     id_role  integer
 );

src/main/resources/db/migration/V002__create_table_roles.sql

@@ -1,10 +1,8 @@
---liquibase formatted sql
-
 --changeset L_DelOff:create_table_roles rollbackSplitStatements:true
 --comment: Создание таблицы ролей
 CREATE TABLE roles
 (
-    id       integer        PRIMARY KEY,
+    id       SERIAL        PRIMARY KEY,
     role    VARCHAR(128)
 );
 

src/main/resources/db/migration/V005__add_anonymous_role.sql

@@ -0,0 +1 @@
+INSERT INTO roles (id, role) VALUES (3, 'ANONYMOUS');

src/main/resources/db/migration/V006__refactor_users_table.sql

@@ -0,0 +1,9 @@
+ALTER TABLE users
+    DROP COLUMN login;
+
+ALTER TABLE users
+    ADD COLUMN telegram_id INTEGER UNIQUE;
+    COMMENT ON COLUMN users.telegram_id IS 'Telegram ID пользователя';
+
+ALTER TABLE users
+    DROP COLUMN id_role;

src/main/resources/db/migration/V007__refactor_roles_table.sql

@@ -0,0 +1,6 @@
+ALTER TABLE roles
+    DROP COLUMN role;
+
+ALTER TABLE roles
+    ADD COLUMN name VARCHAR(128);
+COMMENT ON COLUMN roles.name IS 'Имя роли';

src/main/resources/db/migration/V008__add_roles.sql

@@ -0,0 +1,4 @@
+TRUNCATE TABLE roles CASCADE;
+INSERT INTO roles (id, name) VALUES (1, 'ADMIN');
+INSERT INTO roles (id, name) VALUES (2, 'USER');
+INSERT INTO roles (id, name) VALUES (3, 'ANONYMOUS');

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

@@ -1,10 +0,0 @@
-<?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

@@ -1,12 +0,0 @@
-<?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"/>
-
-</databaseChangeLog>