Merge remote-tracking branch 'origin/personal-schedule'

Reviewed-on: #7

backend/README.md

@@ -0,0 +1,77 @@
+# Руководство Backend-разработчика Magistr
+
+Добро пожаловать в проект Magistr! Этот бэкенд построен на **Spring Boot** и имеет сложную **мультитенантную архитектуру**, где одно приложение обслуживает множество независимых университетов, каждый со своей базой данных. В проекте также есть интеграция с Kubernetes для "горячего" управления этими тенантами.
+
+Здесь описано, как тут всё устроено, чтобы вы ничего не сломали.
+
+---
+
+## 1. Архитектура мультитенантности
+
+Мы используем подход **Separate Database per Tenant** (Отдельная БД для каждого клиента).
+
+- **Как приложение понимает, к какой базе обращаться?**
+  Все запросы с фронтенда приходят с заголовком `Host` (например, `swsu.zuev.company`).
+  В классе `TenantInterceptor` (находится в `config/tenant/TenantInterceptor.java`) мы перехватываем этот запрос ДО того, как он дойдёт до контроллеров, вытаскиваем поддомен (`swsu`) и сохраняем его в `ThreadLocal` переменную через класс `TenantContext`.
+
+- **Как переключаются базы данных?**
+  Класс `TenantRoutingDataSource` наследуется от спринговского `AbstractRoutingDataSource`. Перед каждым запросом в базу (любой `findById` или `save` из репозитория) Spring спрашивает этот класс: *"Какой сейчас ключ тенанта?"*. Класс берёт имя из `TenantContext` и переключает коннект на нужную БД на лету.
+
+> **Важно:** Вся логика переключения абсолютно прозрачна для бизнес-кода. В контроллерах и сервисах вы пишете обычный код (`userRepository.findAll()`), и он сам выполнится в нужной базе.
+
+---
+
+## 2. Динамическое управление тенантами (Kubernetes / ConfigMap)
+
+Бэкенд спроектирован для работы в **Kubernetes с несколькими репликами (replicas: 2+)**.
+
+Список тенантов не зашит в код:
+- В K8s он лежит в специальном `ConfigMap`, который монтируется внутрь пода как файл `tenants.json`.
+- В классе `DatabaseController` находится API для добавления нового тенанта из админки.
+- Чтобы изменения применились ко **всем подам** без перезагрузки, `DatabaseController` вызывает `ConfigMapUpdater`. Этот класс обращается напрямую к **Kubernetes API** (используя ServiceAccount токен пода) и патчит `ConfigMap`.
+- В фоне работает планировщик `TenantConfigWatcher` (каждые 30 секунд). Он следит за изменениями `tenants.json` и, если видит нового тенанта, на лету поднимает для него новый `HikariCP` пул соединений и добавляет в маршрутизатор баз данных.
+
+---
+
+## 3. Базы данных и Миграции (Flyway)
+
+Мы **НЕ используем** автоматическую генерацию таблиц через Hibernate (`spring.jpa.hibernate.ddl-auto=none`).
+Структурой баз данных правит **Flyway**.
+
+Поскольку баз данных много (они создаются динамически), стандартный Spring Boot Flyway отключён. Вместо этого `TenantConfigWatcher` вызывает Flyway **программно** в момент первого подключения нового тенанта.
+
+### 🛑 ПРАВИЛА ИЗМЕНЕНИЯ СТРУКТУРЫ БД:
+
+Если вам нужно добавить новую таблицу, колонку или изменить тип поля:
+
+1. **Запрещено трогать старые файлы миграций!**
+   Запомните: файл `V1__init.sql` (и любые другие V-файлы, которые уже попали в коммит) — **СВЯЩЕНЕН**. Если вы его измените, бэкенд не запустится на сервере с ошибкой `Migration checksum mismatch`.
+
+2. **Как правильно добавить таблицу?**
+   - Зайдите в папку `src/main/resources/db/migration/`.
+   - Создайте новый файл. Название **строго** по формату: `V<Номер>__<Описание>.sql`. Например: `V2__add_student_rating_table.sql`.
+   - Напишите в нём ваш SQL (`CREATE TABLE ...`, `ALTER TABLE ...`).
+   - Сохраните и запустите проект. Flyway **сам** пройдёт по всем базам данных тенантов и накатит этот скрипт.
+
+3. **Что если локально я накосячил в V2?**
+   Пока файл `V2_...` не залит в Git и крутится только у вас на локалке, вы можете его переписывать. Но для этого вам нужно зайти в вашу локальную БД (через DBeaver/pgAdmin), вручную откатить свои кривые изменения (удалить таблицу) и **удалить запись из истории Flyway**:
+   `DELETE FROM flyway_schema_history WHERE version = '2';`
+   Либо, что проще: удалите контейнер с локальной БД (`docker compose down -v`) и поднимите заново пустую.
+
+---
+
+## 4. Как запускать проект локально
+
+В корневой папке репозитория (где лежит `docker-compose.yaml`) поднимите инфраструктуру:
+```bash
+docker compose up -d
+```
+Соберется и запустится:
+- Фронтенд 
+- Бэкенд
+- Ваша локальная тестовая PostgreSQL-база данных (на порту 5432, имя базы `app_db`, юзер `myuser`, логин/пароль см. в compose файле).
+
+Файл `backend/tenants.json` нужен для локальной разработки. Если вы запускаете бэкенд в Docker Compose, вы можете указать URL `jdbc:postgresql://db:5432/app_db` (где `db` — имя контейнера в compose сети). 
+Либо, если вы тестируете взаимодействие бэкенда с вашим текущим IP-адресом (например, `192.168.1.87`), вы можете использовать этот IP. Оба варианта рабочие! Проект сразу подхватит настройки и накатит таблицы через Flyway.
+
+Контроллеры и бизнес-логику пишите как в обычном Spring Boot проекте. Главное, помните: у каждого тенанта — своё изолированное хранилище!

backend/pom.xml

@@ -32,6 +32,12 @@
             <groupId>org.springframework.boot</groupId>
             <artifactId>spring-boot-starter-data-jpa</artifactId>
         </dependency>
+        
+        <!-- Flyway Database Migrations -->
+        <dependency>
+            <groupId>org.flywaydb</groupId>
+            <artifactId>flyway-core</artifactId>
+        </dependency>
         <dependency>
             <groupId>org.postgresql</groupId>
             <artifactId>postgresql</artifactId>
@@ -43,6 +49,13 @@
             <groupId>org.springframework.security</groupId>
             <artifactId>spring-security-crypto</artifactId>
         </dependency>
+
+        <!-- H2 in-memory DB (fallback когда нет настроенных тенантов) -->
+        <dependency>
+            <groupId>com.h2database</groupId>
+            <artifactId>h2</artifactId>
+            <scope>runtime</scope>
+        </dependency>
     </dependencies>
 
     <build>

backend/src/main/java/com/magistr/app/Application.java

@@ -2,8 +2,12 @@ package com.magistr.app;
 
 import org.springframework.boot.SpringApplication;
 import org.springframework.boot.autoconfigure.SpringBootApplication;
+import org.springframework.boot.autoconfigure.flyway.FlywayAutoConfiguration;
+import org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration;
+import org.springframework.scheduling.annotation.EnableScheduling;
 
-@SpringBootApplication
+@SpringBootApplication(exclude = {DataSourceAutoConfiguration.class, FlywayAutoConfiguration.class})
+@EnableScheduling
 public class Application {
 
     public static void main(String[] args) {

backend/src/main/java/com/magistr/app/config/DataInitializer.java

@@ -1,50 +1,39 @@
 package com.magistr.app.config;
 
-import com.magistr.app.model.Role;
+import com.magistr.app.config.tenant.TenantConfig;
-import com.magistr.app.model.User;
+import com.magistr.app.config.tenant.TenantConfigWatcher;
-import com.magistr.app.repository.UserRepository;
+import com.magistr.app.config.tenant.TenantRoutingDataSource;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.springframework.boot.CommandLineRunner;
-import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
 import org.springframework.stereotype.Component;
 
-import java.util.Optional;
+/**
-
+ * При запуске приложения инициализирует БД для каждого тенанта.
+ * Делегирует инициализацию в TenantConfigWatcher.initDatabaseForTenant().
+ */
 @Component
 public class DataInitializer implements CommandLineRunner {
 
     private static final Logger log = LoggerFactory.getLogger(DataInitializer.class);
 
-    private final UserRepository userRepository;
+    private final TenantRoutingDataSource routingDataSource;
-    private final BCryptPasswordEncoder passwordEncoder;
+    private final TenantConfigWatcher configWatcher;
 
-    public DataInitializer(UserRepository userRepository, BCryptPasswordEncoder passwordEncoder) {
+    public DataInitializer(TenantRoutingDataSource routingDataSource,
-        this.userRepository = userRepository;
+                           TenantConfigWatcher configWatcher) {
-        this.passwordEncoder = passwordEncoder;
+        this.routingDataSource = routingDataSource;
+        this.configWatcher = configWatcher;
     }
 
     @Override
     public void run(String... args) {
-        Optional<User> existing = userRepository.findByUsername("admin");
+        log.info("Initializing databases for {} tenant(s)...", routingDataSource.getTenantConfigs().size());
 
-        if (existing.isEmpty()) {
+        for (TenantConfig tenant : routingDataSource.getTenantConfigs().values()) {
-            User admin = new User();
+            configWatcher.initDatabaseForTenant(tenant);
-            admin.setUsername("admin");
+        }
-            admin.setPassword(passwordEncoder.encode("admin"));
+
-            admin.setRole(Role.ADMIN);
+        log.info("Database initialization complete");
-            userRepository.save(admin);
-            log.info("Created default admin user");
-        } else {
-            User admin = existing.get();
-            if (!passwordEncoder.matches("admin", admin.getPassword())) {
-                admin.setPassword(passwordEncoder.encode("admin"));
-                admin.setRole(Role.ADMIN);
-                userRepository.save(admin);
-                log.info("Reset admin password (hash was invalid)");
-            } else {
-                log.info("Admin user already exists with correct password");
-            }
-        }
     }
 }

backend/src/main/java/com/magistr/app/config/tenant/ConfigMapUpdater.java

@@ -0,0 +1,127 @@
+package com.magistr.app.config.tenant;
+
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.stereotype.Service;
+
+import java.io.IOException;
+import java.net.URI;
+import java.net.http.HttpClient;
+import java.net.http.HttpRequest;
+import java.net.http.HttpResponse;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.security.SecureRandom;
+import java.security.cert.X509Certificate;
+import java.util.List;
+import java.util.Map;
+import javax.net.ssl.SSLContext;
+import javax.net.ssl.TrustManager;
+import javax.net.ssl.X509TrustManager;
+
+/**
+ * Обновляет K8s ConfigMap tenants-config через Kubernetes REST API.
+ *
+ * Работает ТОЛЬКО внутри K8s пода (использует ServiceAccount token).
+ * При запуске вне K8s (локальная разработка) — просто логирует предупреждение.
+ */
+@Service
+public class ConfigMapUpdater {
+
+    private static final Logger log = LoggerFactory.getLogger(ConfigMapUpdater.class);
+
+    private static final String TOKEN_PATH = "/var/run/secrets/kubernetes.io/serviceaccount/token";
+    private static final String NAMESPACE_PATH = "/var/run/secrets/kubernetes.io/serviceaccount/namespace";
+    private static final String K8S_API_BASE = "https://kubernetes.default.svc";
+    private static final String CONFIGMAP_NAME = "tenants-config";
+
+    private final ObjectMapper objectMapper = new ObjectMapper();
+    private final boolean runningInK8s;
+
+    public ConfigMapUpdater() {
+        this.runningInK8s = Files.exists(Path.of(TOKEN_PATH));
+        if (!runningInK8s) {
+            log.info("Not running in K8s — ConfigMap updates will be skipped");
+        }
+    }
+
+    /**
+     * Обновляет ConfigMap tenants-config с новым списком тенантов.
+     * @return true если обновление успешно (или мы не в K8s)
+     */
+    public boolean updateTenantsConfig(List<TenantConfig> tenants) {
+        if (!runningInK8s) {
+            log.warn("Not in K8s, skipping ConfigMap update");
+            return true;
+        }
+
+        try {
+            String token = Files.readString(Path.of(TOKEN_PATH)).trim();
+            String namespace = Files.readString(Path.of(NAMESPACE_PATH)).trim();
+
+            // Формируем JSON для тенантов
+            String tenantsJson = objectMapper.writerWithDefaultPrettyPrinter()
+                    .writeValueAsString(tenants);
+
+            // Strategic merge patch для ConfigMap
+            String patchBody = objectMapper.writeValueAsString(Map.of(
+                "data", Map.of("tenants.json", tenantsJson)
+            ));
+
+            String url = String.format("%s/api/v1/namespaces/%s/configmaps/%s",
+                    K8S_API_BASE, namespace, CONFIGMAP_NAME);
+
+            // Создаём HttpClient с отключённой проверкой сертификатов
+            // (внутри кластера используется self-signed CA)
+            HttpClient client = createInsecureClient();
+
+            HttpRequest request = HttpRequest.newBuilder()
+                    .uri(URI.create(url))
+                    .header("Authorization", "Bearer " + token)
+                    .header("Content-Type", "application/strategic-merge-patch+json")
+                    .method("PATCH", HttpRequest.BodyPublishers.ofString(patchBody))
+                    .build();
+
+            HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
+
+            if (response.statusCode() == 200) {
+                log.info("ConfigMap '{}' updated successfully ({} tenants)", CONFIGMAP_NAME, tenants.size());
+                return true;
+            } else {
+                log.error("Failed to update ConfigMap: HTTP {} — {}", response.statusCode(), response.body());
+                return false;
+            }
+
+        } catch (Exception e) {
+            log.error("Error updating ConfigMap: {}", e.getMessage());
+            return false;
+        }
+    }
+
+    /**
+     * Создаёт HttpClient, который доверяет self-signed сертификатам K8s API.
+     */
+    private HttpClient createInsecureClient() {
+        try {
+            TrustManager[] trustAll = new TrustManager[]{
+                new X509TrustManager() {
+                    public X509Certificate[] getAcceptedIssuers() { return new X509Certificate[0]; }
+                    public void checkClientTrusted(X509Certificate[] certs, String authType) {}
+                    public void checkServerTrusted(X509Certificate[] certs, String authType) {}
+                }
+            };
+
+            SSLContext sslContext = SSLContext.getInstance("TLS");
+            sslContext.init(null, trustAll, new SecureRandom());
+
+            return HttpClient.newBuilder()
+                    .sslContext(sslContext)
+                    .build();
+        } catch (Exception e) {
+            log.warn("Failed to create insecure client, using default: {}", e.getMessage());
+            return HttpClient.newHttpClient();
+        }
+    }
+}

backend/src/main/java/com/magistr/app/config/tenant/TenantConfig.java

@@ -0,0 +1,41 @@
+package com.magistr.app.config.tenant;
+
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+
+/**
+ * Модель конфигурации тенанта (университета).
+ */
+@JsonIgnoreProperties(ignoreUnknown = true)
+public class TenantConfig {
+
+    private String name;      // "ЮЗГУ", "МГУ"
+    private String domain;    // "swsu", "mgu" (поддомен)
+    private String url;       // "jdbc:postgresql://192.168.1.50:5432/magistr_db"
+    private String username;
+    private String password;
+
+    public TenantConfig() {}
+
+    public TenantConfig(String name, String domain, String url, String username, String password) {
+        this.name = name;
+        this.domain = domain;
+        this.url = url;
+        this.username = username;
+        this.password = password;
+    }
+
+    public String getName() { return name; }
+    public void setName(String name) { this.name = name; }
+
+    public String getDomain() { return domain; }
+    public void setDomain(String domain) { this.domain = domain; }
+
+    public String getUrl() { return url; }
+    public void setUrl(String url) { this.url = url; }
+
+    public String getUsername() { return username; }
+    public void setUsername(String username) { this.username = username; }
+
+    public String getPassword() { return password; }
+    public void setPassword(String password) { this.password = password; }
+}

backend/src/main/java/com/magistr/app/config/tenant/TenantConfigWatcher.java

@@ -0,0 +1,156 @@
+package com.magistr.app.config.tenant;
+
+import com.fasterxml.jackson.core.type.TypeReference;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.core.io.ClassPathResource;
+import org.springframework.scheduling.annotation.Scheduled;
+import org.springframework.stereotype.Component;
+
+import javax.sql.DataSource;
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.nio.charset.StandardCharsets;
+import java.sql.Connection;
+import java.sql.ResultSet;
+import java.sql.Statement;
+import java.util.*;
+import java.util.stream.Collectors;
+
+/**
+ * Периодически перечитывает tenants.json (mounted ConfigMap).
+ * Если ConfigMap был обновлён через K8s API, этот компонент
+ * подхватит изменения и синхронизирует in-memory datasource'ы.
+ *
+ * Также отвечает за инициализацию БД (init.sql) для новых тенантов.
+ */
+@Component
+public class TenantConfigWatcher {
+
+    private static final Logger log = LoggerFactory.getLogger(TenantConfigWatcher.class);
+
+    private final TenantRoutingDataSource routingDataSource;
+    private final DataSource dataSource;
+    private final ObjectMapper objectMapper = new ObjectMapper();
+
+    @Value("${app.tenants.config-path:tenants.json}")
+    private String tenantsConfigPath;
+
+    // Хеш последнего прочитанного конфига — чтобы не перезагружать зря
+    private String lastConfigHash = "";
+
+    public TenantConfigWatcher(TenantRoutingDataSource routingDataSource, DataSource dataSource) {
+        this.routingDataSource = routingDataSource;
+        this.dataSource = dataSource;
+    }
+
+    /**
+     * Каждые 30 секунд проверяет, изменился ли tenants.json.
+     */
+    @Scheduled(fixedDelay = 30_000, initialDelay = 30_000)
+    public void watchForChanges() {
+        try {
+            File file = new File(tenantsConfigPath);
+            if (!file.exists()) return;
+
+            String content = new String(java.nio.file.Files.readAllBytes(file.toPath()), StandardCharsets.UTF_8);
+            String hash = Integer.toHexString(content.hashCode());
+
+            if (hash.equals(lastConfigHash)) {
+                return; // Ничего не изменилось
+            }
+
+            log.info("Detected tenants.json change (hash: {} -> {}), reloading...", lastConfigHash, hash);
+            lastConfigHash = hash;
+
+            List<TenantConfig> newTenants = objectMapper.readValue(content, new TypeReference<>() {});
+            syncTenants(newTenants);
+
+        } catch (Exception e) {
+            log.error("Error watching tenants config: {}", e.getMessage());
+        }
+    }
+
+    /**
+     * Обновляет хеш конфига (вызывается после ручного обновления ConfigMap с этого же пода).
+     */
+    public void refreshHash() {
+        try {
+            File file = new File(tenantsConfigPath);
+            if (file.exists()) {
+                String content = new String(java.nio.file.Files.readAllBytes(file.toPath()), StandardCharsets.UTF_8);
+                lastConfigHash = Integer.toHexString(content.hashCode());
+            }
+        } catch (Exception e) {
+            log.warn("Failed to refresh config hash: {}", e.getMessage());
+        }
+    }
+
+    /**
+     * Синхронизирует in-memory тенантов с конфигом из файла.
+     */
+    private void syncTenants(List<TenantConfig> newTenants) {
+        Map<String, TenantConfig> current = routingDataSource.getTenantConfigs();
+        Set<String> newDomains = newTenants.stream()
+                .map(t -> t.getDomain().toLowerCase())
+                .collect(Collectors.toSet());
+
+        // Добавить новые тенанты
+        for (TenantConfig tenant : newTenants) {
+            String domain = tenant.getDomain().toLowerCase();
+            if (!current.containsKey(domain)) {
+                log.info("Adding new tenant '{}' from ConfigMap update", domain);
+                routingDataSource.addTenant(tenant);
+                // Инициализируем БД для нового тенанта
+                initDatabaseForTenant(tenant);
+            }
+        }
+
+        // Удалить тенанты, которых больше нет в конфиге
+        for (String existingDomain : new ArrayList<>(current.keySet())) {
+            if (!newDomains.contains(existingDomain)) {
+                log.info("Removing tenant '{}' (no longer in ConfigMap)", existingDomain);
+                routingDataSource.removeTenant(existingDomain);
+            }
+        }
+    }
+
+    /**
+     * Выполняет миграции Flyway для конкретного тенанта пи подключении.
+     * Если БД уже существует, но история Flyway пуста — 
+     * делает baseline (считает V1_init.sql уже выполненным).
+     */
+    public void initDatabaseForTenant(TenantConfig tenant) {
+        String domain = tenant.getDomain();
+        try {
+            TenantContext.setCurrentTenant(domain);
+
+            log.info("[{}] Starting Flyway migrations...", domain);
+            
+            // Получаем DataSource конкретно для этого тенанта
+            javax.sql.DataSource tenantDs = routingDataSource.getResolvedDataSources().get(domain);
+            if (tenantDs == null) {
+                // Если ещё не resolve'нулся (первый запуск), берём обёртку
+                tenantDs = dataSource;
+            }
+
+            org.flywaydb.core.Flyway flyway = org.flywaydb.core.Flyway.configure()
+                    .dataSource(tenantDs)
+                    .baselineOnMigrate(true)
+                    .baselineVersion("1")
+                    .load();
+
+            flyway.migrate();
+            log.info("[{}] Flyway migrations completed successfully", domain);
+
+        } catch (Exception e) {
+            log.error("[{}] Flyway migration failed: {}", domain, e.getMessage());
+        } finally {
+            TenantContext.clear();
+        }
+    }
+}

backend/src/main/java/com/magistr/app/config/tenant/TenantContext.java

@@ -0,0 +1,22 @@
+package com.magistr.app.config.tenant;
+
+/**
+ * ThreadLocal хранилище текущего тенанта (домена).
+ * Устанавливается в TenantInterceptor на каждый HTTP-запрос.
+ */
+public class TenantContext {
+
+    private static final ThreadLocal<String> CURRENT_TENANT = new ThreadLocal<>();
+
+    public static String getCurrentTenant() {
+        return CURRENT_TENANT.get();
+    }
+
+    public static void setCurrentTenant(String tenant) {
+        CURRENT_TENANT.set(tenant);
+    }
+
+    public static void clear() {
+        CURRENT_TENANT.remove();
+    }
+}

backend/src/main/java/com/magistr/app/config/tenant/TenantDataSourceConfig.java

@@ -0,0 +1,156 @@
+package com.magistr.app.config.tenant;
+
+import com.fasterxml.jackson.core.type.TypeReference;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.context.annotation.Primary;
+import org.springframework.orm.jpa.JpaTransactionManager;
+import org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean;
+import org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter;
+import org.springframework.transaction.PlatformTransactionManager;
+import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
+import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
+
+import jakarta.persistence.EntityManagerFactory;
+import javax.sql.DataSource;
+import java.io.File;
+import java.io.IOException;
+import java.util.*;
+
+/**
+ * Конфигурация мультитенантного DataSource.
+ * Загружает тенанты из JSON-файла (mounted ConfigMap).
+ *
+ * Если нет ни одного настроенного тенанта — создаёт H2 in-memory БД
+ * как заглушку, чтобы Spring JPA мог инициализироваться.
+ */
+@Configuration
+public class TenantDataSourceConfig implements WebMvcConfigurer {
+
+    private static final Logger log = LoggerFactory.getLogger(TenantDataSourceConfig.class);
+
+    @Value("${app.tenants.config-path:tenants.json}")
+    private String tenantsConfigPath;
+
+    @Value("${spring.datasource.url:}")
+    private String defaultDbUrl;
+
+    @Value("${spring.datasource.username:}")
+    private String defaultDbUsername;
+
+    @Value("${spring.datasource.password:}")
+    private String defaultDbPassword;
+
+    @Bean
+    @Primary
+    public DataSource dataSource() {
+        TenantRoutingDataSource routingDataSource = new TenantRoutingDataSource();
+
+        // Загружаем тенантов из JSON (read-only ConfigMap mount)
+        List<TenantConfig> tenants = loadTenantsFromFile();
+
+        // Если нет тенантов и есть дефолтный datasource — создаём "default" тенант
+        if (tenants.isEmpty() && defaultDbUrl != null && !defaultDbUrl.isBlank()) {
+            TenantConfig defaultTenant = new TenantConfig(
+                "Default", "default", defaultDbUrl, defaultDbUsername, defaultDbPassword
+            );
+            tenants.add(defaultTenant);
+            log.info("No tenants config found, using default datasource: {}", defaultDbUrl);
+        }
+
+        // Регистрируем тенантов
+        for (TenantConfig tenant : tenants) {
+            try {
+                routingDataSource.addTenant(tenant);
+            } catch (Exception e) {
+                log.error("Failed to add tenant '{}': {}", tenant.getDomain(), e.getMessage());
+            }
+        }
+
+        // Если всё ещё нет ни одного тенанта — H2 in-memory заглушка
+        if (routingDataSource.getTenantConfigs().isEmpty()) {
+            log.warn("=== НЕТ НАСТРОЕННЫХ ТЕНАНТОВ ===");
+            log.warn("Создаём H2 in-memory заглушку для запуска приложения.");
+            log.warn("Добавьте тенант через POST /api/database/tenants");
+
+            TenantConfig h2Fallback = new TenantConfig(
+                "H2 Placeholder", "default",
+                "jdbc:h2:mem:placeholder;DB_CLOSE_DELAY=-1",
+                "sa", ""
+            );
+            routingDataSource.addTenant(h2Fallback);
+        }
+
+        return routingDataSource;
+    }
+
+    @Bean
+    public TenantRoutingDataSource tenantRoutingDataSource(DataSource dataSource) {
+        return (TenantRoutingDataSource) dataSource;
+    }
+
+    @Bean
+    @Primary
+    public LocalContainerEntityManagerFactoryBean entityManagerFactory(DataSource dataSource) {
+        LocalContainerEntityManagerFactoryBean em = new LocalContainerEntityManagerFactoryBean();
+        em.setDataSource(dataSource);
+        em.setPackagesToScan("com.magistr.app.model");
+
+        HibernateJpaVendorAdapter vendorAdapter = new HibernateJpaVendorAdapter();
+        vendorAdapter.setGenerateDdl(false);
+        vendorAdapter.setDatabasePlatform("org.hibernate.dialect.PostgreSQLDialect");
+        em.setJpaVendorAdapter(vendorAdapter);
+
+        Map<String, Object> props = new HashMap<>();
+        props.put("hibernate.hbm2ddl.auto", "none");
+        props.put("hibernate.show_sql", "false");
+        em.setJpaPropertyMap(props);
+
+        return em;
+    }
+
+    @Bean
+    @Primary
+    public PlatformTransactionManager transactionManager(EntityManagerFactory emf) {
+        return new JpaTransactionManager(emf);
+    }
+
+    @org.springframework.context.annotation.Lazy
+    @org.springframework.beans.factory.annotation.Autowired
+    private TenantRoutingDataSource tenantRoutingDataSource;
+
+    @Bean
+    public TenantInterceptor tenantInterceptor(TenantRoutingDataSource routingDataSource) {
+        TenantInterceptor interceptor = new TenantInterceptor();
+        interceptor.setRoutingDataSource(routingDataSource);
+        return interceptor;
+    }
+
+    @Override
+    public void addInterceptors(InterceptorRegistry registry) {
+        // Вызываем метод-бин с переданным параметром (будет перехвачен CGLIB)
+        registry.addInterceptor(tenantInterceptor(tenantRoutingDataSource)).addPathPatterns("/**");
+    }
+
+    private List<TenantConfig> loadTenantsFromFile() {
+        File file = new File(tenantsConfigPath);
+        if (!file.exists()) {
+            log.info("Tenants config file not found: {}", tenantsConfigPath);
+            return new ArrayList<>();
+        }
+
+        try {
+            ObjectMapper mapper = new ObjectMapper();
+            List<TenantConfig> list = mapper.readValue(file, new TypeReference<>() {});
+            log.info("Loaded {} tenant(s) from {}", list.size(), tenantsConfigPath);
+            return list;
+        } catch (IOException e) {
+            log.error("Failed to read tenants config: {}", e.getMessage());
+            return new ArrayList<>();
+        }
+    }
+}

backend/src/main/java/com/magistr/app/config/tenant/TenantInterceptor.java

@@ -0,0 +1,99 @@
+package com.magistr.app.config.tenant;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import jakarta.servlet.http.HttpServletRequest;
+import jakarta.servlet.http.HttpServletResponse;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.web.servlet.HandlerInterceptor;
+
+import java.io.IOException;
+import java.util.Map;
+
+/**
+ * Interceptor: извлекает поддомен из Host header и кладёт в TenantContext.
+ * 
+ * Если тенант не настроен в TenantRoutingDataSource — 
+ * сразу возвращает HTTP 404 (не допускает fallback на чужой тенант).
+ *
+ * Примеры:
+ *   "swsu.zuev.company" → tenant = "swsu"
+ *   "mgu.zuev.company"  → tenant = "mgu"
+ *   "localhost"          → tenant = "default"
+ *   "localhost:8080"     → tenant = "default"
+ *
+ * API управления тенантами (/api/database/**) пропускается без проверки,
+ * чтобы администратор мог добавлять тенантов с любого домена.
+ */
+public class TenantInterceptor implements HandlerInterceptor {
+
+    private static final Logger log = LoggerFactory.getLogger(TenantInterceptor.class);
+
+    private TenantRoutingDataSource routingDataSource;
+
+    /**
+     * Устанавливается после создания бина (из TenantDataSourceConfig).
+     */
+    public void setRoutingDataSource(TenantRoutingDataSource routingDataSource) {
+        this.routingDataSource = routingDataSource;
+    }
+
+    @Override
+    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws IOException {
+        String host = request.getHeader("Host");
+        String tenant = resolveTenant(host);
+        String path = request.getRequestURI();
+
+        // API управления тенантами — всегда пропускаем
+        // (нужно чтобы админ мог добавить тенант даже если его домен не настроен)
+        if (path.startsWith("/api/database")) {
+            TenantContext.setCurrentTenant(tenant);
+            log.debug("Database API request, tenant '{}' (no strict check)", tenant);
+            return true;
+        }
+
+        // Проверяем, существует ли тенант
+        if (routingDataSource != null && !routingDataSource.hasTenant(tenant)) {
+            log.warn("Unknown tenant '{}' from Host '{}' — returning 404", tenant, host);
+            response.setStatus(404);
+            response.setContentType("application/json;charset=UTF-8");
+            new ObjectMapper().writeValue(response.getOutputStream(), Map.of(
+                "error", "Тенант не найден",
+                "tenant", tenant,
+                "message", "Домен " + host + " не настроен. Обратитесь к администратору."
+            ));
+            return false; // Останавливаем обработку запроса
+        }
+
+        TenantContext.setCurrentTenant(tenant);
+        log.debug("Resolved tenant '{}' from Host '{}'", tenant, host);
+        return true;
+    }
+
+    @Override
+    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) {
+        TenantContext.clear();
+    }
+
+    private String resolveTenant(String host) {
+        if (host == null || host.isBlank()) {
+            return "default";
+        }
+
+        // Убираем порт (localhost:8080 → localhost)
+        String hostname = host.contains(":") ? host.substring(0, host.indexOf(':')) : host;
+
+        // localhost или IP → default
+        if ("localhost".equalsIgnoreCase(hostname) || hostname.matches("\\d+\\.\\d+\\.\\d+\\.\\d+")) {
+            return "default";
+        }
+
+        // Извлекаем первый поддомен: swsu.zuev.company → swsu
+        int firstDot = hostname.indexOf('.');
+        if (firstDot > 0) {
+            return hostname.substring(0, firstDot).toLowerCase();
+        }
+
+        return "default";
+    }
+}

backend/src/main/java/com/magistr/app/config/tenant/TenantRoutingDataSource.java

@@ -0,0 +1,150 @@
+package com.magistr.app.config.tenant;
+
+import com.zaxxer.hikari.HikariDataSource;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource;
+
+import javax.sql.DataSource;
+import java.sql.Connection;
+import java.sql.SQLException;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+
+/**
+ * DataSource, который переключается между БД разных тенантов.
+ * На каждый запрос determineCurrentLookupKey() возвращает текущий тенант из TenantContext.
+ */
+public class TenantRoutingDataSource extends AbstractRoutingDataSource {
+
+    private static final Logger log = LoggerFactory.getLogger(TenantRoutingDataSource.class);
+
+    private final Map<String, TenantConfig> tenantConfigs = new ConcurrentHashMap<>();
+    private final Map<Object, Object> dataSources = new ConcurrentHashMap<>();
+    private boolean initialized = false;
+
+    public TenantRoutingDataSource() {
+        // Устанавливаем пустой map чтобы afterPropertiesSet не падал
+        setTargetDataSources(new HashMap<>());
+        setLenientFallback(false);
+    }
+
+    @Override
+    protected Object determineCurrentLookupKey() {
+        String tenant = TenantContext.getCurrentTenant();
+
+        if (tenant == null) {
+            // Нет HTTP контекста (JPA init, background tasks) — берём первый доступный
+            if (!dataSources.isEmpty()) {
+                return dataSources.keySet().iterator().next().toString();
+            }
+            return "default";
+        }
+
+        // HTTP запрос — возвращаем точный ключ тенанта
+        // Если тенанта нет — TenantInterceptor уже вернул 404
+        return tenant;
+    }
+
+    /**
+     * Добавляет тенант и создаёт для него HikariCP пул.
+     */
+    public void addTenant(TenantConfig config) {
+        String domain = config.getDomain().toLowerCase();
+        HikariDataSource ds = createDataSource(config);
+
+        dataSources.put(domain, ds);
+        tenantConfigs.put(domain, config);
+
+        // Обновляем target data sources
+        setTargetDataSources(dataSources);
+        afterPropertiesSet();
+        initialized = true;
+
+        log.info("Added tenant '{}' -> {}", domain, config.getUrl());
+    }
+
+    /**
+     * Удаляет тенант и закрывает его пул соединений.
+     */
+    public void removeTenant(String domain) {
+        domain = domain.toLowerCase();
+        Object removed = dataSources.remove(domain);
+        tenantConfigs.remove(domain);
+
+        if (removed instanceof HikariDataSource ds) {
+            ds.close();
+            log.info("Removed and closed tenant '{}'", domain);
+        }
+
+        setTargetDataSources(dataSources);
+        afterPropertiesSet();
+    }
+
+    /**
+     * Проверяет подключение к БД для указанного тенанта.
+     */
+    public boolean testConnection(String domain) {
+        DataSource ds = (DataSource) dataSources.get(domain.toLowerCase());
+        if (ds == null) return false;
+
+        try (Connection conn = ds.getConnection()) {
+            return conn.isValid(5);
+        } catch (SQLException e) {
+            log.warn("Connection test failed for tenant '{}': {}", domain, e.getMessage());
+            return false;
+        }
+    }
+
+    /**
+     * Тестирует подключение по произвольным параметрам (без регистрации тенанта).
+     */
+    public String testExternalConnection(String url, String username, String password) {
+        HikariDataSource ds = new HikariDataSource();
+        ds.setJdbcUrl(url);
+        ds.setUsername(username);
+        ds.setPassword(password);
+        ds.setMaximumPoolSize(1);
+        ds.setConnectionTimeout(5000);
+
+        try (Connection conn = ds.getConnection()) {
+            if (conn.isValid(5)) {
+                return "OK";
+            }
+            return "Подключение не валидно";
+        } catch (Exception e) {
+            return e.getMessage();
+        } finally {
+            ds.close();
+        }
+    }
+
+    public Map<String, TenantConfig> getTenantConfigs() {
+        return tenantConfigs;
+    }
+
+    public boolean hasTenant(String domain) {
+        return tenantConfigs.containsKey(domain.toLowerCase());
+    }
+
+    public boolean isInitialized() {
+        return initialized && !dataSources.isEmpty();
+    }
+
+    private HikariDataSource createDataSource(TenantConfig config) {
+        HikariDataSource ds = new HikariDataSource();
+        ds.setJdbcUrl(config.getUrl());
+        ds.setUsername(config.getUsername());
+        ds.setPassword(config.getPassword());
+        ds.setPoolName("tenant-" + config.getDomain());
+        ds.setMaximumPoolSize(10);
+        ds.setMinimumIdle(2);
+        ds.setConnectionTimeout(10000);
+        ds.setIdleTimeout(300000);
+        ds.setMaxLifetime(600000);
+        // Не падать при инициализации если БД недоступна
+        ds.setInitializationFailTimeout(-1);
+        return ds;
+    }
+}

backend/src/main/java/com/magistr/app/controller/DatabaseController.java

@@ -0,0 +1,181 @@
+package com.magistr.app.controller;
+
+import com.magistr.app.config.tenant.ConfigMapUpdater;
+import com.magistr.app.config.tenant.TenantConfig;
+import com.magistr.app.config.tenant.TenantConfigWatcher;
+import com.magistr.app.config.tenant.TenantContext;
+import com.magistr.app.config.tenant.TenantRoutingDataSource;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * API управления подключениями к базам данных (тенантами).
+ * Доступно только для ADMIN.
+ *
+ * При добавлении/удалении тенанта:
+ * 1. Обновляется in-memory DataSource (мгновенно на этом поде)
+ * 2. Обновляется K8s ConfigMap (через ConfigMapUpdater)
+ * 3. Другие поды подхватят изменения через TenantConfigWatcher (~30 сек)
+ */
+@RestController
+@RequestMapping("/api/database")
+public class DatabaseController {
+
+    private final TenantRoutingDataSource routingDataSource;
+    private final ConfigMapUpdater configMapUpdater;
+    private final TenantConfigWatcher configWatcher;
+
+    public DatabaseController(TenantRoutingDataSource routingDataSource,
+                              ConfigMapUpdater configMapUpdater,
+                              TenantConfigWatcher configWatcher) {
+        this.routingDataSource = routingDataSource;
+        this.configMapUpdater = configMapUpdater;
+        this.configWatcher = configWatcher;
+    }
+
+    /**
+     * Статус текущего подключения (по домену запроса).
+     */
+    @GetMapping("/status")
+    public ResponseEntity<Map<String, Object>> getStatus() {
+        String currentTenant = TenantContext.getCurrentTenant();
+        boolean connected = routingDataSource.testConnection(currentTenant);
+
+        TenantConfig config = routingDataSource.getTenantConfigs().get(currentTenant);
+
+        Map<String, Object> result = new HashMap<>();
+        result.put("tenant", currentTenant);
+        result.put("connected", connected);
+        result.put("configured", config != null);
+        if (config != null) {
+            result.put("name", config.getName());
+            result.put("url", config.getUrl());
+        }
+        return ResponseEntity.ok(result);
+    }
+
+    /**
+     * Список всех тенантов.
+     */
+    @GetMapping("/tenants")
+    public ResponseEntity<List<Map<String, Object>>> getTenants() {
+        List<Map<String, Object>> result = new ArrayList<>();
+
+        for (TenantConfig config : routingDataSource.getTenantConfigs().values()) {
+            Map<String, Object> tenant = new HashMap<>();
+            tenant.put("name", config.getName());
+            tenant.put("domain", config.getDomain());
+            tenant.put("url", config.getUrl());
+            tenant.put("username", config.getUsername());
+            tenant.put("connected", routingDataSource.testConnection(config.getDomain()));
+            result.add(tenant);
+        }
+
+        return ResponseEntity.ok(result);
+    }
+
+    /**
+     * Добавить новый тенант.
+     */
+    @PostMapping("/tenants")
+    public ResponseEntity<Map<String, Object>> addTenant(@RequestBody TenantConfig config) {
+        Map<String, Object> result = new HashMap<>();
+
+        if (config.getDomain() == null || config.getDomain().isBlank()) {
+            result.put("success", false);
+            result.put("message", "Домен не может быть пустым");
+            return ResponseEntity.badRequest().body(result);
+        }
+
+        if (config.getUrl() == null || config.getUrl().isBlank()) {
+            result.put("success", false);
+            result.put("message", "URL базы данных не может быть пустым");
+            return ResponseEntity.badRequest().body(result);
+        }
+
+        if (routingDataSource.hasTenant(config.getDomain())) {
+            routingDataSource.removeTenant(config.getDomain());
+        }
+
+        try {
+            // 1. Добавить в in-memory (мгновенно на этом поде)
+            routingDataSource.addTenant(config);
+
+            // 2. Инициализировать БД (init.sql) если нужно
+            configWatcher.initDatabaseForTenant(config);
+
+            // 3. Обновить K8s ConfigMap (другие поды подхватят через ~30 сек)
+            persistToConfigMap();
+
+            result.put("success", true);
+            result.put("message", "Тенант '" + config.getDomain() + "' добавлен");
+            return ResponseEntity.ok(result);
+        } catch (Exception e) {
+            result.put("success", false);
+            result.put("message", "Ошибка: " + e.getMessage());
+            return ResponseEntity.internalServerError().body(result);
+        }
+    }
+
+    /**
+     * Удалить тенант.
+     */
+    @DeleteMapping("/tenants/{domain}")
+    public ResponseEntity<Map<String, Object>> removeTenant(@PathVariable String domain) {
+        Map<String, Object> result = new HashMap<>();
+
+        if (!routingDataSource.hasTenant(domain)) {
+            result.put("success", false);
+            result.put("message", "Тенант '" + domain + "' не найден");
+            return ResponseEntity.status(404).body(result);
+        }
+
+        routingDataSource.removeTenant(domain);
+        persistToConfigMap();
+
+        result.put("success", true);
+        result.put("message", "Тенант '" + domain + "' удалён");
+        return ResponseEntity.ok(result);
+    }
+
+    /**
+     * Тест подключения к произвольной БД.
+     */
+    @PostMapping("/test")
+    public ResponseEntity<Map<String, Object>> testConnection(@RequestBody Map<String, String> params) {
+        String url = params.get("url");
+        String username = params.get("username");
+        String password = params.get("password");
+
+        Map<String, Object> result = new HashMap<>();
+
+        if (url == null || url.isBlank()) {
+            result.put("success", false);
+            result.put("message", "URL не указан");
+            return ResponseEntity.badRequest().body(result);
+        }
+
+        String testResult = routingDataSource.testExternalConnection(url, username, password);
+        boolean success = "OK".equals(testResult);
+
+        result.put("success", success);
+        result.put("message", success ? "Подключение успешно!" : testResult);
+        return ResponseEntity.ok(result);
+    }
+
+    /**
+     * Сохраняет текущий список тенантов в K8s ConfigMap.
+     */
+    private void persistToConfigMap() {
+        List<TenantConfig> tenants = new ArrayList<>(routingDataSource.getTenantConfigs().values());
+        boolean ok = configMapUpdater.updateTenantsConfig(tenants);
+        if (ok) {
+            configWatcher.refreshHash(); // Чтобы watcher не перезагрузил те же данные
+        }
+    }
+}

backend/src/main/resources/application.properties

@@ -1,15 +1,18 @@
 server.port=8080
 
-# PostgreSQL
+# PostgreSQL (дефолтный — для локальной разработки через Docker Compose)
 spring.datasource.url=jdbc:postgresql://db:5432/app_db
-spring.datasource.username=${POSTGRES_USER}
+spring.datasource.username=${POSTGRES_USER:myuser}
-spring.datasource.password=${POSTGRES_PASSWORD}
+spring.datasource.password=${POSTGRES_PASSWORD:supersecretpassword}
 spring.datasource.driver-class-name=org.postgresql.Driver
 
 # JPA
-spring.jpa.hibernate.ddl-auto=validate
+spring.jpa.hibernate.ddl-auto=update
 spring.jpa.show-sql=false
 spring.jpa.open-in-view=false
 
-#Eta nastroyka otvechayet za vklyucheniye vidimosti logov urovnya DEBUG v logakh BE, poka vyklyuchil chtoby ne zasoryat'. Zapisi INFO otobrazhat'sya budut
+# Мультитенантность
+app.tenants.config-path=${TENANTS_CONFIG_PATH:tenants.json}
+
 #logging.level.root=DEBUG
+

backend/tenants.json

@@ -0,0 +1,9 @@
+[
+  {
+    "name": "Default (dev)",
+    "domain": "default",
+    "url": "jdbc:postgresql://db:5432/app_db",
+    "username": "myuser",
+    "password": "supersecretpassword"
+  }
+]

compose.yaml

@@ -10,9 +10,7 @@ services:
       POSTGRES_PASSWORD: ${POSTGRES_PASSWORD}
     networks:
       - proxy
-    depends_on:
+
-      db:
-        condition: service_healthy
   frontend:
     container_name: frontend
     restart: always
@@ -23,6 +21,7 @@ services:
       - proxy
     depends_on:
       - backend
+
   db:
     image: postgres:alpine3.23
     container_name: db
@@ -30,21 +29,12 @@ services:
     ports:
       - "5432:5432"
     environment:
-      POSTGRES_USER: ${POSTGRES_USER}
+      POSTGRES_USER: myuser
-      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD}
+      POSTGRES_PASSWORD: supersecretpassword
       POSTGRES_DB: app_db
-    volumes:
-      - ./db/data:/var/lib/postgresql
-      - ./db/init:/docker-entrypoint-initdb.d:ro
     networks:
       - proxy
-    healthcheck:
+
-      test:
-        - CMD-SHELL
-        - pg_isready -U ${POSTGRES_USER} -d app_db
-      interval: 10s
-      timeout: 5s
-      retries: 5
 networks:
   proxy:
     external: true

frontend/admin/index.html

@@ -96,6 +96,14 @@
                 </svg>
                 Расписание занятий
             </a>
+            <a href="#" class="nav-item" data-tab="database">
+                <svg width="20" height="20" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+                    <ellipse cx="12" cy="5" rx="9" ry="3"></ellipse>
+                    <path d="M21 12c0 1.66-4 3-9 3s-9-1.34-9-3"></path>
+                    <path d="M3 5v14c0 1.66 4 3 9 3s9-1.34 9-3V5"></path>
+                </svg>
+                База данных
+            </a>
         </nav>
         <div class="sidebar-footer">
             <button class="btn-logout" id="btn-logout">

frontend/admin/js/main.js

@@ -8,6 +8,7 @@ import { initEquipments } from './views/equipments.js';
 import { initClassrooms } from './views/classrooms.js';
 import { initSubjects } from './views/subjects.js';
 import {initSchedule} from "./views/schedule.js";
+import {initDatabase} from "./views/database.js";
 
 // Configuration
 const ROUTES = {
@@ -17,8 +18,8 @@ const ROUTES = {
     equipments: { title: 'Оборудование', file: 'views/equipments.html', init: initEquipments },
     classrooms: { title: 'Аудитории', file: 'views/classrooms.html', init: initClassrooms },
     subjects: { title: 'Дисциплины и преподаватели', file: 'views/subjects.html', init: initSubjects },
-    // Новая вкладка
     schedule: { title: 'Расписание занятий', file: 'views/schedule.html', init: initSchedule },
+    database: { title: 'База данных', file: 'views/database.html', init: initDatabase },
 };
 
 let currentTab = null;

frontend/admin/js/views/database.js

@@ -0,0 +1,157 @@
+import { api } from '../api.js';
+import { escapeHtml, showAlert, hideAlert } from '../utils.js';
+
+export async function initDatabase() {
+    const tenantsTbody = document.getElementById('tenants-tbody');
+    const addTenantForm = document.getElementById('add-tenant-form');
+    const statusInfo = document.getElementById('db-status-info');
+    const btnTest = document.getElementById('btn-test-connection');
+
+    // === Загрузка статуса текущего подключения ===
+    async function loadStatus() {
+        try {
+            const data = await api.get('/api/database/status');
+            const statusBadge = data.connected
+                ? '<span class="badge badge-available">Online</span>'
+                : '<span class="badge badge-unavailable">Offline</span>';
+
+            statusInfo.innerHTML = `
+                <div style="display: flex; align-items: center; gap: 1rem; flex-wrap: wrap;">
+                    <div>
+                        <span style="color: var(--text-secondary); font-size: 0.85rem;">Тенант:</span>
+                        <strong>${escapeHtml(data.tenant || '—')}</strong>
+                    </div>
+                    <div>
+                        <span style="color: var(--text-secondary); font-size: 0.85rem;">Название:</span>
+                        <strong>${escapeHtml(data.name || '—')}</strong>
+                    </div>
+                    <div>
+                        <span style="color: var(--text-secondary); font-size: 0.85rem;">Статус:</span>
+                        ${statusBadge}
+                    </div>
+                    ${data.url ? `<div>
+                        <span style="color: var(--text-secondary); font-size: 0.85rem;">URL:</span>
+                        <code style="font-size: 0.85rem;">${escapeHtml(data.url)}</code>
+                    </div>` : ''}
+                </div>
+            `;
+        } catch (e) {
+            statusInfo.innerHTML = `<div class="form-alert error" style="display:block">Ошибка загрузки статуса: ${e.message}</div>`;
+        }
+    }
+
+    // === Загрузка списка тенантов ===
+    async function loadTenants() {
+        try {
+            const tenants = await api.get('/api/database/tenants');
+            renderTenantsTable(tenants);
+        } catch (e) {
+            tenantsTbody.innerHTML = `<tr><td colspan="6" class="loading-row">Ошибка загрузки: ${e.message}</td></tr>`;
+        }
+    }
+
+    function renderTenantsTable(tenants) {
+        if (!tenants || !tenants.length) {
+            tenantsTbody.innerHTML = '<tr><td colspan="6" class="loading-row">Нет подключённых тенантов</td></tr>';
+            return;
+        }
+
+        tenantsTbody.innerHTML = tenants.map(t => {
+            const statusBadge = t.connected
+                ? '<span class="badge badge-available">Online</span>'
+                : '<span class="badge badge-unavailable">Offline</span>';
+
+            return `
+            <tr>
+                <td>${escapeHtml(t.name || '—')}</td>
+                <td><code>${escapeHtml(t.domain)}</code></td>
+                <td><code style="font-size: 0.82rem;">${escapeHtml(t.url)}</code></td>
+                <td>${escapeHtml(t.username || '—')}</td>
+                <td>${statusBadge}</td>
+                <td><button class="btn-delete" data-domain="${escapeHtml(t.domain)}">Удалить</button></td>
+            </tr>`;
+        }).join('');
+    }
+
+    // === Тест подключения ===
+    btnTest.addEventListener('click', async () => {
+        hideAlert('add-tenant-alert');
+        const url = document.getElementById('tenant-url').value.trim();
+        const username = document.getElementById('tenant-username').value.trim();
+        const password = document.getElementById('tenant-password').value;
+
+        if (!url) {
+            showAlert('add-tenant-alert', 'Введите JDBC URL', 'error');
+            return;
+        }
+
+        btnTest.textContent = '...';
+        btnTest.disabled = true;
+
+        try {
+            const result = await api.post('/api/database/test', { url, username, password });
+            if (result.success) {
+                showAlert('add-tenant-alert', '✓ Подключение успешно!', 'success');
+            } else {
+                showAlert('add-tenant-alert', `✗ ${result.message}`, 'error');
+            }
+        } catch (e) {
+            showAlert('add-tenant-alert', `Ошибка: ${e.message}`, 'error');
+        } finally {
+            btnTest.textContent = 'Тест';
+            btnTest.disabled = false;
+        }
+    });
+
+    // === Добавление тенанта ===
+    addTenantForm.addEventListener('submit', async (e) => {
+        e.preventDefault();
+        hideAlert('add-tenant-alert');
+
+        const name = document.getElementById('tenant-name').value.trim();
+        const domain = document.getElementById('tenant-domain').value.trim().toLowerCase();
+        const url = document.getElementById('tenant-url').value.trim();
+        const username = document.getElementById('tenant-username').value.trim();
+        const password = document.getElementById('tenant-password').value;
+
+        if (!name || !domain || !url) {
+            showAlert('add-tenant-alert', 'Заполните все обязательные поля', 'error');
+            return;
+        }
+
+        try {
+            const result = await api.post('/api/database/tenants', { name, domain, url, username, password });
+            if (result.success) {
+                showAlert('add-tenant-alert', `Тенант "${escapeHtml(domain)}" добавлен!`, 'success');
+                addTenantForm.reset();
+                loadTenants();
+                loadStatus();
+            } else {
+                showAlert('add-tenant-alert', result.message, 'error');
+            }
+        } catch (e) {
+            showAlert('add-tenant-alert', `Ошибка: ${e.message}`, 'error');
+        }
+    });
+
+    // === Удаление тенанта ===
+    tenantsTbody.addEventListener('click', async (e) => {
+        const btn = e.target.closest('.btn-delete');
+        if (!btn) return;
+
+        const domain = btn.dataset.domain;
+        if (!confirm(`Удалить тенант "${domain}"? Пул соединений будет закрыт.`)) return;
+
+        try {
+            await api.delete(`/api/database/tenants/${domain}`);
+            loadTenants();
+            loadStatus();
+        } catch (e) {
+            alert(`Ошибка: ${e.message}`);
+        }
+    });
+
+    // === Init ===
+    loadStatus();
+    loadTenants();
+}

frontend/admin/views/database.html

@@ -0,0 +1,73 @@
+<!-- ===== Database / Tenants Tab ===== -->
+
+<!-- Текущее подключение -->
+<div class="card">
+    <h2>Текущее подключение</h2>
+    <div id="db-status-info" class="db-status-card">
+        <div class="loading-row">Загрузка...</div>
+    </div>
+</div>
+
+<!-- Таблица тенантов -->
+<div class="card">
+    <h2>Подключённые университеты</h2>
+    <div class="table-wrap">
+        <table id="tenants-table">
+            <thead>
+                <tr>
+                    <th>Название</th>
+                    <th>Домен</th>
+                    <th>JDBC URL</th>
+                    <th>Пользователь</th>
+                    <th>Статус</th>
+                    <th>Действия</th>
+                </tr>
+            </thead>
+            <tbody id="tenants-tbody">
+                <tr>
+                    <td colspan="6" class="loading-row">Загрузка...</td>
+                </tr>
+            </tbody>
+        </table>
+    </div>
+</div>
+
+<!-- Добавить тенант -->
+<div class="card create-card">
+    <h2>Добавить подключение</h2>
+    <form id="add-tenant-form">
+        <div class="form-row">
+            <div class="form-group">
+                <label for="tenant-name">Название университета</label>
+                <input type="text" id="tenant-name" placeholder="ЮЗГУ" required>
+            </div>
+            <div class="form-group">
+                <label for="tenant-domain">Поддомен</label>
+                <input type="text" id="tenant-domain" placeholder="swsu" required>
+            </div>
+        </div>
+        <div class="form-row" style="margin-top: 0.75rem;">
+            <div class="form-group" style="flex: 3;">
+                <label for="tenant-url">JDBC URL</label>
+                <input type="text" id="tenant-url" placeholder="jdbc:postgresql://192.168.1.50:5432/magistr_db" required>
+            </div>
+        </div>
+        <div class="form-row" style="margin-top: 0.75rem;">
+            <div class="form-group">
+                <label for="tenant-username">Пользователь</label>
+                <input type="text" id="tenant-username" placeholder="postgres" required>
+            </div>
+            <div class="form-group">
+                <label for="tenant-password">Пароль</label>
+                <input type="password" id="tenant-password" placeholder="••••••••" required>
+            </div>
+            <button type="button" class="btn-primary" id="btn-test-connection" style="height: fit-content;">
+                Тест
+            </button>
+            <button type="submit" class="btn-primary" style="height: fit-content;">
+                Добавить
+            </button>
+        </div>
+        <div class="form-alert" id="add-tenant-alert" role="alert"></div>
+    </form>
+</div>