Add file info public

# Conflicts:
#	src/main/java/ru/soune/nocopy/controller/ApiController.java
#	src/main/java/ru/soune/nocopy/repository/FileEntityRepository.java
#	src/main/java/ru/soune/nocopy/service/file/impl/FileUploadServiceImpl.java

.env

@@ -1,10 +1,19 @@
+# Postgres
 POSTGRES_DB=no_copy_
-POSTGRES_USER=postgres
-POSTGRES_PASSWORD=postgres
+POSTGRES_USER=ncp_db
+POSTGRES_PASSWORD=ncpDbApp
 POSTGRES_PORT=5432
 POSTGRES_HOST=postgres
 
+# Redis
 REDIS_HOST=redis
 REDIS_PORT=6379
 
+# Backend server
 SERVER_PORT=8080
+
+# Postfix
+MAIL_HOST_PROD=postfix-production
+MAIL_PORT_PROD=25
+MAIL_USERNAME_PROD=noreply@nocopy.com
+SMTP_PASSWORD_PROD=nocopy!nocopy!

.gitea/workflows/job.yaml

@@ -0,0 +1,17 @@
+name: Test Workflow
+
+on:
+  push:
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Print environment variables
+        run: |
+          echo "GITHUB_REPOSITORY: $GITHUB_REPOSITORY"  
+          echo "GITHUB_SHA: $GITHUB_SHA"  
+          echo "GITHUB_REF: $GITHUB_REF"  
+          echo "GITHUB_ACTOR: $GITHUB_ACTOR"  
+          echo "PATH: $PATH"

Dockerfile

@@ -12,6 +12,11 @@ WORKDIR /app
 
 COPY --from=build /app/build/libs/*.jar app.jar
 
+RUN mkdir -p /data/uploads && chmod 755 /data/uploads
+
+ENV BUILD_TIME_BACK="unknown"\
+    BUILD_TIME_FRONT="unknown"
+
 EXPOSE 8080
 
-CMD ["java", "-jar", "app.jar"]
+CMD ["java", "-jar", "app.jar"]

README.md

@@ -0,0 +1,503 @@
+Создаем сеть:
+docker network create app-network
+
+Войти в БД:
+docker exec -it postgres psql -U ncp_db -d no_copy_
+
+Выполнить команду:
+\du
+
+Должен быть один пользователь:
+                                    List of roles
+Role name |                         Attributes
+-----------+------------------------------------------------------------
+ncp_db    | Superuser, Create role, Create DB, Replication, Bypass RLS
+
+суперпользователь БД:
+postgres/postgres 
+пользователь бд для бэка
+ncp_db / ncpDbApp
+
+Подключение к БД для приложения,если volume не существует :
+
+Создаться автоматически.
+
+Если уже существует volume :
+
+docker exec -it postgres psql -U postgres -d postgres
+
+CREATE USER ncp_db WITH PASSWORD 'ncpDbApp';
+
+GRANT ALL PRIVILEGES ON DATABASE no_copy_ TO ncp_db;
+
+\du
+
+\q
+
+-------
+
+psql -U postgres -d no_copy_
+
+-- база
+
+GRANT CONNECT ON DATABASE no_copy_ TO ncp_db;
+
+-- схема
+
+GRANT USAGE ON SCHEMA public TO ncp_db;
+
+-- существующие таблицы
+
+GRANT ALL PRIVILEGES ON ALL TABLES IN SCHEMA public TO ncp_db;
+
+-- существующие sequence (очень важно для id)
+
+GRANT ALL PRIVILEGES ON ALL SEQUENCES IN SCHEMA public TO ncp_db;
+
+-- будущие таблицы
+
+ALTER DEFAULT PRIVILEGES IN SCHEMA public
+GRANT ALL ON TABLES TO ncp_db;
+
+ALTER DEFAULT PRIVILEGES IN SCHEMA public
+GRANT ALL ON SEQUENCES TO ncp_db;
+
+
+Зайти в контейнер:
+docker exec -it {name} bash
+
+------
+
+Создать для сущности FileEntity sequence для икремента индетификатора
+
+CREATE SEQUENCE IF NOT EXISTS file_support_id_seq START 1;
+
+ALTER TABLE file_entities
+ALTER COLUMN support_id
+SET DEFAULT nextval('file_support_id_seq');
+
+----------
+Раздать всем лимиты,у кого их нет
+
+INSERT INTO protect_check (user_id, check_limit, count_checked, last_check_at, version)
+SELECT
+id as user_id,
+10 as check_limit, 
+0 as count_checked,
+NULL as last_check_at,
+0 as version
+FROM users
+WHERE id NOT IN (SELECT user_id FROM protect_check);
+
+--------
+Обновлять констрейнты для file_entities
+
+ALTER TABLE file_entities DROP CONSTRAINT file_entities_status_check;
+
+ALTER TABLE file_entities
+ADD CONSTRAINT file_entities_status_check
+CHECK (status IN (
+'ACTIVE',
+'DELETED',
+'PROCESSING',
+'VIOLATION',
+'CHECKED',
+'ERROR',
+'TEMP'  
+));
+
+-------
+Записи для лимитов поиска
+
+INSERT INTO protect_check (user_id, limit_check, count_checked, last_check_at, version)
+SELECT
+u.id,
+100, -- limit_check = 100
+0,   -- count_checked = 0
+NULL, -- last_check_at = NULL
+0    -- version = 0
+FROM users u
+WHERE NOT EXISTS (
+SELECT 1
+FROM protect_check pc
+WHERE pc.user_id = u.id
+);
+
+
+------
+Скрипты рефералки
+
+INSERT INTO referrals (user_id, referral_link, inviter_id, level_id, total_income, is_active, created_at, hold_balance)
+SELECT
+u.id as user_id,
+CONCAT('ref-', u.id, '-', LOWER(SUBSTRING(MD5(RANDOM()::text) FROM 1 FOR 8))) as referral_link,
+NULL as inviter_id,
+'bronze' as level_id,
+0 as total_income,
+false as is_active,
+NOW() as created_at,
+0 as hold_balance
+FROM users u
+LEFT JOIN referrals r ON u.id = r.user_id
+WHERE
+u.company_id IS NULL
+AND r.user_id IS NULL
+ORDER BY u.id;
+
+-------
+
+INSERT INTO referral_levels (id, name, min_invitees, reward_percentage) VALUES
+('bronze', 'BRONZE', 0, 15),
+('silver', 'SILVER', 6, 18),
+('gold', 'GOLD', 16, 22),
+('platinum', 'PLATINUM', 50, 25);
+
+-----------------
+Скрипт,для нумерации для уже сохданных файлов
+WITH max_id AS (
+SELECT COALESCE(MAX(support_id), 0) as max_val FROM file_entities
+),
+-- Нумеруем только NULL записи, начиная с max_val + 1
+numbered AS (
+SELECT
+f.id,
+(SELECT max_val FROM max_id) + ROW_NUMBER() OVER (ORDER BY f.created_at, f.id) as new_support_id
+FROM file_entities f
+WHERE f.support_id IS NULL
+)
+UPDATE file_entities
+SET support_id = numbered.new_support_id
+FROM numbered
+WHERE file_entities.id = numbered.id;
+
+---------------------------------
+НАСТРОЙКА NGINX
+--------------------------------
+
+# admin.not-copy.com
+server {
+listen 80;
+listen [::]:80;
+server_name admin.not-copy.com;
+return 301 https://$server_name$request_uri;
+}
+
+server {
+listen 443 ssl;
+listen [::]:443 ssl;
+server_name admin.not-copy.com;
+
+    ssl_certificate /etc/letsencrypt/live/admin.not-copy.com/fullchain.pem;
+    ssl_certificate_key /etc/letsencrypt/live/admin.not-copy.com/privkey.pem;
+
+    location /api/ {
+        proxy_pass http://localhost:3003;
+        proxy_set_header Host $host;
+        proxy_set_header X-Real-IP $remote_addr;
+        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+        proxy_set_header X-Forwarded-Proto $scheme;
+    }
+
+    location / {
+        proxy_pass http://localhost:2995;
+        proxy_set_header Host $host;
+        proxy_set_header X-Real-IP $remote_addr;
+        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+        proxy_set_header X-Forwarded-Proto $scheme;
+    }
+}
+
+# workspace.not-copy.com
+server {
+listen 80;
+listen [::]:80;
+server_name workspace.not-copy.com;
+return 301 https://$server_name$request_uri;
+}
+
+server {
+listen 443 ssl;
+listen [::]:443 ssl;
+server_name workspace.not-copy.com;
+
+    ssl_certificate /etc/letsencrypt/live/workspace.not-copy.com/fullchain.pem;
+    ssl_certificate_key /etc/letsencrypt/live/workspace.not-copy.com/privkey.pem;
+
+    location /api/ {
+        proxy_pass http://localhost:3003;
+        proxy_set_header Host $host;
+        proxy_set_header X-Real-IP $remote_addr;
+        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+        proxy_set_header X-Forwarded-Proto $scheme;
+    }
+
+    location / {
+        proxy_pass http://localhost:2998;
+        proxy_set_header Host $host;
+        proxy_set_header X-Real-IP $remote_addr;
+        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+        proxy_set_header X-Forwarded-Proto $scheme;
+    }
+}
+
+# lp.not-copy.com
+server {
+listen 80;
+listen [::]:80;
+server_name lp.not-copy.com;
+return 301 https://$server_name$request_uri;
+}
+
+server {
+listen 443 ssl;
+listen [::]:443 ssl;
+server_name lp.not-copy.com;
+
+    ssl_certificate /etc/letsencrypt/live/lp.not-copy.com/fullchain.pem;
+    ssl_certificate_key /etc/letsencrypt/live/lp.not-copy.com/privkey.pem;
+
+    location /api/ {
+        proxy_pass http://localhost:3003;
+        proxy_set_header Host $host;
+        proxy_set_header X-Real-IP $remote_addr;
+        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+        proxy_set_header X-Forwarded-Proto $scheme;
+    }
+
+    location / {
+        proxy_pass http://localhost:2993;
+        proxy_set_header Host $host;
+        proxy_set_header X-Real-IP $remote_addr;
+        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+        proxy_set_header X-Forwarded-Proto $scheme;
+    }
+}
+
+# dev-admin.not-copy.com
+server {
+listen 80;
+listen [::]:80;
+server_name dev-admin.not-copy.com;
+return 301 https://$server_name$request_uri;
+}
+
+server {
+listen 443 ssl;
+listen [::]:443 ssl;
+server_name dev-admin.not-copy.com;
+
+    ssl_certificate /etc/letsencrypt/live/dev-admin.not-copy.com/fullchain.pem;
+    ssl_certificate_key /etc/letsencrypt/live/dev-admin.not-copy.com/privkey.pem;
+
+    location /api/ {
+        proxy_pass http://localhost:8082;
+        proxy_set_header Host $host;
+        proxy_set_header X-Real-IP $remote_addr;
+        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+        proxy_set_header X-Forwarded-Proto $scheme;
+    }
+
+    location / {
+        proxy_pass http://localhost:2996;
+        proxy_set_header Host $host;
+        proxy_set_header X-Real-IP $remote_addr;
+        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+        proxy_set_header X-Forwarded-Proto $scheme;
+    }
+}
+
+# dev-workspace.not-copy.com
+server {
+listen 80;
+listen [::]:80;
+server_name dev-workspace.not-copy.com;
+return 301 https://$server_name$request_uri;
+}
+
+server {
+listen 443 ssl;
+listen [::]:443 ssl;
+server_name dev-workspace.not-copy.com;
+
+    ssl_certificate /etc/letsencrypt/live/dev-workspace.not-copy.com/fullchain.pem;
+    ssl_certificate_key /etc/letsencrypt/live/dev-workspace.not-copy.com/privkey.pem;
+
+    location /api/ {
+
+        proxy_pass http://localhost:3001;
+        proxy_set_header Host $host;
+        proxy_set_header X-Real-IP $remote_addr;
+        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+        proxy_set_header X-Forwarded-Proto $scheme;
+    }
+
+    location / {
+        proxy_pass http://localhost:3002;
+        proxy_set_header Host $host;
+        proxy_set_header X-Real-IP $remote_addr;
+        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+        proxy_set_header X-Forwarded-Proto $scheme;
+    }
+}
+
+# dev-lp.not-copy.com
+server {
+listen 80;
+listen [::]:80;
+server_name dev-lp.not-copy.com;
+return 301 https://$server_name$request_uri;
+}
+
+server {
+listen 443 ssl;
+listen [::]:443 ssl;
+server_name dev-lp.not-copy.com;
+
+    ssl_certificate /etc/letsencrypt/live/dev-lp.not-copy.com/fullchain.pem;
+    ssl_certificate_key /etc/letsencrypt/live/dev-lp.not-copy.com/privkey.pem;
+
+    location /api/ {
+        proxy_pass http://localhost:3001;
+        proxy_set_header Host $host;
+        proxy_set_header X-Real-IP $remote_addr;
+        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+        proxy_set_header X-Forwarded-Proto $scheme;
+    }
+
+    location / {
+        proxy_pass http://localhost:2994;
+        proxy_set_header Host $host;
+        proxy_set_header X-Real-IP $remote_addr;
+        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+        proxy_set_header X-Forwarded-Proto $scheme;
+    }
+}
+
+
+# Проверяем конфиг
+ls -la /etc/nginx/sites-available/
+ls -la /etc/nginx/sites-enabled/
+
+# Создание конфига
+
+sudo nano /etc/nginx/sites-available/not-copy
+
+# Создание симлинк
+sudo ln -s /etc/nginx/sites-available/not-copy /etc/nginx/sites-enabled/
+
+# Чек
+sudo nginx -t
+
+# Рестарт
+sudo systemctl reload nginx
+
+
+---------------------------------------------
+
+# ПОЛНАЯ ИНСТРУКЦИЯ: НАСТРОЙКА ПРОКСИ ДЛЯ ОБХОДА БЛОКИРОВОК SEARCHAPI.IO
+
+## Данные для подключения к прокси-серверу
+IP: 193.46.217.94
+Порт HTTP: 3128
+Порт SOCKS: 1080
+Логин SSH: root
+Пароль SSH: u7nRtsD6
+
+## 1. Настройка прокси-сервера 
+```bash
+# Подключаемся к серверу
+ssh root@193.46.217.94
+# Вводим пароль: u7nRtsD6
+
+# Обновляем систему и устанавливаем пакеты
+yum update -y
+yum install -y epel-release net-tools nano
+yum install -y 3proxy
+
+# Создаем конфигурацию
+mkdir -p /etc/3proxy
+cat > /etc/3proxy/3proxy.cfg << 'EOF'
+nserver 8.8.8.8
+nserver 8.8.4.4
+timeouts 1 5 30 60 180 1800 15 60
+daemon
+log /var/log/3proxy/3proxy.log
+logformat "- +_L%t.%. %N.%p %E %U %C:%c %R:%r %O %I %h %T"
+rotate 30
+auth none
+allow * * * * *
+proxy -p3128
+socks -p1080
+EOF
+
+# Создаем папку для логов и запускаем прокси
+mkdir -p /var/log/3proxy
+/usr/bin/3proxy /etc/3proxy/3proxy.cfg
+
+# Проверяем, что запустилось
+ps aux | grep 3proxy
+netstat -tulpn | grep -E '3128|1080'
+
+# Настраиваем файрвол
+firewall-cmd --permanent --add-port=3128/tcp
+firewall-cmd --permanent --add-port=1080/tcp
+firewall-cmd --reload
+firewall-cmd --list-ports
+
+# Проверяем локальную работу прокси
+curl -x http://127.0.0.1:3128 https://api.ipify.org
+# Должен вернуть: 193.46.217.94
+
+# Настраиваем автозапуск
+echo "/usr/bin/3proxy /etc/3proxy/3proxy.cfg" >> /etc/rc.local
+chmod +x /etc/rc.local
+
+
+# Проверяем доступность прокси
+ping -c 4 193.46.217.94
+curl -x http://193.46.217.94:3128 https://api.ipify.org
+# Должен вернуть: 193.46.217.94
+
+# Проверяем работу с SearchAPI через прокси
+curl -x http://193.46.217.94:3128 "https://www.searchapi.io/api/v1/search?engine=google_lens&api_key=5jyYZC8jSaxhZTwjMUhwtAXi&url=https://dev-workspace.not-copy.com/api/files/public/76d06557-6df1-4fcd-a273-050ec6a35faf&search_type=exact_matches" -o test.json
+ls -la test.json
+tail -20 test.json
+# Файл должен быть полным (заканчиваться на '}')
+
+
+
+ps aux | grep 3proxy              # Проверка статуса
+netstat -tulpn | grep -E '3128|1080'  # Проверка портов
+tail -f /var/log/3proxy/3proxy.log    # Просмотр логов
+killall 3proxy                         # Остановка прокси
+/usr/bin/3proxy /etc/3proxy/3proxy.cfg # Запуск прокси
+
+
+firewall-cmd --permanent --remove-port=3128/tcp
+firewall-cmd --permanent --add-rich-rule='rule family="ipv4" source address="IP_ТВОЕГО_СЕРВЕРА" port port="3128" protocol="tcp" accept'
+firewall-cmd --permanent --add-rich-rule='rule family="ipv4" source address="IP_ТВОЕГО_СЕРВЕРА" port port="1080" protocol="tcp" accept'
+firewall-cmd --reload
+
+
+На прокси-сервере:
+bash
+ps aux | grep 3proxy              # Проверка статуса
+netstat -tulpn | grep -E '3128|1080'  # Проверка портов
+tail -f /var/log/3proxy/3proxy.log    # Просмотр логов
+killall 3proxy                         # Остановка прокси
+/usr/bin/3proxy /etc/3proxy/3proxy.cfg # Запуск прокси
+
+На основном сервере:
+bash
+curl -x http://193.46.217.94:3128 https://api.ipify.org  # Проверка прокси
+telnet 193.46.217.94 3128                                 # Проверка порта
+
+------
+
+Настройка Яндекс Клауд
+
+1. YCAJEpWAtaVkVGX0sH6_EupEg - индетификатор ключа
+2. YCMmVykfXrZ_nfU13Vo4yoCVGa70DnTlBgF1pUzO - секретный ключ
+
+   private static final String KEY_ID = "YCAJEmHZcWxzf4oGWvETG3mms";
+   private static final String SECRET_KEY = "YCPAPZ32XC-LWb8xE0b_xTcBD8NZUCHpSOfu8LUG";

build.gradle

@@ -21,6 +21,9 @@ configurations {
 
 repositories {
 	mavenCentral()
+	flatDir {
+		dirs 'libs'
+	}
 }
 
 dependencies {
@@ -29,16 +32,60 @@ dependencies {
 	implementation 'org.springframework.boot:spring-boot-starter-web'
 	implementation 'org.springframework.security:spring-security-crypto:6.5.3'
 	implementation 'org.mapstruct:mapstruct:1.5.5.Final'
+	implementation 'commons-validator:commons-validator:1.7'
+	implementation group: 'org.springframework.boot', name: 'spring-boot-starter-mail', version: '4.0.1'
+	implementation group: 'com.fasterxml.jackson.core', name: 'jackson-databind', version: '2.17.2'
+	implementation group: 'com.google.cloud', name: 'google-cloud-vision', version: '3.55.0'
+	implementation group: 'com.google.api-client', name: 'google-api-client', version: '2.7.2'
+
+	implementation 'org.flywaydb:flyway-core:9.22.0'
+
+	implementation 'com.fasterxml.jackson.dataformat:jackson-dataformat-xml:2.17.0'
+	implementation 'tools.jackson.core:jackson-core:3.0.3'
+	implementation 'jakarta.xml.bind:jakarta.xml.bind-api:4.0.0'
+
 	annotationProcessor 'org.mapstruct:mapstruct-processor:1.5.5.Final'
+	annotationProcessor 'org.projectlombok:lombok'
+
 	compileOnly 'org.projectlombok:lombok'
+
 	developmentOnly 'org.springframework.boot:spring-boot-devtools'
+
 	runtimeOnly 'com.microsoft.sqlserver:mssql-jdbc'
 	runtimeOnly 'com.mysql:mysql-connector-j'
 	runtimeOnly 'org.postgresql:postgresql'
-	annotationProcessor 'org.projectlombok:lombok'
+
 	testImplementation 'org.springframework.boot:spring-boot-starter-test'
 	testImplementation 'org.mockito:mockito-core:5.3.1'
 	testRuntimeOnly 'org.junit.platform:junit-platform-launcher'
+
+	implementation name: 'testlib-fat-0.3.1-all'
+
+	implementation group: 'com.squareup.okhttp3', name: 'okhttp', version: '4.12.0'
+	implementation 'com.maxmind.geoip2:geoip2:4.2.0'
+	implementation 'org.sejda.imageio:webp-imageio:0.1.6'
+
+	implementation project(':referral')
+
+	//cloud
+	implementation("software.amazon.awssdk:aws-sdk-java:2.29.33")
+	implementation("software.amazon.awssdk:apache-client:2.29.33")
+
+	implementation("org.springdoc:springdoc-openapi-starter-webmvc-ui:2.7.0")
+	implementation("org.springframework.boot:spring-boot-starter-web")
+
+
+	implementation 'org.springframework.cloud:spring-cloud-starter-openfeign:4.1.0'
+	implementation 'io.github.resilience4j:resilience4j-spring-boot3:2.2.0'
+
+	//cache
+	implementation("org.springframework.boot:spring-boot-starter-cache:4.0.6")
+	implementation 'com.github.ben-manes.caffeine:caffeine'
+
+	//security
+	implementation 'org.springframework.boot:spring-boot-starter-security'
+	implementation("io.jsonwebtoken:jjwt:0.13.0")
+
 }
 
 tasks.named('test') {

docker-compose.yaml

@@ -1,17 +1,69 @@
 version: '3.9'
 
 services:
+  storage:
+    image: alpine:latest
+    container_name: file-storage
+    deploy:
+      resources:
+        limits:
+          memory: 128M
+        reservations:
+          memory: 64M
+    networks:
+      - app-network
+    volumes:
+      - uploads_data:/storage:rw
+    command: tail -f /dev/null
+    restart: unless-stopped
+
+#  postfix:
+#    image: boky/postfix:latest
+#    container_name: postfix-production
+#    hostname: ${DOMAIN:-no-copy.ru}
+#    environment:
+#      - DOMAIN=${DOMAIN:-no-copy.ru}
+#      - ALLOWED_SENDER_DOMAINS=*
+#      - RELAYHOST=
+#      - DISABLE_SMTP_AUTH=
+#      - SMTP_USERNAME=${MAIL_USERNAME:-noreply@no-copy.ru}
+#      - SMTP_PASSWORD=${SMTP_PASSWORD:-nocopy!nocopy!}
+#      - RELAY_NETWORKS=172.16.0.0/12
+#      - POSTFIX_mynetworks=127.0.0.0/8 172.17.0.0/16 172.16.0.0/12
+#      - POSTFIX_smtpd_relay_restrictions=permit_mynetworks, permit_sasl_authenticated, reject_unauth_destination
+#      - POSTFIX_smtpd_recipient_restrictions=permit_mynetworks, permit_sasl_authenticated, reject_unauth_destination
+#      - DISABLE_SIGNING=true
+#    ports:
+#      - "25:25"
+#      - "587:587"
+#    networks:
+#      - app-network
+#    restart: unless-stopped
+
   db:
-    image: postgres:17
+    image: postgres:17.7
     restart: always
+    deploy:
+      resources:
+        limits:
+          cpus: '2.0'
+          memory: 2G
+        reservations:
+          cpus: '1.0'
+          memory: 1G
     environment:
       POSTGRES_DB: no_copy_
-      POSTGRES_USER: postgres
-      POSTGRES_PASSWORD: postgres
+      #      POSTGRES_USER: postgres
+      #      POSTGRES_PASSWORD: postgres
+      POSTGRES_USER: ${POSTGRES_USER}
+      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD}
+      POSTGRES_SHARED_BUFFERS: 512MB
+      POSTGRES_EFFECTIVE_CACHE_SIZE: 1536MB
     ports:
       - "54320:5432"
     volumes:
       - pgdata:/var/lib/postgresql/data
+      - ./init-scripts:/docker-entrypoint-initdb.d:ro
     container_name: postgres
     networks:
       app-network:
@@ -21,12 +73,40 @@ services:
   app:
     build: .
     container_name: app-backend
+    deploy:
+      resources:
+        limits:
+          cpus: '1.5'
+          memory: 3G
+        reservations:
+          cpus: '0.5'
+          memory: 2G
     environment:
+      JAVA_TOOL_OPTIONS: "-Xmx2g -Xms1g -XX:MaxMetaspaceSize=512m -XX:+UseG1GC -XX:+HeapDumpOnOutOfMemoryError -XX:+UseContainerSupport -XX:InitialRAMPercentage=50 -XX:MaxRAMPercentage=75"
+      FILE_STORAGE_PATH: /data/uploads
+      MAX_FILE_SIZE: 10737418240
+      #      FILE_CHUNK_SIZE: 1048576
+      FILE_CHUNK_SIZE: 1000000
       POSTGRES_DB: no_copy_
-      POSTGRES_USER: postgres
-      POSTGRES_PASSWORD: postgres
+
+      POSTGRES_USER: ${POSTGRES_USER}
+      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD}
       POSTGRES_PORT: 5432
       POSTGRES_HOST: db
+      STORAGE_SERVICE_URL: http://storage:8081
+      SPRING_PROFILES_ACTIVE: prod
+      YANDEX_API_KEY: AQVNyaVaUmgUb1GMCtf5zSEqFxy0woXrcMOOB43q
+      YANDEX_FOLDER_ID: b1gokpdbm6qfpsou8pcd
+      YANDEX_SEARCH_URL: "https://searchapi.api.cloud.yandex.net/v2/image/search_by_image"
+#      POSTGRES_USER: postgres
+#      POSTGRES_PASSWORD: postgres
+#      MAIL_HOST: postfix
+#      MAIL_PORT: 25
+#      MAIL_USERNAME: noreply@no-copy.ru
+#      SMTP_PASSWORD: nocopy!nocopy!
+#      SPRING_MAIL_PROPERTIES_MAIL_SMTP_STARTTLS_ENABLE: "false"
+#      SPRING_MAIL_PROPERTIES_MAIL_SMTP_AUTH: "false"
+#      SPRING_MAIL_PROPERTIES_MAIL_DEBUG: "true"
     depends_on:
       - db
     ports:
@@ -37,10 +117,23 @@ services:
           - app
           - backend
           - api
+    volumes:
+      - uploads_data:/data/uploads:rw
+    healthcheck:
+      test: [ "CMD-SHELL", "pg_isready -U ${POSTGRES_USER} -d no_copy_" ]
+      interval: 10s
+      retries: 5
 
   grafana:
     image: grafana/grafana:10.3.1
     container_name: grafana
+    deploy:
+      resources:
+        limits:
+          cpus: '0.5'
+          memory: 512M
+        reservations:
+          memory: 256M
     ports:
       - "3000:3000"
     depends_on:
@@ -57,6 +150,8 @@ services:
       GF_SECURITY_ADMIN_USER: admin
       GF_SECURITY_ADMIN_PASSWORD: admin
       GF_METRICS_ENABLED: "true"
+      GF_DATABASE_MAX_IDLE_CONN: "2"
+      GF_DATABASE_MAX_OPEN_CONN: "10"
     volumes:
       - ./infrastructure/grafana/provisioning:/etc/grafana/provisioning
       - ./infrastructure/grafana/dashboards:/var/lib/grafana/dashboards
@@ -71,10 +166,23 @@ services:
   prometheus:
     image: prom/prometheus:latest
     container_name: prometheus
+    deploy:
+      resources:
+        limits:
+          cpus: '0.5'
+          memory: 1G
+        reservations:
+          memory: 512M
     ports:
       - "9090:9090"
     volumes:
       - ./infrastructure/prometheus/prometheus.yml:/etc/prometheus/prometheus.yml
+      - prometheus_data:/prometheus
+    command:
+      - '--config.file=/etc/prometheus/prometheus.yml'
+      - '--storage.tsdb.path=/prometheus'
+      - '--storage.tsdb.retention.time=15d'
+      - '--web.enable-lifecycle'
     healthcheck:
       test: [ "CMD", "wget", "--spider", "http://localhost:9090/-/healthy" ]
       interval: 10s
@@ -86,10 +194,20 @@ services:
   loki:
     image: grafana/loki:2.9.2
     container_name: loki
+    deploy:
+      resources:
+        limits:
+          cpus: '1.0'
+          memory: 2G
+        reservations:
+          memory: 1G
     ports:
       - "3100:3100"
     volumes:
       - ./infrastructure/loki/loki-config.yaml:/etc/loki/loki-config.yaml:ro
+      - loki_data:/loki
+    command:
+      - -config.file=/etc/loki/loki-config.yaml
     healthcheck:
       test: [ "CMD", "wget", "--spider", "-q", "http://localhost:3100/ready" ]
       interval: 10s
@@ -98,9 +216,43 @@ services:
     networks:
       - app-network
 
+  nexus:
+    image: sonatype/nexus3:latest
+    container_name: nexus
+    restart: unless-stopped
+    ports:
+      - "9000:8081"
+    volumes:
+      - nexus-data:/nexus-data
+    environment:
+      - INSTALL4J_ADD_VM_PARAMS=-Xms512m -Xmx1024m -XX:MaxDirectMemorySize=512m
+    networks:
+      - app-network
+
+  mongodb:
+    image: mongo:latest
+    container_name: mongo_ncp
+    restart: unless-stopped
+    ports:
+      - "27017:27017"
+    environment:
+      MONGO_INITDB_ROOT_USERNAME: mongo_db
+      MONGO_INITDB_ROOT_PASSWORD: mongo_ncp
+    volumes:
+      - mongodb_data:/data/db
+    networks:
+      - app-network
+
   tempo:
     image: grafana/tempo:2.4.1
     container_name: tempo
+    deploy:
+      resources:
+        limits:
+          cpus: '0.5'
+          memory: 512M
+        reservations:
+          memory: 256M
     command: [ "-config.file=/etc/tempo/tempo.yaml" ]
     volumes:
       - ./infrastructure/tempo/tempo.yaml:/etc/tempo/tempo.yaml
@@ -113,6 +265,13 @@ services:
   alloy:
     image: grafana/alloy:latest
     container_name: alloy
+    deploy:
+      resources:
+        limits:
+          cpus: '0.5'
+          memory: 256M
+        reservations:
+          memory: 128M
     user: root
     ports:
       - "9080:9080"
@@ -135,13 +294,19 @@ services:
 
 volumes:
   pgdata:
+  mongodb_data:
+    name: mongodb_data
   artifacts:
   tempo_data:
   loki_data:
   loki_chunks:
   loki_index:
   loki_rules:
-
+  uploads_data:
+  prometheus_data:
+  nexus-data:
+    driver: local
+#  postfix-data:
 networks:
   app-network:
     external: true

finance/build.gradle.kts

@@ -0,0 +1,24 @@
+plugins {
+    kotlin("jvm") version "2.1.10"
+}
+
+group = "ru.soune"
+version = "1.0.0"
+
+repositories {
+    mavenCentral()
+}
+
+dependencies {
+    implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.10.2")
+    implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core-jvm:1.10.2")
+    implementation("io.insert-koin:koin-core:4.1.1")
+    implementation("io.insert-koin:koin-core-jvm:4.1.1")
+}
+
+tasks.test {
+    useJUnitPlatform()
+}
+kotlin {
+    jvmToolchain(21)
+}

finance/src/main/kotlin/Main.kt

@@ -0,0 +1,5 @@
+package ru.soune
+
+fun main() {
+    println("Hello World!")
+}

finance/src/main/kotlin/actions/NoCopyAction.kt

@@ -0,0 +1,3 @@
+package ru.soune.actions
+
+abstract class NoCopyAction

finance/src/main/kotlin/actions/free/NoCopyFreeAction.kt

@@ -0,0 +1,5 @@
+package ru.soune.actions.free
+
+import ru.soune.actions.NoCopyAction
+
+sealed class NoCopyFreeAction : NoCopyAction()

finance/src/main/kotlin/actions/paid/NoCopyPaidAction.kt

@@ -0,0 +1,8 @@
+package ru.soune.actions.paid
+
+import ru.soune.actions.NoCopyAction
+
+sealed class NoCopyPaidAction : NoCopyAction() {
+
+    abstract val cost: Double
+}

infrastructure/jenkins/README.md

@@ -0,0 +1,26 @@
+## Команды для помещения в сеть
+
+Сеть для работы бэка и фронта : Наименование == app-network-{port}
+
+
+### Проверить состояние:
+
+
+docker inspect {container-name} --format='{{range $net, $_ := .NetworkSettings.Networks}}{{$net}} {{end}}'
+
+
+### Создать сеть ,если нет
+
+docker network create {name-network} 2>/dev/null || echo "Сеть уже существует"
+
+###  Переместить контейнер:
+
+# Отключить от старой сети
+docker network disconnect {network-name-old} {container-name}
+
+# Подключить к новой сети
+docker network connect {network-name-new}  {container-name}
+
+# Добавить алиас (опционально)
+docker network connect --alias {alias} {network-name-new} {container-name}
+

infrastructure/jenkins/admin-panel.groovy

@@ -0,0 +1,156 @@
+pipeline {
+    agent any
+
+    parameters {
+        string(
+                name: 'BRANCH',
+                defaultValue: 'main',
+                description: 'Ветка для деплоя админ-панели'
+        )
+        string(
+                name: 'PORT',
+                defaultValue: '2996',
+                description: 'Порт для запуска экземпляра'
+        )
+    }
+
+    stages {
+        stage('Git pull') {
+            steps {
+                script {
+                    checkout([
+                            $class: 'GitSCM',
+                            branches: [[name: params.BRANCH]],
+                            userRemoteConfigs: [[
+                                                        url: 'https://code.3err0.ru/frontdev/no-copy-admin-panel-frontend.git',
+                                                        credentialsId: 'nx-jen'
+                                                ]]
+                    ])
+                }
+            }
+        }
+
+        stage('Stop old') {
+            steps {
+                script {
+                    withCredentials([
+                            usernamePassword(
+                                    credentialsId: 'server-root-password',
+                                    usernameVariable: 'SSH_USER',
+                                    passwordVariable: 'SSH_PASS'
+                            )
+                    ]) {
+                        sh """
+                        sshpass -p '$SSH_PASS' ssh $SSH_USER@92.242.61.23 "
+                        docker stop no-copy-admin-panel-${params.PORT} 2>/dev/null || true
+                        docker rm no-copy-admin-panel-${params.PORT} 2>/dev/null || true
+                        mkdir -p /opt/deployments/admin-panel/${params.BRANCH}-${params.PORT}
+                        rm -rf /opt/deployments/admin-panel/${params.BRANCH}-${params.PORT}/*
+                    "
+                """
+                    }
+                }
+            }
+        }
+
+        stage('Copy to server') {
+            steps {
+                script {
+                    withCredentials([
+                            usernamePassword(
+                                    credentialsId: 'server-root-password',
+                                    usernameVariable: 'SSH_USER',
+                                    passwordVariable: 'SSH_PASS'
+                            )
+                    ]) {
+                        sh """
+                    sshpass -p '$SSH_PASS' scp -r ./* $SSH_USER@92.242.61.23:/opt/deployments/admin-panel/${params.BRANCH}-${params.PORT}/
+                """
+                    }
+                }
+            }
+        }
+
+        stage('Build on server') {
+            steps {
+                script {
+                    withCredentials([
+                            usernamePassword(
+                                    credentialsId: 'server-root-password',
+                                    usernameVariable: 'SSH_USER',
+                                    passwordVariable: 'SSH_PASS'
+                            )
+                    ]) {
+                        sh """
+                    sshpass -p '$SSH_PASS' ssh $SSH_USER@92.242.61.23 "
+                        cd /opt/deployments/admin-panel/${params.BRANCH}-${params.PORT}
+                        docker build -t no-copy-admin-panel:${params.BRANCH}-${params.PORT} .
+                    "
+                """
+                    }
+                }
+            }
+        }
+
+        stage('Start on server') {
+            steps {
+                script {
+                    withCredentials([
+                            usernamePassword(
+                                    credentialsId: 'server-root-password',
+                                    usernameVariable: 'SSH_USER',
+                                    passwordVariable: 'SSH_PASS'
+                            )
+                    ]) {
+                        sh """
+                    sshpass -p '$SSH_PASS' ssh $SSH_USER@92.242.61.23 "
+                        docker run -d \\
+                            --name no-copy-admin-panel-${params.PORT} \\
+                            --restart unless-stopped \\
+                            --network app-network \\
+                            -p ${params.PORT}:2996 \\
+                            no-copy-admin-panel:${params.BRANCH}-${params.PORT}
+                        sleep 5
+                        docker ps --filter name=no-copy-admin-panel-${params.PORT}
+                    "
+                """
+                    }
+                }
+            }
+        }
+
+        stage('Check status') {
+            steps {
+                script {
+                    withCredentials([
+                            usernamePassword(
+                                    credentialsId: 'server-root-password',
+                                    usernameVariable: 'SSH_USER',
+                                    passwordVariable: 'SSH_PASS'
+                            )
+                    ]) {
+                        sh """
+                    sshpass -p '$SSH_PASS' ssh $SSH_USER@92.242.61.23 "
+                        if docker ps --format '{{.Names}}' | grep -q 'no-copy-admin-panel-${params.PORT}'; then
+                            HTTP_CODE=\$(curl -s -o /dev/null -w '%{http_code}' http://localhost:${params.PORT} 2>/dev/null || echo '000')
+                            echo 'Admin panel available on http://92.242.61.23:${params.PORT}'
+                        else
+                            exit 1
+                        fi
+                    "
+                """
+                    }
+                }
+            }
+        }
+    }
+
+    post {
+        success {
+            echo "Admin panel ${params.BRANCH} deployed"
+        }
+        failure {
+            echo "Deployment failed"
+        }
+    }
+}

infrastructure/jenkins/deploy-backend.groovy

@@ -0,0 +1,238 @@
+pipeline {
+    agent any
+
+    parameters {
+        string(
+                name: 'BRANCH',
+                defaultValue: 'dev',
+                description: 'Ветка для деплоя'
+        )
+        string(
+                name: 'PORT',
+                defaultValue: '3001',
+                description: 'Порт для запуска экземпляра'
+        )
+        string(
+                name: 'PORT_DB',
+                defaultValue: '',
+                description: 'Порт для запуска БД'
+        )
+        string(
+                name: 'SERVER',
+                defaultValue: '92.242.61.23',
+                description: 'Сервер для деплоя'
+        )
+        string(
+                name: 'NETWORK',
+                defaultValue: 'app-network-dev',
+                description: 'Имя сети (будет создана если не существует)'
+        )
+        choice(
+                name: 'SPRING_PROFILE',
+                choices: ['dev', 'prod'],
+                description: 'Профиль Spring для запуска'
+        )
+    }
+
+    stages {
+        stage('Git pull') {
+            steps {
+                cleanWs()
+                script {
+                    checkout([
+                            $class: 'GitSCM',
+                            branches: [[name: params.BRANCH]],
+                            userRemoteConfigs: [[
+                                                        url: 'https://code.3err0.ru/backdev/no-copy.git',
+                                                        credentialsId: 'nx-jen'
+                                                ]]
+                    ])
+                }
+            }
+        }
+
+        stage('Copy to server') {
+            steps {
+                script {
+                    withCredentials([
+                            usernamePassword(
+                                    credentialsId: 'server-root-password',
+                                    usernameVariable: 'SSH_USER',
+                                    passwordVariable: 'SSH_PASS'
+                            )
+                    ]) {
+                        sh """
+                    sshpass -p '${SSH_PASS}' ssh -o StrictHostKeyChecking=no ${SSH_USER}@${params.SERVER} "
+                        rm -rf /opt/deployments/${params.BRANCH}-${params.PORT}/*
+                        mkdir -p /opt/deployments/${params.BRANCH}-${params.PORT}
+                    "
+                    
+                    sshpass -p '${SSH_PASS}' scp -r ./* ${SSH_USER}@${params.SERVER}:/opt/deployments/${params.BRANCH}-${params.PORT}/
+                """
+                    }
+                }
+            }
+        }
+
+        stage('Deploy with docker-compose') {
+            steps {
+                script {
+                    def buildTime = sh(script: "TZ='Asia/Novosibirsk' date '+%d-%m-%Y %H:%M:%S'", returnStdout: true).trim()
+                    def springProfile = params.SPRING_PROFILE
+                    withCredentials([
+                            usernamePassword(
+                                    credentialsId: 'server-root-password',
+                                    usernameVariable: 'SSH_USER',
+                                    passwordVariable: 'SSH_PASS'
+                            ),
+                            string(credentialsId: 'DB_USER', variable: 'DB_USER'),
+                            string(credentialsId: 'DB_PASSWORD', variable: 'DB_PASSWORD'),
+                            string(credentialsId: 'MONGO_USER', variable: 'MONGO_USER'),
+                            string(credentialsId: 'MONGO_PASSWORD', variable: 'MONGO_PASSWORD')
+                    ]) {
+                        sh """
+                echo "Testing SSH connection..."
+                if sshpass -p '${SSH_PASS}' ssh -o StrictHostKeyChecking=no ${SSH_USER}@${params.SERVER} 'echo "SSH connection successful"'; then
+                    echo "SSH connection OK"
+                else
+                    echo "SSH connection failed"
+                    exit 1
+                fi
+
+                sshpass -p '${SSH_PASS}' ssh -o StrictHostKeyChecking=no ${SSH_USER}@${params.SERVER} "
+                    mkdir -p /opt/deployments/${params.BRANCH}-${params.PORT}
+                    cd /opt/deployments/${params.BRANCH}-${params.PORT}
+
+                    echo '1. Проверяем/создаем сеть ${params.NETWORK}...'
+                    if ! docker network ls --format '{{.Name}}' | grep -q '^${params.NETWORK}\$'; then
+                        docker network create ${params.NETWORK}
+                        echo 'Сеть ${params.NETWORK} создана'
+                    else
+                        echo 'Сеть ${params.NETWORK} уже существует'
+                    fi
+
+                    echo '2. Останавливаем старые контейнеры порта ${params.PORT}...'
+                    docker stop app-backend-${params.PORT} 2>/dev/null || echo 'Контейнер не найден'
+                    docker rm app-backend-${params.PORT} 2>/dev/null || echo 'Контейнер не найден'
+                    docker stop postgres-${params.PORT} 2>/dev/null || echo 'Контейнер БД не найден'
+                    docker rm postgres-${params.PORT} 2>/dev/null || echo 'Контейнер БД не найден'
+                    docker stop file-storage-${params.PORT} 2>/dev/null || echo 'Контейнер storage не найден'
+                    docker rm file-storage-${params.PORT} 2>/dev/null || echo 'Контейнер storage не найден'
+                    docker stop mongodb-${params.PORT} 2>/dev/null || echo 'Контейнер MongoDB не найден'
+                    docker rm mongodb-${params.PORT} 2>/dev/null || echo 'Контейнер MongoDB не найден'
+
+                    echo '3. Запускаем БД...'
+                    docker run -d \\
+                      --name postgres-${params.PORT} \\
+                      --network ${params.NETWORK} \\
+                      --network-alias no_copy_${params.PORT} \\
+                      --network-alias database-${params.PORT} \\
+                      --network-alias db-${params.PORT} \\
+                      -p ${params.PORT}0:5432 \\
+                      -e POSTGRES_DB=no_copy${params.PORT_DB} \\
+                      -e POSTGRES_USER=${DB_USER} \\
+                      -e POSTGRES_PASSWORD=${DB_PASSWORD} \\
+                      -v pgdata_${params.PORT}:/var/lib/postgresql/data \\
+                      -e BUILD_TIME_BACK='${buildTime}' \\
+                      postgres:17.7
+
+                    echo '4. Запускаем MongoDB...'
+                    docker run -d \\
+                      --name mongodb-${params.PORT} \\
+                      --network ${params.NETWORK} \\
+                      --network-alias mongodb-${params.PORT} \\
+                      -p ${params.PORT}1:27017 \\
+                      -e MONGO_INITDB_ROOT_USERNAME=${MONGO_USER} \\
+                      -e MONGO_INITDB_ROOT_PASSWORD=${MONGO_PASSWORD} \\
+                      -v mongodb_data_${params.PORT}:/data/db \\
+                      mongo:7.0
+
+                    echo '5. Запускаем storage...'
+                    docker run -d \\
+                      --name file-storage-${params.PORT} \\
+                      --network ${params.NETWORK} \\
+                      -v uploads_data_${params.PORT}:/storage:rw \\
+                      alpine:latest tail -f /dev/null
+
+                    echo '6. Ждем БД...'
+                    sleep 15
+                    
+                    echo '7. Собираем приложение...'
+                    docker build --no-cache -t app-backend-${params.PORT}:latest .
+
+                    echo '8. Запускаем приложение...'
+                    docker run -d \\
+                      --name app-backend-${params.PORT} \\
+                      --network ${params.NETWORK} \\
+                      --network-alias app \\
+                      --network-alias app-${params.PORT} \\
+                      -p ${params.PORT}:8080 \\
+                      -v uploads_data_${params.PORT}:/data/uploads:rw \\
+                      -e POSTGRES_DB=no_copy${params.PORT_DB} \\
+                      -e POSTGRES_USER=${DB_USER} \\
+                      -e POSTGRES_PASSWORD=${DB_PASSWORD} \\
+                      -e POSTGRES_PORT=5432 \\
+                      -e POSTGRES_HOST=no_copy_${params.PORT} \\
+                      -e FILE_STORAGE_PATH=/data/uploads \\
+                      -e SPRING_PROFILES_ACTIVE=${springProfile} \\
+                      -e MONGO_URI=mongodb://${MONGO_USER}:${MONGO_PASSWORD}@mongodb-${params.PORT}:27017 \\
+                      -e MONGO_DATABASE=no_copy \\
+                      app-backend-${params.PORT}:latest
+
+                    echo '9. Проверка...'
+                    sleep 10
+                    
+                    if curl -s -f http://localhost:${params.PORT}/health > /dev/null 2>&1; then
+                        echo 'Приложение работает на порту ${params.PORT}'
+                    else
+                        echo 'Проверка health не удалась'
+                        docker logs app-backend-${params.PORT} --tail=20
+                    fi
+                "
+                """
+                    }
+                }
+            }
+        }
+
+        stage('Verify network') {
+            steps {
+                script {
+                    withCredentials([
+                            usernamePassword(
+                                    credentialsId: 'server-root-password',
+                                    usernameVariable: 'SSH_USER',
+                                    passwordVariable: 'SSH_PASS'
+                            )
+                    ]) {
+                        sh """
+                        sshpass -p '${SSH_PASS}' ssh -o StrictHostKeyChecking=no ${SSH_USER}@${params.SERVER} "
+                            echo 'Проверяем подключение к сети ${params.NETWORK}'
+                            docker network inspect ${params.NETWORK} --format='{{.Name}}: {{range .Containers}}{{.Name}} {{end}}'
+                            
+                            echo 'Проверяем алиас app для контейнера app-backend-${params.PORT}'
+                            docker inspect app-backend-${params.PORT} | grep -A 5 'Aliases'
+                        "
+                        """
+                    }
+                }
+            }
+        }
+    }
+
+    post {
+        success {
+            script {
+                def appUrl = params.SPRING_PROFILE == 'prod' ? 'https://workspace.not-copy.com' : 'https://dev-workspace.not-copy.com'
+                echo "Deployment successful"
+                echo "Application URL: ${appUrl}"
+            }
+        }
+        failure {
+            echo "Deployment failed for branch ${params.BRANCH} on port ${params.PORT}"
+        }
+        always {
+            echo "Deployment process finished"
+        }
+    }
+}

infrastructure/jenkins/deploy-front.groovy

@@ -7,6 +7,16 @@ pipeline {
                 defaultValue: 'main',
                 description: 'Ветка для деплоя'
         )
+        string(
+                name: 'PORT',
+                defaultValue: '2998',
+                description: 'Порт для запуска экземпляра'
+        )
+        string(
+                name: 'NETWORK',
+                defaultValue: 'app-network-dev',
+                description: 'Docker сеть для подключения'
+        )
     }
 
     stages {
@@ -36,19 +46,19 @@ pipeline {
                             )
                     ]) {
                         sh """
-                            sshpass -p '$SSH_PASS' ssh $SSH_USER@92.242.61.23 "
-                                docker stop no-copy-frontend 2>/dev/null || true
-                                docker rm no-copy-frontend 2>/dev/null || true
-                                
-                                cd /opt/deployments/frontend/${params.BRANCH} 2>/dev/null || mkdir -p /opt/deployments/frontend/${params.BRANCH}
-                                
-                                if [ -f 'docker-compose.yaml' ]; then
-                                    docker-compose -f docker-compose.yaml down 2>/dev/null || true
-                                elif [ -f 'docker-compose.yml' ]; then
-                                    docker-compose -f docker-compose.yml down 2>/dev/null || true
-                                fi
-                            "
-                        """
+                    sshpass -p '$SSH_PASS' ssh $SSH_USER@92.242.61.23 "
+                        docker stop no-copy-frontend-${params.PORT} 2>/dev/null || true
+                        docker rm no-copy-frontend-${params.PORT} 2>/dev/null || true
+                        
+                        cd /opt/deployments/frontend/${params.BRANCH}-${params.PORT} 2>/dev/null || mkdir -p /opt/deployments/frontend/${params.BRANCH}-${params.PORT}
+                        
+                        if [ -f 'docker-compose.yaml' ]; then
+                            docker-compose -f docker-compose.yaml -p frontend-${params.PORT} down 2>/dev/null || true
+                        elif [ -f 'docker-compose.yml' ]; then
+                            docker-compose -f docker-compose.yml -p frontend-${params.PORT} down 2>/dev/null || true
+                        fi
+                    "
+                """
                     }
                 }
             }
@@ -65,13 +75,13 @@ pipeline {
                             )
                     ]) {
                         sh """
-                            sshpass -p '$SSH_PASS' ssh $SSH_USER@92.242.61.23 "
-                                rm -rf /opt/deployments/frontend/${params.BRANCH}/*
-                                mkdir -p /opt/deployments/frontend/${params.BRANCH}
-                            "
-                            
-                            sshpass -p '$SSH_PASS' scp -r ./* $SSH_USER@92.242.61.23:/opt/deployments/frontend/${params.BRANCH}/
-                        """
+                    sshpass -p '$SSH_PASS' ssh $SSH_USER@92.242.61.23 "
+                        rm -rf /opt/deployments/frontend/${params.BRANCH}-${params.PORT}/*
+                        mkdir -p /opt/deployments/frontend/${params.BRANCH}-${params.PORT}
+                    "
+                    
+                    sshpass -p '$SSH_PASS' scp -r ./* $SSH_USER@92.242.61.23:/opt/deployments/frontend/${params.BRANCH}-${params.PORT}/
+                """
                     }
                 }
             }
@@ -80,6 +90,8 @@ pipeline {
         stage('Build on server') {
             steps {
                 script {
+                    def BUILD_TIME_FRONT = sh(script: "date '+%d-%m-%Y %H:%M:%S'", returnStdout: true).trim()
+
                     withCredentials([
                             usernamePassword(
                                     credentialsId: 'server-root-password',
@@ -88,19 +100,21 @@ pipeline {
                             )
                     ]) {
                         sh """
-                            sshpass -p '$SSH_PASS' ssh $SSH_USER@92.242.61.23 "
-                                cd /opt/deployments/frontend/${params.BRANCH}
-                                
-                                if [ -f 'docker-compose.yaml' ]; then
-                                    docker-compose -f docker-compose.yaml build
-                                elif [ -f 'docker-compose.yml' ]; then
-                                    docker-compose -f docker-compose.yml build
-                                else
-                                    echo 'Exception:don't found docker-compose'
-                                    exit 1
-                                fi
-                            "
-                        """
+                sshpass -p '$SSH_PASS' ssh $SSH_USER@92.242.61.23 "
+                    cd /opt/deployments/frontend/${params.BRANCH}-${params.PORT}
+                    
+                    # 1. СОЗДАЕМ JSON ФАЙЛ (ЭТО РАБОТАЕТ 100%)
+                    mkdir -p public
+                    echo '{\\"buildTime\\": \\"${BUILD_TIME_FRONT}\\"}' > public/build-info.json
+                    
+                    # 2. Меняем имя контейнера и порт
+                    sed -i 's/container_name: no-copy-frontend\$/container_name: no-copy-frontend-${params.PORT}/' docker-compose.yml
+                    sed -i 's/\\\"2998:2999\\\"/\\\"${params.PORT}:2999\\\"/' docker-compose.yml
+                    
+                    # 3. Собираем образ
+                    docker-compose -f docker-compose.yml -p frontend-${params.PORT} build
+                "
+                """
                     }
                 }
             }
@@ -117,21 +131,26 @@ pipeline {
                             )
                     ]) {
                         sh """
-                            sshpass -p '$SSH_PASS' ssh $SSH_USER@92.242.61.23 "
-                                cd /opt/deployments/frontend/${params.BRANCH}
-                                
-                                if [ -f 'docker-compose.yaml' ]; then
-                                    docker-compose -f docker-compose.yaml up -d
-                                elif [ -f 'docker-compose.yml' ]; then
-                                    docker-compose -f docker-compose.yml up -d
-                                fi
-                                
-                                sleep 10
-                                
-                                echo 'Status container:'
-                                docker ps --filter name=no-copy-frontend
-                            "
-                        """
+                    sshpass -p '$SSH_PASS' ssh $SSH_USER@92.242.61.23 "
+                        cd /opt/deployments/frontend/${params.BRANCH}-${params.PORT}
+                        
+                        echo '=== Запускаем контейнер ==='
+                        docker-compose -f docker-compose.yml -p frontend-${params.PORT} up -d
+                        
+                        sleep 10
+                        
+                        echo '=== Проверяем запуск ==='
+                        if docker ps --format '{{.Names}}' | grep -q 'no-copy-frontend-${params.PORT}'; then
+                            echo '✓ Контейнер запущен: no-copy-frontend-${params.PORT}'
+                            echo '✓ Порт: ${params.PORT}:2999'
+                        else
+                            echo '✗ Контейнер не запустился'
+                            echo 'Логи:'
+                            docker-compose -f docker-compose.yml -p frontend-${params.PORT} logs
+                            exit 1
+                        fi
+                    "
+                """
                     }
                 }
             }
@@ -148,23 +167,93 @@ pipeline {
                             )
                     ]) {
                         sh """
-                            sshpass -p '$SSH_PASS' ssh $SSH_USER@92.242.61.23 "
-                                if docker ps --format '{{.Names}}' | grep -q 'no-copy-frontend'; then
-                                    echo 'Container start'
-                                    
-                                    sleep 5
-                                    
-                                    HTTP_CODE=\$(curl -s -o /dev/null -w '%{http_code}' http://localhost:2998 || echo '000')
-                                    echo 'HTTP код: ' \$HTTP_CODE
-                                    
-                                    echo 'Frong start on http://92.242.61.23:2998'
-                                else
-                                    echo 'Exception: container don't start'
-                                    docker ps -a | grep frontend
-                                    exit 1
-                                fi
-                            "
-                        """
+                    sshpass -p '$SSH_PASS' ssh $SSH_USER@92.242.61.23 "
+                        # Ищем контейнер с правильным именем (с портом)
+                        if docker ps --format '{{.Names}}' | grep -q 'no-copy-frontend-${params.PORT}'; then
+                            echo 'Container started: no-copy-frontend-${params.PORT}'
+                            
+                            sleep 5
+                            
+                            HTTP_CODE=\$(curl -s -o /dev/null -w '%{http_code}' http://localhost:${params.PORT} || echo '000')
+                            echo 'HTTP code: \$HTTP_CODE'
+                            
+                            echo 'Frontend available on http://92.242.61.23:${params.PORT}'
+                            
+                            # Показываем все фронтенды
+                            echo ''
+                            echo 'All frontend containers:'
+                            docker ps --filter name=no-copy-frontend --format 'table {{.Names}}\\t{{.Ports}}\\t{{.Status}}'
+                        else
+                            echo 'Exception: container did not start'
+                            docker ps -a | grep frontend
+                            exit 1
+                        fi
+                    "
+                """
+                    }
+                }
+            }
+        }
+
+//        stage('Connect to network') {
+//            steps {
+//                script {
+//                    withCredentials([
+//                            usernamePassword(
+//                                    credentialsId: 'server-root-password',
+//                                    usernameVariable: 'SSH_USER',
+//                                    passwordVariable: 'SSH_PASS'
+//                            )
+//                    ]) {
+//                        sh """
+//            sshpass -p '$SSH_PASS' ssh $SSH_USER@92.242.61.23 "
+//                echo 'Отключаем от всех сетей и подключаем к ${params.NETWORK}'
+//
+//                # Отключаем от всех сетей (кроме bridge, host, none)
+//                current_networks=\$(docker inspect no-copy-frontend-${params.PORT} --format='{{range \$net, \$v := .NetworkSettings.Networks}}{{\$net}}{{\"\\n\"}}{{end}}' | grep -v -E '^(bridge|host|none)\$' || true)
+//
+//                for net in \$current_networks; do
+//                    echo \"Отключаем от сети: \$net\"
+//                    docker network disconnect \$net no-copy-frontend-${params.PORT} 2>/dev/null || true
+//                done
+//
+//                # Подключаем к нужной сети
+//                docker network connect ${params.NETWORK} no-copy-frontend-${params.PORT}
+//
+//                echo 'Готово! Контейнер теперь в сети:'
+//                docker inspect no-copy-frontend-${params.PORT} --format='{{range \$net, \$v := .NetworkSettings.Networks}}{{\$net}}{{\"\\n\"}}{{end}}'
+//            "
+//        """
+//                    }
+//                }
+//            }
+//        }
+
+        stage('Connect to network') {
+            steps {
+                script {
+                    withCredentials([
+                            usernamePassword(
+                                    credentialsId: 'server-root-password',
+                                    usernameVariable: 'SSH_USER',
+                                    passwordVariable: 'SSH_PASS'
+                            )
+                    ]) {
+                        sh """
+                    sshpass -p '$SSH_PASS' ssh $SSH_USER@92.242.61.23 "
+                        echo 'Подключаем контейнер к сети ${params.NETWORK}'
+                        
+                        if ! docker network ls --format '{{.Name}}' | grep -q '^${params.NETWORK}\$'; then
+                            docker network create ${params.NETWORK}
+                        fi
+                        
+                        if docker ps -a --format '{{.Names}}' | grep -q '^no-copy-frontend-${params.PORT}\$'; then
+                            docker network disconnect ${params.NETWORK} no-copy-frontend-${params.PORT} 2>/dev/null || true
+                            docker network connect ${params.NETWORK} no-copy-frontend-${params.PORT}
+                            echo 'Контейнер подключен к ${params.NETWORK}'
+                        fi
+                    "
+                """
                     }
                 }
             }
@@ -173,11 +262,12 @@ pipeline {
 
     post {
         success {
-            echo "Front branch ${params.BRANCH} completed"
-            echo "Use on http://92.242.61.23:2998"
+            echo "Front branch ${params.BRANCH} deployment completed"
+            echo "Frontend available on http://92.242.61.23:${params.PORT}"
+            echo "Container: no-copy-frontend-${params.PORT}"
         }
         failure {
-            echo "Failed"
+            echo "Deployment failed"
         }
     }
 }

infrastructure/jenkins/deploy.groovy

@@ -7,7 +7,6 @@ pipeline {
                 defaultValue: 'dev',
                 description: 'Ветка для деплоя'
         )
-
         string(
                 name: 'SERVER',
                 defaultValue: '92.242.61.23',
@@ -18,6 +17,7 @@ pipeline {
     stages {
         stage('Git pull') {
             steps {
+                cleanWs()
                 script {
                     checkout([
                             $class: 'GitSCM',
@@ -31,174 +31,90 @@ pipeline {
             }
         }
 
-        stage('Stop old container') {
+        stage('Deploy with docker-compose') {
             steps {
                 script {
+                    def buildTime = sh(script: "TZ='Asia/Novosibirsk' date '+%d-%m-%Y %H:%M:%S'", returnStdout: true).trim()
                     withCredentials([
                             usernamePassword(
                                     credentialsId: 'server-root-password',
                                     usernameVariable: 'SSH_USER',
                                     passwordVariable: 'SSH_PASS'
-                            )
+                            ),
+                            string(credentialsId: 'DB_USER', variable: 'DB_USER'),
+                            string(credentialsId: 'DB_PASSWORD', variable: 'DB_PASSWORD')
                     ]) {
                         sh """
-                            echo "Stop old container by branch ${params.BRANCH}..."
-                            
-                            sshpass -p '$SSH_PASS' ssh $SSH_USER@$SERVER "
-                                cd /opt/deployments/${params.BRANCH} 2>/dev/null || mkdir -p /opt/deployments/${params.BRANCH}
-                                
-                                # Stop old container if have docker-compose
-                                if [ -f 'docker-compose.yaml' ] || [ -f 'docker-compose.yml' ]; then
-                                    if [ -f 'docker-compose.yaml' ]; then
-                                        docker-compose -f docker-compose.yaml down 2>/dev/null || true
-                                    elif [ -f 'docker-compose.yml' ]; then
-                                        docker-compose -f docker-compose.yml down 2>/dev/null || true
-                                    fi
-                                fi
-                                
-                                # Stop and delete container by name
-                                docker stop app-${params.BRANCH} 2>/dev/null || true
-                                docker rm app-${params.BRANCH} 2>/dev/null || true
-                                
-                                echo "Old containder deleted"
-                            "
-                        """
-                    }
-                }
-            }
-        }
+                        echo "Deploying branch: ${params.BRANCH}"
 
-        stage('Copy to server') {
-            steps {
-                script {
-                    withCredentials([
-                            usernamePassword(
-                                    credentialsId: 'server-root-password',
-                                    usernameVariable: 'SSH_USER',
-                                    passwordVariable: 'SSH_PASS'
-                            )
-                    ]) {
-                        sh """
-                            echo "Copy files on server..."
-                            
-                            # Clean mkdir
-                            sshpass -p '$SSH_PASS' ssh $SSH_USER@$SERVER "
-                                rm -rf /opt/deployments/${params.BRANCH}/*
-                                mkdir -p /opt/deployments/${params.BRANCH}
-                            "
-                            
-                            # Copy all files
-                            sshpass -p '$SSH_PASS' scp -r ./* $SSH_USER@$SERVER:/opt/deployments/${params.BRANCH}/ 2>/dev/null || true
-                            
-                            echo "Files copied"
-                        """
-                    }
-                }
-            }
-        }
+                        echo "Copying files to server..."
+                        sshpass -p '$SSH_PASS' ssh -o StrictHostKeyChecking=no $SSH_USER@$SERVER "mkdir -p /opt/deployments/${params.BRANCH}"
 
-        stage('Build on server') {
-            steps {
-                script {
-                    withCredentials([
-                            usernamePassword(
-                                    credentialsId: 'server-root-password',
-                                    usernameVariable: 'SSH_USER',
-                                    passwordVariable: 'SSH_PASS'
-                            )
-                    ]) {
-                        sh """
-                            echo "Build on server..."
-                            
-                            sshpass -p '$SSH_PASS' ssh $SSH_USER@$SERVER "
-                                cd /opt/deployments/${params.BRANCH}
-                                
-                                echo "Build Docker for branch ${params.BRANCH}..."
-                                
-                                # delete old docker image
-                                docker rmi app:${params.BRANCH} 2>/dev/null || true
-                                
-                                # build from branch
-                                if [ -f 'Dockerfile' ]; then
-                                    docker build -t app:${params.BRANCH} .
-                                    echo "Docker образ app:${params.BRANCH} собран"
-                                fi
-                                
-                                # or from docker-compose
-                                if [ -f 'docker-compose.yaml' ]; then
-                                    docker-compose -f docker-compose.yaml build
-                                    echo "Build from docker-compose.yaml completed"
-                                elif [ -f 'docker-compose.yml' ]; then
-                                    docker-compose -f docker-compose.yml build
-                                    echo "Build from docker-compose.yml completed"
-                                fi
-                                
-                                echo 'Build completed'
-                            "
-                        """
-                    }
-                }
-            }
-        }
+                        sshpass -p '$SSH_PASS' rsync -av --delete \\
+                          --exclude=.git \\
+                          --exclude=.gradle \\
+                          --exclude=build \\
+                          --exclude=**/build \\
+                          --exclude=.idea \\
+                          --exclude=out \\
+                          . $SSH_USER@$SERVER:/opt/deployments/${params.BRANCH}/
 
-        stage('Start on server') {
-            steps {
-                script {
-                    withCredentials([
-                            usernamePassword(
-                                    credentialsId: 'server-root-password',
-                                    usernameVariable: 'SSH_USER',
-                                    passwordVariable: 'SSH_PASS'
-                            )
-                    ]) {
-                        sh """
-                            echo "Start container..."
-                            
-                            sshpass -p '$SSH_PASS' ssh $SSH_USER@$SERVER "
-                                cd /opt/deployments/${params.BRANCH}
-                                
-                                # If have docker-compose - use them
-                                if [ -f 'docker-compose.yaml' ]; then
-                                    echo "Start docker-compose.yaml..."
-                                    docker-compose -f docker-compose.yaml up -d
-                                    
-                                elif [ -f 'docker-compose.yml' ]; then
-                                    echo "Start docker-compose.yml..."
-                                    docker-compose -f docker-compose.yml up -d
-                                    
-                                # If have Dockerfile - start
-                                elif [ -f 'Dockerfile' ]; then
-                                    echo "Start app-${params.BRANCH}..."
-                                    docker run -d \\
-                                      --name app-${params.BRANCH} \\
-                                      -p 8080:8080 \\
-                                      app:${params.BRANCH}
-                                else
-                                    echo "Error:Dockerfile NOT FOUND, docker-compose.yaml or docker-compose.yml"
-                                    exit 1
-                                fi
-                                
-                                echo 'Container start'
-                                
-                                # Wait start
-                                sleep 10
-                                
-                                # Check status
-                                echo 'status container:'
-                                if [ -f 'docker-compose.yaml' ] || [ -f 'docker-compose.yml' ]; then
-                                    if [ -f 'docker-compose.yaml' ]; then
-                                        docker-compose -f docker-compose.yaml ps
-                                    else
-                                        docker-compose -f docker-compose.yml ps
-                                    fi
-                                else
-                                    docker ps --filter "name=app-${params.BRANCH}"
-                                fi
-                                
-                                echo ''
-                                echo 'Apps start on:'
-                                echo 'http://$SERVER:80'
-                            "
+                        sshpass -p '$SSH_PASS' ssh -o StrictHostKeyChecking=no $SSH_USER@$SERVER "
+                            cd /opt/deployments/${params.BRANCH}
+
+                            echo '1. Остановка старого приложения...'
+                            docker stop app-backend 2>/dev/null || echo 'Контейнер не найден'
+                            docker rm app-backend 2>/dev/null || echo 'Контейнер не найден'
+
+                            echo '2. Удаление старых образов...'
+                            docker images --filter 'reference=*app*' -q | xargs -r docker rmi -f 2>/dev/null || echo 'Нет образов для удаления'
+
+                            echo '3. Создание сети если нужно...'
+                            docker network create app-network 2>/dev/null || echo 'Сеть уже существует'
+
+                            echo '4. Запуск инфраструктуры...'
+                            docker-compose up -d db storage
+
+                            echo '5. Ожидание PostgreSQL...'
+                            sleep 10
+
+                            echo '6. Сборка нового образа приложения...'
+                            docker build --no-cache -t app-backend:latest .
+
+                            echo '7. Запуск приложения...'
+                            docker run -d \\
+                              --name app-backend \\
+                              --network app-network \\
+                              --network-alias app \\
+                              -p 80:8080 \\
+                              -v uploads_data:/data/uploads:rw \\
+                              -e POSTGRES_DB=no_copy_ \\
+                              -e POSTGRES_USER=$DB_USER \\
+                              -e POSTGRES_PASSWORD=$DB_PASSWORD \\
+                              -e POSTGRES_PORT=5432 \\
+                              -e POSTGRES_HOST=db \\
+                              -e BUILD_TIME_BACK='${buildTime}' \\
+                              --restart unless-stopped \\
+                              app-backend:latest
+
+                            echo '8. Запуск мониторинга...'
+                            docker-compose up -d grafana prometheus loki tempo alloy
+
+                            echo '9. Проверка...'
+                            sleep 5
+
+                            echo 'Статус контейнеров:'
+                            docker ps --format 'table {{.Names}}\\t{{.Image}}\\t{{.Status}}'
+
+                            echo '10. Проверка health...'
+                            if curl -s -f http://localhost:80/health > /dev/null 2>&1; then
+                                echo 'Приложение работает'
+                                echo 'URL: http://${params.SERVER}:80'
+                            else
+                                echo 'Проверка health не удалась'
+                                docker logs app-backend --tail=20
+                            fi
+                        "
                         """
                     }
                 }
@@ -208,11 +124,14 @@ pipeline {
 
     post {
         success {
-            echo "Deploy branch ${params.BRANCH} completed"
-            echo "App : http://$SERVER:80"
+            echo "Deployment successful"
+            echo "Application URL: http://${params.SERVER}:80"
         }
         failure {
-            echo "Deploy failed"
+            echo "Deployment failed for branch ${params.BRANCH}"
+        }
+        always {
+            echo "Deployment process finished"
         }
     }
-}
+}

infrastructure/jenkins/legal-panel.groovy

@@ -0,0 +1,156 @@
+pipeline {
+    agent any
+
+    parameters {
+        string(
+                name: 'BRANCH',
+                defaultValue: 'main',
+                description: 'Ветка для деплоя легальной панели'
+        )
+        string(
+                name: 'PORT',
+                defaultValue: '2997',
+                description: 'Порт для запуска экземпляра'
+        )
+    }
+
+    stages {
+        stage('Git pull') {
+            steps {
+                script {
+                    checkout([
+                            $class: 'GitSCM',
+                            branches: [[name: params.BRANCH]],
+                            userRemoteConfigs: [[
+                                                        url: 'https://code.3err0.ru/frontdev/no-copy-legal-panel-frontend.git',
+                                                        credentialsId: 'nx-jen'
+                                                ]]
+                    ])
+                }
+            }
+        }
+
+        stage('Stop old') {
+            steps {
+                script {
+                    withCredentials([
+                            usernamePassword(
+                                    credentialsId: 'server-root-password',
+                                    usernameVariable: 'SSH_USER',
+                                    passwordVariable: 'SSH_PASS'
+                            )
+                    ]) {
+                        sh """
+                    sshpass -p '$SSH_PASS' ssh $SSH_USER@92.242.61.23 "
+                        docker stop no-copy-legal-panel-${params.PORT} 2>/dev/null || true
+                        docker rm no-copy-legal-panel-${params.PORT} 2>/dev/null || true
+                        mkdir -p /opt/deployments/legal-panel/${params.BRANCH}-${params.PORT}
+                        rm -rf /opt/deployments/legal-panel/${params.BRANCH}-${params.PORT}/*
+                    "
+                """
+                    }
+                }
+            }
+        }
+
+        stage('Copy to server') {
+            steps {
+                script {
+                    withCredentials([
+                            usernamePassword(
+                                    credentialsId: 'server-root-password',
+                                    usernameVariable: 'SSH_USER',
+                                    passwordVariable: 'SSH_PASS'
+                            )
+                    ]) {
+                        sh """
+                    sshpass -p '$SSH_PASS' scp -r ./* $SSH_USER@92.242.61.23:/opt/deployments/legal-panel/${params.BRANCH}-${params.PORT}/
+                """
+                    }
+                }
+            }
+        }
+
+        stage('Build on server') {
+            steps {
+                script {
+                    withCredentials([
+                            usernamePassword(
+                                    credentialsId: 'server-root-password',
+                                    usernameVariable: 'SSH_USER',
+                                    passwordVariable: 'SSH_PASS'
+                            )
+                    ]) {
+                        sh """
+                        sshpass -p '$SSH_PASS' ssh $SSH_USER@92.242.61.23 "
+                        cd /opt/deployments/legal-panel/${params.BRANCH}-${params.PORT}
+                        docker build -t no-copy-legal-panel:${params.BRANCH}-${params.PORT} .
+                    "
+                """
+                    }
+                }
+            }
+        }
+
+        stage('Start on server') {
+            steps {
+                script {
+                    withCredentials([
+                            usernamePassword(
+                                    credentialsId: 'server-root-password',
+                                    usernameVariable: 'SSH_USER',
+                                    passwordVariable: 'SSH_PASS'
+                            )
+                    ]) {
+                        sh """
+                    sshpass -p '$SSH_PASS' ssh $SSH_USER@92.242.61.23 "
+                        docker run -d \\
+                            --name no-copy-legal-panel-${params.PORT} \\
+                            --restart unless-stopped \\
+                            --network app-network \\
+                            -p ${params.PORT}:2997 \\
+                            no-copy-legal-panel:${params.BRANCH}-${params.PORT}
+                        sleep 5
+                        docker ps --filter name=no-copy-legal-panel-${params.PORT}
+                    "
+                """
+                    }
+                }
+            }
+        }
+
+        stage('Check status') {
+            steps {
+                script {
+                    withCredentials([
+                            usernamePassword(
+                                    credentialsId: 'server-root-password',
+                                    usernameVariable: 'SSH_USER',
+                                    passwordVariable: 'SSH_PASS'
+                            )
+                    ]) {
+                        sh """
+                    sshpass -p '$SSH_PASS' ssh $SSH_USER@92.242.61.23 "
+                        if docker ps --format '{{.Names}}' | grep -q 'no-copy-legal-panel-${params.PORT}'; then
+                            HTTP_CODE=\$(curl -s -o /dev/null -w '%{http_code}' http://localhost:${params.PORT} 2>/dev/null || echo '000')
+                            echo 'Legal panel available on http://92.242.61.23:${params.PORT}'
+                        else
+                            exit 1
+                        fi
+                    "
+                """
+                    }
+                }
+            }
+        }
+    }
+
+    post {
+        success {
+            echo "Legal panel ${params.BRANCH} deployed on port ${params.PORT}"
+        }
+        failure {
+            echo "Deployment failed"
+        }
+    }
+}

init-scripts/01-init.sql

@@ -0,0 +1,19 @@
+DO $$
+BEGIN
+   IF NOT EXISTS (SELECT FROM pg_roles WHERE rolname = 'ncp_db') THEN
+      CREATE USER ncp_db WITH PASSWORD 'ncpDbApp';
+END IF;
+END
+$$;
+
+GRANT CONNECT ON DATABASE no_copy_ TO ncp_db;
+GRANT USAGE ON SCHEMA public TO ncp_db;
+
+GRANT ALL PRIVILEGES ON ALL TABLES IN SCHEMA public TO ncp_db;
+GRANT ALL PRIVILEGES ON ALL SEQUENCES IN SCHEMA public TO ncp_db;
+
+ALTER DEFAULT PRIVILEGES IN SCHEMA public
+GRANT ALL ON TABLES TO ncp_db;
+
+ALTER DEFAULT PRIVILEGES IN SCHEMA public
+GRANT ALL ON SEQUENCES TO ncp_db;

referral/build.gradle.kts

@@ -0,0 +1,26 @@
+plugins {
+    kotlin("jvm") version "2.1.10"
+}
+
+group = "ru.soune"
+version = "1.0.0"
+
+repositories {
+    mavenCentral()
+}
+
+dependencies {
+
+    implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.10.2")
+    implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core-jvm:1.10.2")
+
+    implementation("io.insert-koin:koin-core:4.1.1")
+    implementation("io.insert-koin:koin-core-jvm:4.1.1")
+}
+
+tasks.test {
+    useJUnitPlatform()
+}
+kotlin {
+    jvmToolchain(21)
+}

referral/src/main/kotlin/Main.kt

@@ -0,0 +1,5 @@
+package ru.soune
+
+fun main() {
+    println("Hello World!")
+}

referral/src/main/kotlin/Referral.kt

@@ -0,0 +1,14 @@
+package ru.soune
+
+interface Referral {
+
+    val userId: Long
+    val referralLink: String
+    val inviter: Long?
+    val currentLevel: String
+    val totalIncome: Int
+    val availableIncome: Int
+    val holdBalance: Int
+    val spentBalance: Int
+    val active: Boolean
+}

referral/src/main/kotlin/ReferralInvitee.kt

@@ -0,0 +1,7 @@
+package ru.soune
+
+data class ReferralInvitee(
+    val email: String,
+    val isActive: Boolean,
+    val regDate: String,
+)

referral/src/main/kotlin/ReferralLevel.kt

@@ -0,0 +1,10 @@
+package ru.soune
+
+interface ReferralLevel {
+    val id: String
+    val name: String
+    val share: Int
+    val minInvitee: Int
+    val maxInvitee: Int
+    val next: String?
+}

referral/src/main/kotlin/ReferralLevelProvider.kt

@@ -0,0 +1,11 @@
+package ru.soune
+
+interface ReferralLevelProvider {
+
+    fun getAvailableReferralLevels(): List<ReferralLevel>
+
+    fun getInitialReferralLevelId(): String
+
+    fun getReferralLevelById(levelId: String): ReferralLevel
+
+}

referral/src/main/kotlin/ReferralRepo.kt

@@ -0,0 +1,33 @@
+package ru.soune
+
+interface ReferralRepo {
+
+    fun getUserReferralLink(userId: Long): String
+
+    fun getUserIdByLink(link: String): Long?
+
+    fun getInviterIdForUser(userId: Long): Long?
+
+    fun getReferralLevelForUser(userId: Long): String
+
+    fun getReferralByUserId(userId: Long): Referral
+
+    fun getReferralInvitees(userId: Long, pageSize: Int, pageNumber: Int): List<ReferralInvitee>
+
+    // создаем новую запись в БД
+    fun createReferralEntity(entity: Referral)
+
+    // прибавить к totalIncome и availableIncome значение transferAmount
+    fun increaseIncome(userId: Long, transferAmount: Int)
+
+    // установить active в true
+    fun activateUser(userId: Long): Boolean
+
+    // посчитать записи, у которых inviter == userId и active == true
+    fun getActiveInviteeForUser(userId: Long): Int
+
+    // посчитать записи, у которых inviter == userId
+    fun getTotalInviteeForUser(userId: Long): Int
+
+    fun upgradeReferralLevelForUser(userId: Long, newLevelId: String)
+}

referral/src/main/kotlin/ReferralService.kt

@@ -0,0 +1,70 @@
+package ru.soune
+
+class ReferralService(
+    private val referralLevelProvider: ReferralLevelProvider,
+    private val referralRepo: ReferralRepo,
+) {
+
+    fun onRegister(userId: Long, inviterReferralLink: String?) {
+        val initialReferralLevel = referralLevelProvider.getInitialReferralLevelId()
+        val referralLink = referralRepo.getUserReferralLink(userId)
+        val inviter = inviterReferralLink?.let(referralRepo::getUserIdByLink)
+
+        val referral = object : Referral {
+            override val userId = userId
+            override val referralLink = referralLink
+            override val inviter = inviter
+            override val currentLevel = initialReferralLevel
+            override val totalIncome = 0
+            override val availableIncome = 0
+            override val holdBalance: Int = 0
+            override val spentBalance: Int = 0
+            override val active: Boolean = false
+        }
+
+        referralRepo.createReferralEntity(referral)
+    }
+
+    fun onUserAccountRefill(userId: Long, transferAmount: Int) {
+        val wasActivated = referralRepo.activateUser(userId)
+        val inviterId = referralRepo.getInviterIdForUser(userId) ?: return
+        val currentInviterLevel = referralRepo.getReferralLevelForUser(inviterId)
+            .let { referralLevelProvider.getReferralLevelById(it) }
+        val reward = transferAmount * currentInviterLevel.share / 100
+
+        referralRepo.increaseIncome(inviterId, reward)
+
+        if (!wasActivated) return
+
+        val currentCount = referralRepo.getActiveInviteeForUser(inviterId)
+        val nextLevel = currentInviterLevel.next
+
+        if (currentCount + 1 > currentInviterLevel.maxInvitee && nextLevel != null) {
+            referralRepo.upgradeReferralLevelForUser(inviterId, nextLevel)
+        }
+    }
+
+    fun getReferralLevels(): List<ReferralLevel> =
+        referralLevelProvider.getAvailableReferralLevels()
+
+
+    fun getReferralLevelForUser(userId: Long): ReferralLevel =
+        referralRepo.getReferralLevelForUser(userId)
+            .let { referralLevelProvider.getReferralLevelById(it) }
+
+    fun getReferralStatForUser(userId: Long): ReferralStat {
+        var referral = referralRepo.getReferralByUserId(userId)
+        return ReferralStat(
+            totalInvitee = referralRepo.getTotalInviteeForUser(userId),
+            activeInvitee = referralRepo.getActiveInviteeForUser(userId),
+            totalIncome = referral.totalIncome,
+            availableIncome = referral.availableIncome,
+            holdBalance = referral.holdBalance,
+            referralLink = referral.referralLink,
+            spentBalance = referral.spentBalance,
+        )
+    }
+
+    fun getInviteeForUser(userId: Long, pageSize: Int, pageNumber: Int): List<ReferralInvitee> =
+        referralRepo.getReferralInvitees(userId, pageSize, pageNumber)
+}

referral/src/main/kotlin/ReferralStat.kt

@@ -0,0 +1,11 @@
+package ru.soune
+
+data class ReferralStat(
+    val totalInvitee: Int,
+    val activeInvitee: Int,
+    val totalIncome: Int,
+    val availableIncome: Int,
+    val holdBalance: Int,
+    val referralLink: String,
+    val spentBalance: Int,
+)

settings.gradle

@@ -1 +1,7 @@
+plugins {
+    id 'org.gradle.toolchains.foojay-resolver-convention' version '0.8.0'
+}
 rootProject.name = 'no-copy'
+include 'referral'
+include 'finance'
+

src/main/java/ru/soune/no_copy/configuration/ApplicationConfig.java

@@ -1,17 +0,0 @@
-package ru.soune.no_copy.configuration;
-
-import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
-import org.springframework.context.annotation.Bean;
-import org.springframework.context.annotation.Configuration;
-import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
-import org.springframework.security.crypto.password.PasswordEncoder;
-
-@Configuration
-@EnableAutoConfiguration
-public class ApplicationConfig {
-
-    @Bean
-    PasswordEncoder passwordEncoder() {
-        return new BCryptPasswordEncoder();
-    }
-}

src/main/java/ru/soune/no_copy/controller/AuthController.java

@@ -1,58 +0,0 @@
-package ru.soune.no_copy.controller;
-
-import jakarta.validation.Valid;
-import lombok.RequiredArgsConstructor;
-import org.springframework.http.ResponseEntity;
-import org.springframework.web.bind.annotation.*;
-import ru.soune.no_copy.dto.AuthResponse;
-import ru.soune.no_copy.dto.LoginRequest;
-import ru.soune.no_copy.dto.LoginResponse;
-import ru.soune.no_copy.dto.RegisterRequest;
-import ru.soune.no_copy.entity.AuthToken;
-import ru.soune.no_copy.exception.TokenNotFoundException;
-import ru.soune.no_copy.repository.AuthTokenRepository;
-import ru.soune.no_copy.service.AuthService;
-
-import java.util.Map;
-import java.util.Optional;
-
-@RestController
-@RequestMapping("v1/api/auth")
-@RequiredArgsConstructor
-public class AuthController {
-
-    private final AuthService authService;
-
-    private final AuthTokenRepository authTokenRepository;
-
-    @PostMapping("/register")
-    public ResponseEntity<AuthResponse> register(@Valid @RequestBody RegisterRequest registerRequest) {
-        AuthToken authToken = authService.register(registerRequest);
-
-        return ResponseEntity.ok(new AuthResponse(true, "success.user.register", authToken.getToken(),
-                authToken.getExpiresAt()));
-    }
-
-    @PostMapping("/login")
-    public ResponseEntity<LoginResponse> login(@Valid @RequestBody LoginRequest request) {
-        AuthToken login = authService.login(request);
-
-        return ResponseEntity.ok(new LoginResponse(true, login.getUser().getEmail(),
-                login.getToken(),login.getExpiresAt().toString()));
-    }
-
-    @PostMapping("/logout")
-    public ResponseEntity<?> logout(@RequestHeader("Authorization") String tokenHeader) {
-        String token = tokenHeader.replace("Bearer ", "");
-
-        Optional<AuthToken> opToken = authTokenRepository.findByToken(token);
-
-        if (opToken.isEmpty()) {
-            throw new TokenNotFoundException("Token not found");
-        }
-
-        authService.logout(token);
-
-        return ResponseEntity.ok(Map.of("success", true));
-    }
-}

src/main/java/ru/soune/no_copy/controller/UserContentController.java

@@ -1,11 +0,0 @@
-package ru.soune.no_copy.controller;
-
-import lombok.AllArgsConstructor;
-import org.springframework.web.bind.annotation.RequestMapping;
-import org.springframework.web.bind.annotation.RestController;
-
-@RestController
-@RequestMapping("v1/api/content")
-@AllArgsConstructor
-public class UserContentController {
-}

src/main/java/ru/soune/no_copy/controller/UserController.java

@@ -1,111 +0,0 @@
-package ru.soune.no_copy.controller;
-
-import lombok.RequiredArgsConstructor;
-import org.springframework.http.ResponseEntity;
-import org.springframework.web.bind.annotation.*;
-import ru.soune.no_copy.dto.ChangePasswordRequest;
-import ru.soune.no_copy.dto.UserDTO;
-import ru.soune.no_copy.dto.UserRequest;
-import ru.soune.no_copy.entity.AuthToken;
-import ru.soune.no_copy.entity.User;
-import ru.soune.no_copy.exception.InvalidUserEmail;
-import ru.soune.no_copy.exception.NotFoundAuthToken;
-import ru.soune.no_copy.mapper.UserMapper;
-import ru.soune.no_copy.repository.AuthTokenRepository;
-import ru.soune.no_copy.repository.UserRepository;
-import ru.soune.no_copy.service.UserService;
-
-import java.util.List;
-import java.util.Optional;
-
-@RestController
-@RequestMapping("v1/api/user")
-@RequiredArgsConstructor
-public class UserController {
-
-    private final UserRepository userRepository;
-
-    private final UserService userService;
-
-    private final AuthTokenRepository authTokenRepository;
-
-    private final UserMapper userMapper;
-
-    @GetMapping("/all")
-    public ResponseEntity<List<UserDTO>> getAllUsers() {
-        List<UserDTO> allUsers = userRepository.findAll().stream()
-                .map(u -> new UserDTO(u.getFullName(), u.getCompany(), u.getEmail(), u.getIsActive(),
-                        u.getPhone(), u.getGenderType(),
-                        u.getBirthday(), u.getCreatedAt(), u.getSubscriptionType()))
-                .toList();
-
-        return ResponseEntity.ok(allUsers);
-    }
-
-    @GetMapping
-    public ResponseEntity<UserDTO> getUser(@RequestParam("email") String email,
-                                           @RequestHeader("Authorization") String tokenHeader) {
-        String token = tokenHeader.replace("Bearer ", "");
-
-        Optional<AuthToken> tokenOptional = authTokenRepository.findByToken(token);
-
-        AuthToken authToken = tokenOptional.orElseThrow(() -> new NotFoundAuthToken("Token: " + token + "not found"));
-
-        if (authToken != null) {
-            Optional<User> user = userRepository.findByEmail(email);
-            //TODO add mapper
-            if (user.isPresent()) {
-                UserDTO userDTO = userMapper.toDTO(user.get());
-                userDTO.setEmail(email);
-                userDTO.setFullName(user.get().getFullName());
-                userDTO.setCompany(user.get().getCompany());
-                userDTO.setPhone(user.get().getPhone());
-                userDTO.setGenderType(user.get().getGenderType());
-                userDTO.setBirthday(user.get().getBirthday());
-                userDTO.setCreatedAt(user.get().getCreatedAt());
-                userDTO.setSubscriptionType(user.get().getSubscriptionType());
-                userDTO.setActive(user.get().getIsActive());
-
-                return ResponseEntity.ok(userDTO);
-            }
-
-        }
-
-        return ResponseEntity.notFound().build();
-    }
-
-    //TODO fix mapper,doesnot exist all fields
-    @PostMapping("/change-password")
-    public ResponseEntity<UserDTO> updateUser(@RequestBody ChangePasswordRequest changePasswordRequest,
-                                              @RequestHeader("Authorization") String tokenHeader) {
-        String token = tokenHeader.replace("Bearer ", "");
-
-        Optional<AuthToken> tokenOptional = authTokenRepository.findByToken(token);
-
-        AuthToken authToken = tokenOptional.orElseThrow(() -> new NotFoundAuthToken("Token: " + token + "not found"));
-
-        User user = authToken.getUser();
-
-        if (!changePasswordRequest.getEmail().equals(user.getEmail())) {
-            throw new InvalidUserEmail("Email is not valid: " + changePasswordRequest.getEmail() + "not found");
-        }
-
-        User updateUser = userService.changePassword(user, changePasswordRequest);
-
-        return ResponseEntity.ok(userMapper.toDTO(updateUser));
-    }
-
-    @PatchMapping("/user-update")
-    public ResponseEntity<UserDTO> updateUser(@RequestBody UserRequest userRequest,
-                                              @RequestHeader("Authorization") String tokenHeader) {
-        String token = tokenHeader.replace("Bearer ", "");
-
-        Optional<AuthToken> tokenOptional = authTokenRepository.findByToken(token);
-
-        AuthToken authToken = tokenOptional.orElseThrow(() -> new NotFoundAuthToken("Token: " + token + "not found"));
-
-        User user = authToken.getUser();
-
-        return ResponseEntity.ok(userService.updateUser(userRequest, user));
-    }
-}

src/main/java/ru/soune/no_copy/dto/AuthResponse.java

@@ -1,10 +0,0 @@
-package ru.soune.no_copy.dto;
-
-import java.time.LocalDateTime;
-
-public record AuthResponse (
-        boolean success,
-        String message,
-        String token,
-        LocalDateTime expiresAt
-) {}

src/main/java/ru/soune/no_copy/dto/LoginResponse.java

@@ -1,14 +0,0 @@
-package ru.soune.no_copy.dto;
-
-import lombok.AllArgsConstructor;
-import lombok.Data;
-import ru.soune.no_copy.entity.User;
-
-@Data
-@AllArgsConstructor
-public class LoginResponse {
-    private boolean success;
-    private String email;
-    private String token;
-    private String expiresAt;
-}

src/main/java/ru/soune/no_copy/dto/RegisterRequest.java

@@ -1,40 +0,0 @@
-package ru.soune.no_copy.dto;
-
-import com.fasterxml.jackson.annotation.JsonFormat;
-import jakarta.validation.constraints.Email;
-import jakarta.validation.constraints.NotBlank;
-import jakarta.validation.constraints.Past;
-import jakarta.validation.constraints.Size;
-import org.springframework.format.annotation.DateTimeFormat;
-import ru.soune.no_copy.entity.GenderType;
-import ru.soune.no_copy.entity.SubscriptionType;
-
-import java.time.LocalDate;
-
-public record RegisterRequest(
-        @NotBlank(message = "error.name.length")
-        String fullName,
-
-        String companyName,
-
-        @Size(min = 11, max = 14)
-        String phone,
-
-        @NotBlank(message = "error.not.blank")
-        @Email(message = "error.not.email")
-        @Size(max = 128)
-        String email,
-
-        @DateTimeFormat(pattern = "dd-MM-yyyy")
-        @JsonFormat(pattern = "dd-MM-yyyy")
-        @Past
-        LocalDate birthday,
-
-        @NotBlank(message = "error.not.blank")
-        @Size(min = 8)
-        String password,
-
-        SubscriptionType subscriptionType,
-
-        GenderType genderType
-) {}

src/main/java/ru/soune/no_copy/dto/UserContentDTO.java

@@ -1,15 +0,0 @@
-package ru.soune.no_copy.dto;
-
-import lombok.Data;
-import ru.soune.no_copy.entity.FileType;
-
-@Data
-public class UserContentDTO {
-    String fileName;
-    String originalFilename;
-    String fileType;
-    String fileExtension;
-    Long fileSize;
-    String filePath;
-    Integer protectionLevel;
-}

src/main/java/ru/soune/no_copy/dto/UserContentResponse.java

@@ -1,17 +0,0 @@
-package ru.soune.no_copy.dto;
-
-import ru.soune.no_copy.entity.ContentStatus;
-import ru.soune.no_copy.entity.FileType;
-
-import java.time.LocalDateTime;
-
-public record UserContentResponse(
-        Long id,
-        String filename,
-        String originalFilename,
-        FileType fileType,
-        long fileSize,
-        String filePath,
-        ContentStatus status,
-        LocalDateTime uploadDate
-) {}

src/main/java/ru/soune/no_copy/entity/FileType.java

@@ -1,21 +0,0 @@
-package ru.soune.no_copy.entity;
-
-import lombok.Getter;
-
-@Getter
-public enum FileType {
-    PHOTO("photo"),
-    VIDEO("video"),
-    AUDIO("audio"),
-    DOCUMENT("document");
-
-    private final String code;
-
-    FileType(String code) {
-        this.code = code;
-    }
-
-    public String getCode() {
-        return code;
-    }
-}

src/main/java/ru/soune/no_copy/entity/ImageProtection.java

@@ -1,49 +0,0 @@
-package ru.soune.no_copy.entity;
-
-import jakarta.persistence.*;
-import lombok.*;
-import org.springframework.data.annotation.CreatedDate;
-import org.springframework.data.jpa.domain.support.AuditingEntityListener;
-
-import java.time.LocalDateTime;
-
-@Entity
-@Table(name = "image_protection")
-@Getter
-@Setter
-@NoArgsConstructor
-@AllArgsConstructor
-@ToString
-@EntityListeners(AuditingEntityListener.class)
-public class ImageProtection {
-
-    @Id
-    @GeneratedValue(strategy = GenerationType.IDENTITY)
-    private Long protectionId;
-
-    @ManyToOne(fetch = FetchType.LAZY)
-    @JoinColumn(name = "user_id", nullable = false)
-    @ToString.Exclude
-    private User user;
-
-    @ManyToOne(fetch = FetchType.LAZY)
-    @JoinColumn(name = "content_id", nullable = false)
-    @ToString.Exclude
-    private UserContent content;
-
-    @Column(name = "protection_method", nullable = false, length = 50)
-    private String protectionMethod;
-
-    @Column(name = "protection_level", nullable = false)
-    private Integer protectionLevel;
-
-    @Column(name = "is_active", nullable = false)
-    private Boolean isActive = true;
-
-    @CreatedDate
-    @Column(name = "applied_at", nullable = false, updatable = false)
-    private LocalDateTime appliedAt;
-
-    @Column(name = "metadata", columnDefinition = "JSON")
-    private String metadata;
-}

src/main/java/ru/soune/no_copy/entity/User.java

@@ -1,92 +0,0 @@
-package ru.soune.no_copy.entity;
-
-import com.fasterxml.jackson.annotation.JsonIgnore;
-import jakarta.persistence.*;
-import jakarta.validation.constraints.Size;
-import lombok.*;
-import org.springframework.data.annotation.CreatedDate;
-import org.springframework.data.jpa.domain.support.AuditingEntityListener;
-
-import java.time.LocalDate;
-import java.time.LocalDateTime;
-import java.util.ArrayList;
-import java.util.List;
-
-@Entity
-@Table(name = "users")
-@Getter
-@Setter
-@NoArgsConstructor
-@AllArgsConstructor
-@ToString
-@EntityListeners(AuditingEntityListener.class)
-public class User {
-
-    @Id
-    @GeneratedValue(strategy = GenerationType.IDENTITY)
-    private Long Id;
-
-    @Column(name = "full_name", nullable = false)
-    private String fullName;
-
-    @Size(max = 1024)
-    @Column(name = "email", nullable = false, length = 1024, unique = true)
-    private String email;
-
-    @Column(name = "company")
-    private String company;
-
-    @Column(nullable = false)
-    @Size(min = 6)
-    @JsonIgnore
-    private String password;
-
-    @Size(min = 11, max = 14)
-    private String phone;
-
-    @Enumerated(EnumType.STRING)
-    @Column(name = "subscription_type", nullable = false, length = 20)
-    private SubscriptionType subscriptionType = SubscriptionType.DEMO;
-
-    @Enumerated(EnumType.STRING)
-    @Column(name = "gender")
-    private GenderType genderType = GenderType.MALE;
-
-    @Column(name = "birthday")
-    private LocalDate birthday;
-
-    @CreatedDate
-    @Column(name = "created_at", updatable = false, nullable = false)
-    private LocalDateTime createdAt;
-
-    @Column(name = "last_login_at")
-    private LocalDateTime lastLoginAt;
-
-    @Column(name = "is_active")
-    private Boolean isActive = true;
-
-    @OneToMany(mappedBy = "user", cascade = CascadeType.ALL, orphanRemoval = true)
-    @JsonIgnore
-    @ToString.Exclude
-    private List<AuthToken> tokens = new ArrayList<>();
-
-    @OneToMany(mappedBy = "user", cascade = CascadeType.ALL, orphanRemoval = true)
-    @JsonIgnore
-    @ToString.Exclude
-    private List<UserContent> userContents = new ArrayList<>();
-
-    @OneToMany(mappedBy = "user", cascade = CascadeType.ALL, orphanRemoval = true)
-    @JsonIgnore
-    @ToString.Exclude
-    private List<UserAction> userActions = new ArrayList<>();
-
-    @OneToMany(mappedBy = "user", cascade = CascadeType.ALL, orphanRemoval = true)
-    @JsonIgnore
-    @ToString.Exclude
-    private List<Violation> violations = new ArrayList<>();
-
-    @OneToMany(mappedBy = "user", cascade = CascadeType.ALL, orphanRemoval = true)
-    @JsonIgnore
-    @ToString.Exclude
-    private List<ImageProtection> imageProtections = new ArrayList<>();
-}

src/main/java/ru/soune/no_copy/entity/UserAction.java

@@ -1,44 +0,0 @@
-package ru.soune.no_copy.entity;
-
-import jakarta.persistence.*;
-import lombok.*;
-import org.springframework.data.annotation.CreatedDate;
-import org.springframework.data.jpa.domain.support.AuditingEntityListener;
-
-import java.time.LocalDateTime;
-
-@Entity
-@Table(name = "user_actions")
-@Getter
-@Setter
-@NoArgsConstructor
-@AllArgsConstructor
-@ToString
-@EntityListeners(AuditingEntityListener.class)
-public class UserAction {
-
-    @Id
-    @GeneratedValue(strategy = GenerationType.IDENTITY)
-    private Long actionId;
-
-    @ManyToOne(fetch = FetchType.LAZY)
-    @JoinColumn(name = "user_id", nullable = false)
-    @ToString.Exclude
-    private User user;
-
-    @Column(name = "action", nullable = false, length = 100)
-    private String action;
-
-    @Column(name = "details", columnDefinition = "TEXT")
-    private String details;
-
-    @Column(name = "ip_address", length = 45)
-    private String ipAddress;
-
-    @Column(name = "user_agent", columnDefinition = "TEXT")
-    private String userAgent;
-
-    @CreatedDate
-    @Column(name = "created_at", nullable = false, updatable = false)
-    private LocalDateTime createdAt;
-}

src/main/java/ru/soune/no_copy/entity/Violation.java

@@ -1,56 +0,0 @@
-package ru.soune.no_copy.entity;
-
-import jakarta.persistence.*;
-import lombok.*;
-import org.springframework.data.annotation.CreatedDate;
-import org.springframework.data.jpa.domain.support.AuditingEntityListener;
-
-import java.time.LocalDateTime;
-
-@Entity
-@Table(name = "violations")
-@Getter
-@Setter
-@NoArgsConstructor
-@AllArgsConstructor
-@ToString
-@EntityListeners(AuditingEntityListener.class)
-public class Violation {
-
-    @Id
-    @GeneratedValue(strategy = GenerationType.IDENTITY)
-    private Long violationId;
-
-    @ManyToOne(fetch = FetchType.LAZY)
-    @JoinColumn(name = "user_id", nullable = false)
-    @ToString.Exclude
-    private User user;
-
-    @Column(name = "violation_type", nullable = false, length = 50)
-    private String violationType;
-
-    @Column(name = "description", columnDefinition = "TEXT")
-    private String description;
-
-    @Column(name = "content_id")
-    private Long contentId;
-
-    @Column(name = "status", nullable = false, length = 20)
-    private String status = "new";
-
-    @Column(name = "severity", length = 20)
-    private String severity;
-
-    @Column(name = "resolved_at")
-    private LocalDateTime resolvedAt;
-
-    @Column(name = "resolved_by")
-    private Long resolvedBy;
-
-    @Column(name = "resolution_notes", columnDefinition = "TEXT")
-    private String resolutionNotes;
-
-    @CreatedDate
-    @Column(name = "created_at", nullable = false, updatable = false)
-    private LocalDateTime createdAt;
-}

src/main/java/ru/soune/no_copy/exception/UserAlreadyExistsException.java

@@ -1,7 +0,0 @@
-package ru.soune.no_copy.exception;
-
-public class UserAlreadyExistsException extends RuntimeException {
-    public UserAlreadyExistsException(String message) {
-        super(message);
-    }
-}

src/main/java/ru/soune/no_copy/repository/AuthTokenRepository.java

@@ -1,14 +0,0 @@
-package ru.soune.no_copy.repository;
-
-import org.springframework.data.jpa.repository.JpaRepository;
-import org.springframework.stereotype.Repository;
-import ru.soune.no_copy.entity.AuthToken;
-
-import java.time.LocalDate;
-import java.util.Optional;
-
-@Repository
-public interface AuthTokenRepository extends JpaRepository<AuthToken, Long> {
-    Optional<AuthToken> findByTokenAndExpiresAtAfter(String token, LocalDate expiresAtAfter);
-    Optional<AuthToken> findByToken(String token);
-}

src/main/java/ru/soune/no_copy/repository/UserRepository.java

@@ -1,11 +0,0 @@
-package ru.soune.no_copy.repository;
-
-import org.springframework.data.jpa.repository.JpaRepository;
-import ru.soune.no_copy.entity.User;
-
-import java.util.Optional;
-
-public interface UserRepository extends JpaRepository<User, Long> {
-    Optional<User> findByEmail(String email);
-    boolean existsByEmail(String email);
-}

src/main/java/ru/soune/no_copy/service/AuthService.java

@@ -1,101 +0,0 @@
-package ru.soune.no_copy.service;
-
-import lombok.RequiredArgsConstructor;
-import org.springframework.context.MessageSource;
-import org.springframework.security.crypto.password.PasswordEncoder;
-import org.springframework.stereotype.Service;
-import org.springframework.transaction.annotation.Transactional;
-import ru.soune.no_copy.dto.LoginRequest;
-import ru.soune.no_copy.dto.RegisterRequest;
-import ru.soune.no_copy.entity.AuthToken;
-import ru.soune.no_copy.entity.User;
-import ru.soune.no_copy.exception.NotValidationPasswordException;
-import ru.soune.no_copy.exception.UserAlreadyExistsException;
-import ru.soune.no_copy.exception.UserNotFoundException;
-import ru.soune.no_copy.repository.AuthTokenRepository;
-import ru.soune.no_copy.repository.UserRepository;
-
-import java.security.SecureRandom;
-import java.time.LocalDateTime;
-import java.util.Base64;
-import java.util.Locale;
-import java.util.Optional;
-
-@Service
-@RequiredArgsConstructor
-public class AuthService {
-
-    private final UserRepository userRepository;
-
-    private final AuthTokenRepository authTokenRepository;
-
-    private final PasswordEncoder passwordEncoder;
-
-    private final MessageSource messageSource;
-
-    private final SecureRandom secureRandom = new SecureRandom();
-
-    @Transactional
-    public AuthToken register(RegisterRequest registerRequest) {
-        if (userRepository.existsByEmail(registerRequest.email())) {
-            throw new UserAlreadyExistsException("User already exists with email: " + registerRequest.email());
-        }
-
-        User user = new User();
-        user.setFullName(registerRequest.fullName());
-        user.setEmail(registerRequest.email());
-        user.setPassword(passwordEncoder.encode(registerRequest.password()));
-
-        if (registerRequest.companyName() != null) {
-            user.setCompany(registerRequest.companyName());
-        }
-
-        if (registerRequest.phone() != null) {
-            user.setPhone(registerRequest.phone());
-        }
-
-        User savedUser = userRepository.save(user);
-
-        AuthToken authToken = new AuthToken();
-        authToken.setToken(generateAuthToken());
-        authToken.setUser(savedUser);
-
-        return authTokenRepository.save(authToken);
-    }
-
-    @Transactional
-    public AuthToken login(LoginRequest request) {
-        Optional<User> userOpt = userRepository.findByEmail(request.getEmail());
-
-        if (userOpt.isEmpty()) {
-            throw new UserNotFoundException("User with email " + request.getEmail() + " not found");
-        }
-
-        User user = userOpt.get();
-
-        if (!passwordEncoder.matches(request.getPassword(), user.getPassword())) {
-            throw new NotValidationPasswordException("Invalid password");
-        }
-
-        user.setLastLoginAt(LocalDateTime.now());
-        User savedUser = userRepository.save(user);
-
-        AuthToken authToken = new AuthToken();
-        authToken.setToken(generateAuthToken());
-        authToken.setUser(savedUser);
-
-        return authTokenRepository.save(authToken);
-    }
-
-    @Transactional
-    public void logout(String token) {
-        authTokenRepository.findByToken(token)
-                .ifPresent(authTokenRepository::delete);
-    }
-
-    private String generateAuthToken() {
-        byte[] bytes = new byte[32];
-        secureRandom.nextBytes(bytes);
-        return Base64.getUrlEncoder().withoutPadding().encodeToString(bytes);
-    }
-}

src/main/java/ru/soune/no_copy/service/UserContentService.java

@@ -1,72 +0,0 @@
-package ru.soune.no_copy.service;
-
-import lombok.AllArgsConstructor;
-import org.springframework.stereotype.Service;
-import org.springframework.transaction.annotation.Transactional;
-import ru.soune.no_copy.dto.UserContentRequest;
-import ru.soune.no_copy.dto.UserContentUpdateRequest;
-import ru.soune.no_copy.entity.FileType;
-import ru.soune.no_copy.entity.User;
-import ru.soune.no_copy.entity.UserContent;
-import ru.soune.no_copy.exception.ContentNotFoundException;
-import ru.soune.no_copy.exception.UserNotFoundException;
-import ru.soune.no_copy.mapper.UserContentMapper;
-import ru.soune.no_copy.repository.UserContentRepository;
-import ru.soune.no_copy.repository.UserRepository;
-
-import java.util.List;
-import java.util.Optional;
-
-@Service
-@AllArgsConstructor
-public class UserContentService {
-
-    private final UserContentRepository userContentRepository;
-
-    private final UserRepository userRepository;
-
-    private final UserContentMapper userContentMapper;
-
-    public List<UserContent> findByUser(long userId) {
-        return userContentRepository.findByUserId(userId);
-    }
-
-    @Transactional
-    public UserContent addUserContent(UserContentRequest userContentRequest) {
-        UserContent userContent = new UserContent();
-
-        Optional<User> byEmail = userRepository.findByEmail(userContentRequest.userEmail());
-        User user = byEmail.orElseThrow(() -> new UserNotFoundException(userContentRequest.userEmail()));
-
-        userContent.setUser(user);
-        userContent.setFilename(userContentRequest.fileName());
-        userContent.setFileExtension(userContentRequest.fileExtension());
-        userContent.setFilePath(userContentRequest.filePath());
-        userContent.setFileType(FileType.valueOf(userContentRequest.fileType()));
-        userContent.setOriginalFilename(userContentRequest.originalFilename());
-        userContent.setProtectionLevel(userContentRequest.protectionLevel());
-        userContent.setFileSize(userContentRequest.fileSize());
-
-        //TODO add
-        //    @Column(name = "protection_hash", length = 64)
-        //    private String protectionHash;
-        //    @Column(name = "watermark_id", length = 50)
-        //    private String watermarkId;
-
-        return userContentRepository.save(userContent);
-    }
-
-    @Transactional
-    public UserContent updateUserContent(UserContentUpdateRequest userContentRequest) {
-        UserContent entity = userContentRepository.findById(userContentRequest.id())
-                .orElseThrow(() -> new ContentNotFoundException("Content not found with: " + userContentRequest.id()));
-
-        userContentMapper.updateEntityFromDto(userContentRequest, entity);
-
-        return userContentRepository.save(entity);
-    }
-
-    public void deleteUserContent(long userContentId) {
-        userContentRepository.deleteById(userContentId);
-    }
-}

src/main/java/ru/soune/no_copy/service/UserService.java

@@ -1,86 +0,0 @@
-package ru.soune.no_copy.service;
-
-import lombok.AllArgsConstructor;
-import org.springframework.security.crypto.password.PasswordEncoder;
-import org.springframework.stereotype.Service;
-import org.springframework.transaction.annotation.Transactional;
-import ru.soune.no_copy.dto.ChangePasswordRequest;
-import ru.soune.no_copy.dto.UserDTO;
-import ru.soune.no_copy.dto.UserRequest;
-import ru.soune.no_copy.entity.User;
-import ru.soune.no_copy.exception.InvalidUserEmail;
-import ru.soune.no_copy.exception.NotValidationPasswordException;
-import ru.soune.no_copy.exception.UserNotFoundException;
-import ru.soune.no_copy.repository.UserRepository;
-
-@Service
-@AllArgsConstructor
-public class UserService {
-
-    private final UserRepository userRepository;
-
-    private final PasswordEncoder passwordEncoder;
-
-    @Transactional
-    public User changePassword(User user, ChangePasswordRequest request) {
-        if (!passwordEncoder.matches(request.getCurrentPassword(), user.getPassword())) {
-            throw new NotValidationPasswordException("Current password is incorrect");
-        }
-
-        user.setPassword(passwordEncoder.encode(request.getNewPassword()));
-
-        return userRepository.save(user);
-    }
-
-    @Transactional
-    public UserDTO updateUser(UserRequest userRequest, User currentUser) {
-        User user = userRepository.findById(currentUser.getId())
-                .orElseThrow(() -> new UserNotFoundException("User not found with id: " + currentUser.getId()));
-
-        updateUserFromRequest(user, userRequest);
-
-        User updatedUser = userRepository.save(user);
-
-        return mapToDTO(updatedUser);
-    }
-
-    private void updateUserFromRequest(User user, UserRequest request) {
-        if (request.getFullName() != null) {
-            user.setFullName(request.getFullName());
-        }
-
-        if (request.getCompany() != null) {
-            user.setCompany(request.getCompany());
-        }
-
-        if (request.getEmail() != null && !request.getEmail().equals(user.getEmail())) {
-            if (userRepository.existsByEmail(request.getEmail())) {
-                throw new InvalidUserEmail("Email already exists: " + request.getEmail());
-            }
-            user.setEmail(request.getEmail());
-        }
-
-        if (request.getPhone() != null) {
-            user.setPhone(request.getPhone());
-        }
-        if (request.getGenderType() != null) {
-            user.setGenderType(request.getGenderType());
-        }
-        if (request.getBirthday() != null) {
-            user.setBirthday(request.getBirthday());
-        }
-    }
-
-    private UserDTO mapToDTO(User user) {
-        return UserDTO.builder()
-                .fullName(user.getFullName())
-                .email(user.getEmail())
-                .company(user.getCompany())
-                .phone(user.getPhone())
-                .genderType(user.getGenderType())
-                .birthday(user.getBirthday())
-                .subscriptionType(user.getSubscriptionType())
-                .createdAt(user.getCreatedAt())
-                .build();
-    }
-}

src/main/java/ru/soune/nocopy/NoCopyApplication.java

@@ -1,9 +1,13 @@
-package ru.soune.no_copy;
+package ru.soune.nocopy;
 
 import org.springframework.boot.SpringApplication;
 import org.springframework.boot.autoconfigure.SpringBootApplication;
+import org.springframework.cache.annotation.EnableCaching;
+import org.springframework.scheduling.annotation.EnableScheduling;
 
 @SpringBootApplication
+@EnableScheduling
+@EnableCaching
 public class NoCopyApplication {
 
 	public static void main(String[] args) {

src/main/java/ru/soune/nocopy/client/YooKassaClient.java

@@ -0,0 +1,69 @@
+package ru.soune.nocopy.client;
+
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.stereotype.Component;
+import java.net.URI;
+import java.net.http.HttpClient;
+import java.net.http.HttpRequest;
+import java.net.http.HttpResponse;
+import java.nio.charset.StandardCharsets;
+import java.util.Base64;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.UUID;
+import com.fasterxml.jackson.databind.ObjectMapper;
+
+@Component
+@Slf4j
+public class YooKassaClient {
+
+    @Value("${yookassa.shop-id}")
+    private String shopId;
+
+    @Value("${yookassa.secret-key}")
+    private String secretKey;
+
+    private final HttpClient httpClient = HttpClient.newHttpClient();
+
+    private final ObjectMapper mapper = new ObjectMapper();
+
+    public boolean createAutoPayment(String paymentMethodId, double amount, String description, String userId) {
+        try {
+            String url = "https://api.yookassa.ru/v3/payments";
+            String auth = shopId + ":" + secretKey;
+            String encodedAuth = Base64.getEncoder().encodeToString(auth.getBytes(StandardCharsets.UTF_8));
+
+            Map<String, Object> body = new HashMap<>();
+            body.put("amount", Map.of("value", String.format("%.2f", amount),
+                    "currency", "RUB"));
+            body.put("payment_method_id", paymentMethodId);
+            body.put("description", description);
+            body.put("capture", true);
+            body.put("metadata", Map.of("user_id", userId, "auto_payment", "true"));
+
+            String requestBody = mapper.writeValueAsString(body);
+
+            HttpRequest request = HttpRequest.newBuilder()
+                    .uri(URI.create(url))
+                    .header("Content-Type", "application/json")
+                    .header("Authorization", "Basic " + encodedAuth)
+                    .header("Idempotence-Key", UUID.randomUUID().toString())
+                    .POST(HttpRequest.BodyPublishers.ofString(requestBody))
+                    .build();
+
+            HttpResponse<String> response = httpClient.send(request, HttpResponse.BodyHandlers.ofString());
+
+            if (response.statusCode() == 200 || response.statusCode() == 201) {
+                log.info("Auto payment created: {}", response.body());
+                return true;
+            } else {
+                log.error("Auto payment failed: {} - {}", response.statusCode(), response.body());
+                return false;
+            }
+        } catch (Exception e) {
+            log.error("Error creating auto payment", e);
+            return false;
+        }
+    }
+}

src/main/java/ru/soune/nocopy/configuration/ApplicationConfig.java

@@ -0,0 +1,73 @@
+package ru.soune.nocopy.configuration;
+
+import com.github.benmanes.caffeine.cache.Caffeine;
+import com.vrt.AudioFilePathProvider;
+import com.vrt.fileprotection.FileProtector;
+import com.vrt.fileprotection.audio.AudioLocalSearch;
+import com.vrt.fileprotection.documents.DocumentLocalSearch;
+import com.vrt.fileprotection.image.ImageLocalSearch;
+import com.vrt.fileprotection.image.ImageUniqueCheck;
+import lombok.AllArgsConstructor;
+import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
+import org.springframework.cache.CacheManager;
+import org.springframework.cache.annotation.EnableCaching;
+import org.springframework.cache.caffeine.CaffeineCacheManager;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
+import org.springframework.security.crypto.password.PasswordEncoder;
+
+import java.util.Collections;
+import java.util.concurrent.TimeUnit;
+
+@Configuration
+@EnableAutoConfiguration
+@AllArgsConstructor
+@EnableCaching
+public class ApplicationConfig {
+
+    @Bean
+    PasswordEncoder passwordEncoder() {
+        return new BCryptPasswordEncoder();
+    }
+
+    @Bean
+    public com.vrt.
+            NoCopyFileService noCopyFileService(
+            FileProtector.FileProvider fileProvider,
+            FileProtector.ProcessingListener processingListener,
+            ImageUniqueCheck imageUniqueCheck,
+            ImageLocalSearch imageLocalSearch,
+            AudioLocalSearch audioLocalSearch,
+            AudioFilePathProvider audioFilePathProvider,
+            DocumentLocalSearch documentLocalSearch) {
+
+        return new com.vrt.NoCopyFileService(
+                Collections.emptyList(),
+                fileProvider,
+                processingListener,
+                imageUniqueCheck,
+                imageLocalSearch,
+                audioLocalSearch,
+                audioFilePathProvider,
+                documentLocalSearch
+        );
+    }
+
+    @Bean
+    public CacheManager cacheManager() {
+        CaffeineCacheManager cacheManager = new CaffeineCacheManager(
+                "reverseImageSearch", "parsedImages");
+
+        cacheManager.setCaffeine(Caffeine.newBuilder()
+                .maximumSize(2_000)
+                .expireAfterWrite(1, TimeUnit.HOURS)
+                .expireAfterAccess(30, TimeUnit.MINUTES)
+                .softValues()
+                .recordStats()
+        );
+
+        return cacheManager;
+    }
+}
+

src/main/java/ru/soune/nocopy/configuration/CorsConfig.java

@@ -0,0 +1,23 @@
+package ru.soune.nocopy.configuration;
+
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.web.cors.CorsConfiguration;
+import org.springframework.web.cors.UrlBasedCorsConfigurationSource;
+import org.springframework.web.filter.CorsFilter;
+
+@Configuration
+public class CorsConfig {
+
+    @Bean
+    public CorsFilter corsFilter() {
+        UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
+        CorsConfiguration config = new CorsConfiguration();
+        config.addAllowedOrigin("*");
+        config.addAllowedMethod("*");
+        config.addAllowedHeader("*");
+        source.registerCorsConfiguration("/**", config);
+
+        return new CorsFilter(source);
+    }
+}

src/main/java/ru/soune/nocopy/configuration/HandlerConfig.java

@@ -0,0 +1,157 @@
+package ru.soune.nocopy.configuration;
+
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import ru.soune.nocopy.handler.*;
+
+import java.util.HashMap;
+import java.util.Map;
+
+@Configuration
+public class HandlerConfig {
+/*
+RegRequestHandler
+LoginRequestHandler
+FileUploadHandler
+FileEntityHandler
+ImageFoundRequestHandler
+VerifyRegisterUserHandler
+TariffHandler
+ReferralHandler
+ResetPasswordHandler
+MonitoringHandler
+GlobalSearchHandler
+ComplaintEntityHandler
+ViolationNotionHandler
+NotificationHandler
+TokenOperationHandler
+DockViewFileHandler
+ */
+
+/*
+Убрать
+LogoutRequestHandler logoutHandler
+ */
+    @Bean
+    public Map<Integer, RequestHandler> handlers(
+            FileUploadHandler upload,
+            FileEntityHandler file,
+            ImageFoundRequestHandler imageFoundRequestHandler,
+            VerifyRegisterUserHandler verifyRegisterUser,
+            AuthRequestHandler authRequestHandler,
+            CompanyHandler companyHandler,
+            TariffHandler tariffHandler,
+            TariffInfoHandler tariffInfoHandler,
+            ReferralHandler referralHandler,
+            PaymentHandler paymentHandler,
+            CostHandler costHandler,
+            MonitoringHandler monitoringHandler,
+            ViolationHandler violationHandler,
+            ViolationStatisticsHandler violationStatisticsHandler,
+            GlobalSearchHandler globalSearchHandler,
+            ViolationNotionHandler violationNotionHandler,
+            ComplaintEntityHandler complaintEntityHandler,
+            UserInfoHandler userInfoHandler,
+            NotificationHandler notificationHandler,
+            UserVerificationHandler userVerificationHandler,
+            LawCaseHandler lawCaseHandler,
+            TokenOperationHandler tokenOperationHandler,
+            MonitoringStatisticHandler monitoringStatisticHandler,
+            DockViewFileHandler dockViewFileHandler
+    ) {
+        Map<Integer, RequestHandler> map = new HashMap<>();
+        map.put(20004, upload);
+        map.put(20005, file);
+        map.put(20007, imageFoundRequestHandler);
+        map.put(20008, authRequestHandler);
+        map.put(20009, verifyRegisterUser);
+        map.put(30000, companyHandler);
+        map.put(30001, tariffHandler);
+        map.put(30002, tariffInfoHandler);
+        map.put(30003, referralHandler);
+        map.put(30005, paymentHandler);
+        map.put(30007, monitoringHandler);
+        map.put(30008, costHandler);
+        map.put(30009, violationHandler);
+        map.put(30010, violationStatisticsHandler);
+        map.put(30011, globalSearchHandler);
+        map.put(30012, violationNotionHandler);
+        map.put(30013, complaintEntityHandler);
+        map.put(30014, userInfoHandler);
+        map.put(30015, notificationHandler);
+        map.put(30016, userVerificationHandler);
+        map.put(30017, lawCaseHandler);
+        map.put(30018, tokenOperationHandler);
+        map.put(30027, monitoringStatisticHandler);
+        map.put(30028, dockViewFileHandler);
+
+        return map;
+    }
+
+    @Bean
+    public Map<Integer, RequestHandler> internalInfoHandler(
+         StatisticComplaintHandler statisticComplaintHandler,
+         StatisticUserFilesHandler statisticUserHandler,
+         StatisticTariffInfoFileHandler statisticTariffInfoFileHandler,
+         StatisticUserDynamicHandler statisticUserDynamicHandler,
+         StatisticProtectedFilesHandler statisticProtectedFilesHandler,
+         StatisticViolationHandler statisticViolationHandler,
+         StatisticSubscriberHandler statisticSubscriberHandler,
+         StatisticTokenHandler statisticTokenHandler,
+         StatisticIncomeHandler statisticIncomeHandler,
+         FileInteranlInfoHandler fileInfo,
+         TariffInformationHandler tariffInformationHandler,
+         UserInfoHandler userInfoHandler
+    )
+    {
+        Map<Integer, RequestHandler> map = new HashMap<>();
+        map.put(30014, userInfoHandler);
+        map.put(30019, statisticUserHandler);
+        map.put(30020, statisticTariffInfoFileHandler);
+        map.put(30021, statisticUserDynamicHandler);
+        map.put(30022, statisticProtectedFilesHandler);
+        map.put(30023, statisticViolationHandler);
+        map.put(30024, statisticSubscriberHandler);
+        map.put(30025, statisticTokenHandler);
+        map.put(30026, statisticIncomeHandler);
+        map.put(30029, statisticComplaintHandler);
+        map.put(40001, fileInfo);
+        map.put(40004, tariffInformationHandler);
+
+        return map;
+    }
+
+    @Bean
+    public Map<Integer, RequestHandler> internalControlHandler(
+            ControlComplaintHandler controlComplaintHandler,
+            FileInternalControlHandler fileInternalControlHandler,
+            TariffControlHandler tariffControlHandler,
+            UserInfoHandler userInfoHandler
+    )
+    {
+        Map<Integer, RequestHandler> map = new HashMap<>();
+        map.put(30014, userInfoHandler);
+        map.put(30030, controlComplaintHandler);
+        map.put(40002, fileInternalControlHandler);
+        map.put(40003, tariffControlHandler);
+
+        return map;
+    }
+
+    @Bean
+    public Map<Integer, RequestHandler> authHandler(
+            RegRequestHandler reg,
+            LoginRequestHandler login,
+            DaDataHandler daDataHandler,
+            ResetPasswordHandler resetPasswordHandler
+            )
+    {
+        Map<Integer, RequestHandler> map = new HashMap<>();
+        map.put(20001, login);
+        map.put(20002, reg);
+        map.put(30004, daDataHandler);
+        map.put(20010, resetPasswordHandler);
+
+        return map;
+    }
+}

src/main/java/ru/soune/nocopy/configuration/ImageMigration.java

@@ -0,0 +1,44 @@
+package ru.soune.nocopy.configuration;
+
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.context.event.ApplicationReadyEvent;
+import org.springframework.context.event.EventListener;
+import org.springframework.stereotype.Component;
+import ru.soune.nocopy.entity.file.FileEntity;
+import ru.soune.nocopy.repository.FileEntityRepository;
+import ru.soune.nocopy.service.file.ImageResizeService;
+
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.List;
+
+@Component
+@Slf4j
+public class ImageMigration {
+
+    @Autowired
+    private FileEntityRepository fileRepository;
+
+    @Autowired
+    private ImageResizeService imageResizeService;
+
+    @EventListener(ApplicationReadyEvent.class)
+    public void migrate() {
+        List<FileEntity> images = fileRepository.findByThumbnailPathIsNull();
+
+        for (FileEntity file : images) {
+            try {
+                Path path = Paths.get(file.getProtectedFilePath());
+                if (Files.exists(path)) {
+                    byte[] data = Files.readAllBytes(path);
+                    imageResizeService.generateSizes(file, data);
+                    fileRepository.save(file);
+                }
+            } catch (Exception e) {
+                log.error("Error migrating {}: {}", file.getId(), e.getMessage());
+            }
+        }
+    }
+}

src/main/java/ru/soune/nocopy/configuration/JacksonConfig.java

@@ -1,4 +1,4 @@
-package ru.soune.no_copy.configuration;
+package ru.soune.nocopy.configuration;
 
 import com.fasterxml.jackson.databind.ObjectMapper;
 import com.fasterxml.jackson.databind.SerializationFeature;
@@ -9,6 +9,7 @@ import com.fasterxml.jackson.datatype.jsr310.ser.LocalDateTimeSerializer;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
 import org.springframework.context.annotation.Primary;
+import org.springframework.http.converter.json.Jackson2ObjectMapperBuilder;
 
 import java.time.LocalDate;
 import java.time.LocalDateTime;
@@ -20,7 +21,13 @@ public class JacksonConfig {
     @Bean
     @Primary
     public ObjectMapper objectMapper() {
-        ObjectMapper mapper = new ObjectMapper();
+        ObjectMapper mapper = Jackson2ObjectMapperBuilder.json()
+                .defaultViewInclusion(true)
+                .autoDetectFields(true)
+                .failOnUnknownProperties(false)
+                .featuresToDisable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS)
+                .featuresToEnable(SerializationFeature.INDENT_OUTPUT)
+                .build();
 
         JavaTimeModule javaTimeModule = new JavaTimeModule();
 
@@ -35,6 +42,8 @@ public class JacksonConfig {
 
         mapper.registerModule(javaTimeModule);
         mapper.disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS);
+        mapper.configure(com.fasterxml.jackson.databind.DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
+        mapper.enable(SerializationFeature.INDENT_OUTPUT);
 
         return mapper;
     }

src/main/java/ru/soune/nocopy/configuration/JpaConfiguration.java

@@ -1,4 +1,4 @@
-package ru.soune.no_copy.configuration;
+package ru.soune.nocopy.configuration;
 
 import org.springframework.context.annotation.Configuration;
 import org.springframework.data.jpa.repository.config.EnableJpaAuditing;

src/main/java/ru/soune/nocopy/configuration/ReferralConfig.java

@@ -0,0 +1,16 @@
+package ru.soune.nocopy.configuration;
+
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import ru.soune.ReferralLevelProvider;
+import ru.soune.ReferralRepo;
+import ru.soune.ReferralService;
+
+@Configuration
+public class ReferralConfig {
+
+    @Bean
+    public ReferralService referralService(ReferralLevelProvider referralLevelProvider, ReferralRepo referralRepo) {
+        return new ReferralService(referralLevelProvider, referralRepo);
+    }
+}

src/main/java/ru/soune/nocopy/configuration/RestTemplateConfig.java

@@ -0,0 +1,22 @@
+package ru.soune.nocopy.configuration;
+
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.http.client.SimpleClientHttpRequestFactory;
+import org.springframework.web.client.RestTemplate;
+
+@Configuration
+public class RestTemplateConfig {
+
+    @Bean
+    public RestTemplate restTemplate() {
+        RestTemplate restTemplate = new RestTemplate();
+
+        SimpleClientHttpRequestFactory requestFactory = new SimpleClientHttpRequestFactory();
+        requestFactory.setConnectTimeout(30000);
+        requestFactory.setReadTimeout(60000);
+        restTemplate.setRequestFactory(requestFactory);
+
+        return restTemplate;
+    }
+}

src/main/java/ru/soune/nocopy/configuration/SubscriptionConfig.java

@@ -1,4 +1,4 @@
-package ru.soune.no_copy.configuration;
+package ru.soune.nocopy.configuration;
 
 import lombok.Getter;
 import org.springframework.boot.context.properties.ConfigurationProperties;

src/main/java/ru/soune/nocopy/configuration/file/AsyncConfig.java

@@ -0,0 +1,35 @@
+package ru.soune.nocopy.configuration.file;
+
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.scheduling.annotation.EnableAsync;
+import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
+
+import java.util.concurrent.Executor;
+
+@Configuration
+@EnableAsync
+public class AsyncConfig {
+
+    @Bean(name = "fileUploadTaskExecutor")
+    public Executor fileUploadTaskExecutor() {
+        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
+        executor.setCorePoolSize(3);
+        executor.setMaxPoolSize(10);
+        executor.setQueueCapacity(50);
+        executor.setThreadNamePrefix("FileUpload-");
+        executor.initialize();
+        return executor;
+    }
+
+    @Bean(name = "taskExecutor")
+    public Executor taskExecutor() {
+        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
+        executor.setCorePoolSize(3);
+        executor.setMaxPoolSize(5);
+        executor.setQueueCapacity(50);
+        executor.setThreadNamePrefix("global-search-");
+        executor.initialize();
+        return executor;
+    }
+}

src/main/java/ru/soune/nocopy/configuration/file/NoCopyInitializer.java

@@ -0,0 +1,15 @@
+package ru.soune.nocopy.configuration.file;
+
+import lombok.AllArgsConstructor;
+import org.springframework.boot.context.event.ApplicationReadyEvent;
+import org.springframework.context.event.EventListener;
+import org.springframework.stereotype.Component;
+
+@Component
+@AllArgsConstructor
+public class NoCopyInitializer {
+
+    @EventListener(ApplicationReadyEvent.class)
+    public void initializeOnStartup() {
+    }
+}

src/main/java/ru/soune/nocopy/configuration/search/SearchProperties.java

@@ -0,0 +1,26 @@
+package ru.soune.nocopy.configuration.search;
+
+import lombok.Data;
+import org.springframework.boot.context.properties.ConfigurationProperties;
+import org.springframework.stereotype.Component;
+import java.util.Map;
+
+@Data
+@Component
+@ConfigurationProperties(prefix = "search")
+public class SearchProperties {
+    private Map<String, EngineConfig> engines;
+    private ProxyConfig proxy;
+
+    @Data
+    public static class EngineConfig {
+        private boolean enabled;
+    }
+
+    @Data
+    public static class ProxyConfig {
+        private boolean enabled;
+        private String host;
+        private int port;
+    }
+}

src/main/java/ru/soune/nocopy/configuration/security/SecurityConfig.java

@@ -0,0 +1,40 @@
+package ru.soune.nocopy.configuration.security;
+
+import lombok.RequiredArgsConstructor;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.security.config.annotation.web.builders.HttpSecurity;
+import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
+import org.springframework.security.config.annotation.web.configurers.AbstractHttpConfigurer;
+import org.springframework.security.config.http.SessionCreationPolicy;
+import org.springframework.security.web.SecurityFilterChain;
+import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;
+import ru.soune.nocopy.util.JwtAuthFilter;
+
+@Configuration
+@EnableWebSecurity
+@RequiredArgsConstructor
+public class SecurityConfig {
+
+    private final JwtAuthFilter jwtAuthFilter;
+
+    @Bean
+    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
+        http
+                .csrf(AbstractHttpConfigurer::disable)
+                .sessionManagement(session ->
+                        session.sessionCreationPolicy(SessionCreationPolicy.STATELESS))
+                .authorizeHttpRequests(auth -> auth
+                        .requestMatchers("api/v{version}/files/public-download/**").permitAll()
+                        .requestMatchers("/api/files/public/**").permitAll()
+                        .requestMatchers("/api/auth/**").permitAll()
+                        .requestMatchers("/api/file/link/**").permitAll()
+                        .requestMatchers("/check/api/**").permitAll()
+                        .requestMatchers("/internal/**").permitAll()
+                        .anyRequest().authenticated()
+                )
+                .addFilterBefore(jwtAuthFilter, UsernamePasswordAuthenticationFilter.class);
+
+        return http.build();
+    }
+}

src/main/java/ru/soune/nocopy/controller/ApiController.java

@@ -0,0 +1,858 @@
+package ru.soune.nocopy.controller;
+
+import com.vrt.NoCopyFileService;
+import com.vrt.fileprotection.FileProtector;
+import com.vrt.fileprotection.NoCopyCheckResult;
+import com.vrt.fileprotection.audio.AudioCheckResult;
+import com.vrt.fileprotection.documents.DocumentCheckResult;
+import jakarta.servlet.http.HttpServletRequest;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.apache.commons.io.IOUtils;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.web.PageableDefault;
+import org.springframework.http.*;
+import org.springframework.validation.BindingResult;
+import org.springframework.validation.FieldError;
+import org.springframework.web.bind.annotation.*;
+import org.springframework.web.multipart.MultipartFile;
+import ru.soune.nocopy.dto.BaseRequest;
+import ru.soune.nocopy.dto.BaseResponse;
+import ru.soune.nocopy.dto.MessageCode;
+import ru.soune.nocopy.dto.docviewer.DocViewerRequest;
+import ru.soune.nocopy.dto.file.*;
+import ru.soune.nocopy.dto.register.RegAnswer;
+import ru.soune.nocopy.entity.company.Company;
+import ru.soune.nocopy.entity.file.FileEntity;
+import ru.soune.nocopy.entity.file.FileStatus;
+import ru.soune.nocopy.entity.file.UploadStatus;
+import ru.soune.nocopy.entity.file.permission.PermissionType;
+import ru.soune.nocopy.entity.user.AuthToken;
+import ru.soune.nocopy.entity.user.User;
+import ru.soune.nocopy.exception.*;
+import ru.soune.nocopy.handler.*;
+import ru.soune.nocopy.repository.AuthTokenRepository;
+import ru.soune.nocopy.repository.FileEntityRepository;
+import ru.soune.nocopy.repository.UserRepository;
+import ru.soune.nocopy.service.FileSimilarityService;
+import ru.soune.nocopy.service.dockview.DockViewService;
+import ru.soune.nocopy.service.file.*;
+import ru.soune.nocopy.service.file.CheckCounterService;
+import ru.soune.nocopy.service.file.ProtectionsLimitService;
+import ru.soune.nocopy.service.file.cloud.CloudStorageService;
+import software.amazon.awssdk.services.s3.model.NoSuchKeyException;
+
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.InputStream;
+import java.net.URLEncoder;
+import java.nio.charset.StandardCharsets;
+import java.util.*;
+import java.util.stream.Collectors;
+
+@Slf4j
+@RestController
+@RequestMapping("/api")
+@RequiredArgsConstructor
+public class ApiController {
+    private final FileUploadService fileUploadService;
+
+    private final Map<Integer, RequestHandler> handlers;
+
+    private final Map<Integer, RequestHandler> internalInfoHandler;
+
+    private final Map<Integer, RequestHandler> internalControlHandler;
+
+    private final Map<Integer, RequestHandler> authHandler;
+
+    private final FileEntityService fileEntityService;
+
+    private final FileSimilarityService fileSimilarityService;
+
+    private final FileEntityRepository fileEntityRepository;
+
+    private final NoCopyFileService noCopyFileService;
+
+    private final HttpServletRequest httpServletRequest;
+
+    private final ProtectionsLimitService protectionsLimitService;
+
+    private final AuthTokenRepository authTokenRepository;
+
+    private final UserRepository userRepository;
+
+    private final CheckCounterService checkCounterService;
+
+    private final CloudStorageService cloudStorageService;
+
+    private final ZipService zipService;
+
+    private final DockViewService dockViewService;
+
+    @PostMapping("/v{version}/data")
+    public ResponseEntity<?> handlePostRequest(@RequestBody BaseRequest request,
+                                               @PathVariable("version") int version) {
+        Integer msgId = request.getMsgId();
+        BaseResponse response;
+
+        try {
+            RequestHandler handler = handlers.get(msgId);
+
+            if (handler == null) {
+                response = new BaseResponse(msgId,
+                        MessageCode.MSG_ID_NOT_FOUND.getCode(),
+                        MessageCode.MSG_ID_NOT_FOUND.getDescription(),
+                        new HashMap<>());
+            } else {
+                response = handler.handle(request);
+            }
+
+            return ResponseEntity.ok().body(response);
+        } catch (ValidationException e) {
+            return createValidationErrorResponse(e.getBindingResult(), e.getMsgId());
+        } catch (UserNotFoundException e) {
+            return ResponseEntity.ok().body(new BaseResponse(msgId, MessageCode.USER_NOT_FOUND.getCode(),
+                    MessageCode.USER_NOT_FOUND.getDescription(), new HashMap<>()));
+        } catch (NotFoundAuthToken e) {
+            return ResponseEntity.ok().body(new BaseResponse(msgId, MessageCode.AUTH_TOKEN_NOT_FOUND.getCode(),
+                    MessageCode.AUTH_TOKEN_NOT_FOUND.getDescription(), new HashMap<>()));
+        } catch (NotValidFieldException e) {
+            throw e;
+        } catch (Exception e) {
+            log.error("Handler execution failed for msgId: {}", msgId, e);
+
+            BaseResponse errorResponse = new BaseResponse(msgId,
+                    MessageCode.INVALID_JSON_BODY.getCode(),
+                    MessageCode.INVALID_JSON_BODY.getDescription(),
+                    new HashMap<>());
+
+            return ResponseEntity.ok().body(errorResponse);
+        }
+    }
+
+    @PostMapping("/auth")
+    public ResponseEntity<?> handlePostRequest(@RequestBody BaseRequest request) {
+        Integer msgId = request.getMsgId();
+        BaseResponse response;
+
+        try {
+            RequestHandler handler = authHandler.get(msgId);
+
+            if (handler == null) {
+                response = new BaseResponse(msgId,
+                        MessageCode.MSG_ID_NOT_FOUND.getCode(),
+                        MessageCode.MSG_ID_NOT_FOUND.getDescription(),
+                        new HashMap<>());
+            } else {
+                response = handler.handle(request);
+            }
+
+            return ResponseEntity.ok().body(response);
+        } catch (ValidationException e) {
+            return createValidationErrorResponse(e.getBindingResult(), e.getMsgId());
+        } catch (UserNotFoundException e) {
+            return ResponseEntity.ok().body(new BaseResponse(msgId, MessageCode.USER_NOT_FOUND.getCode(),
+                    MessageCode.USER_NOT_FOUND.getDescription(), new HashMap<>()));
+        } catch (NotFoundAuthToken e) {
+            return ResponseEntity.ok().body(new BaseResponse(msgId, MessageCode.AUTH_TOKEN_NOT_FOUND.getCode(),
+                    MessageCode.AUTH_TOKEN_NOT_FOUND.getDescription(), new HashMap<>()));
+        } catch (NotValidFieldException e) {
+            throw e;
+        } catch (Exception e) {
+            log.error("Handler execution failed for msgId: {}", msgId, e);
+
+            BaseResponse errorResponse = new BaseResponse(msgId,
+                    MessageCode.INVALID_JSON_BODY.getCode(),
+                    MessageCode.INVALID_JSON_BODY.getDescription(),
+                    new HashMap<>());
+
+            return ResponseEntity.ok().body(errorResponse);
+        }
+    }
+
+    @PostMapping("/internal/data-info")
+    public ResponseEntity<?> handleInternalInfoPostRequest(@RequestBody BaseRequest request) {
+        Integer msgId = request.getMsgId();
+        BaseResponse response;
+        RequestHandler internalHandler = internalInfoHandler.get(msgId);
+
+        try {
+            if (internalHandler == null) {
+                response = new BaseResponse(msgId,
+                        MessageCode.MSG_ID_NOT_FOUND.getCode(),
+                        MessageCode.MSG_ID_NOT_FOUND.getDescription(),
+                        new HashMap<>());
+            } else {
+                response = internalHandler.handle(request);
+            }
+
+            return ResponseEntity.ok().body(response);
+        } catch (Exception e) {
+            log.error("Handler execution failed for msgId: {}", msgId, e);
+
+            BaseResponse errorResponse = new BaseResponse(msgId,
+                    MessageCode.INVALID_JSON_BODY.getCode(),
+                    MessageCode.INVALID_JSON_BODY.getDescription(),
+                    new HashMap<>());
+
+            return ResponseEntity.ok().body(errorResponse);
+        }
+    }
+
+    @GetMapping("/internal/data-download/{fileId}")
+    public ResponseEntity<byte[]> getPublicFile(@PathVariable String fileId) {
+        try {
+            FileEntity fileEntity = fileEntityRepository.findById(fileId)
+                    .orElseThrow(() -> new FileNotFoundException("Not found in DB: " + fileId));
+
+            MediaType mediaType = getMediaType(fileEntity);
+
+            ContentDisposition contentDisposition = ContentDisposition.inline()
+                    .filename(fileEntity.getOriginalFileName(), StandardCharsets.UTF_8)
+                    .build();
+
+            byte[] fileBytes;
+            try (InputStream inputStream = cloudStorageService.readFileFromStorage(fileEntity.getFilePath())) {
+                fileBytes = IOUtils.toByteArray(inputStream);
+            }
+
+            return ResponseEntity.ok()
+                    .contentType(mediaType)
+                    .header(HttpHeaders.CONTENT_DISPOSITION, contentDisposition.toString())
+                    .header(HttpHeaders.CACHE_CONTROL, "public, max-age=3600")
+                    .body(fileBytes);
+
+        } catch (FileNotFoundException e) {
+            return ResponseEntity.notFound().build();
+        } catch (NoSuchKeyException e) {
+            return ResponseEntity.status(HttpStatus.NOT_FOUND).build();
+        } catch (Exception e) {
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build();
+        }
+    }
+
+    @PostMapping("/internal/data-control")
+    public ResponseEntity<?> handleInternalControlPostRequest(@RequestBody BaseRequest request) {
+        Integer msgId = request.getMsgId();
+        BaseResponse response;
+        RequestHandler internalHandler = internalControlHandler.get(msgId);
+
+        try {
+            if (internalHandler == null) {
+                response = new BaseResponse(msgId,
+                        MessageCode.MSG_ID_NOT_FOUND.getCode(),
+                        MessageCode.MSG_ID_NOT_FOUND.getDescription(),
+                        new HashMap<>());
+            } else {
+                response = internalHandler.handle(request);
+            }
+
+            return ResponseEntity.ok().body(response);
+        } catch (Exception e) {
+            log.error("Handler execution failed for msgId: {}", msgId, e);
+
+            BaseResponse errorResponse = new BaseResponse(msgId,
+                    MessageCode.INVALID_JSON_BODY.getCode(),
+                    MessageCode.INVALID_JSON_BODY.getDescription(),
+                    new HashMap<>());
+
+            return ResponseEntity.ok().body(errorResponse);
+        }
+    }
+
+    @PostMapping("/v{version}/files/chunk")
+    public ResponseEntity<BaseResponse> uploadChunk(
+            @PathVariable("version") int version,
+            @RequestParam(value = "upload_id", required = false) String uploadId,
+            @RequestParam(value = "chunk_number", required = false) Integer chunkNumber,
+            @RequestParam(value = "chunk", required = false) MultipartFile chunk,
+            @RequestParam(value = "findSimilar", required = false, defaultValue = "0") Integer findSimilar) {
+        try {
+            if (chunk == null || chunk.isEmpty()) {
+                return buildErrorResponse(uploadId, chunkNumber, "Chunk file null or empty");
+            }
+            if (uploadId == null || uploadId.isBlank()) {
+                return buildErrorResponse(uploadId, chunkNumber, "Upload ID is required");
+            }
+            if (chunkNumber == null || chunkNumber < 0) {
+                return buildErrorResponse(uploadId, chunkNumber, "Valid chunk number is required");
+            }
+
+            UploadProgressResponse uploadProgressResponse = fileUploadService.uploadChunk(uploadId, chunkNumber,
+                    chunk, findSimilar);
+
+            return buildSuccessResponse(uploadId, chunkNumber, chunk,
+                    fileEntityService.findFileIdByPath(uploadProgressResponse.getFilePath()));
+        } catch (DuplicateImageException e) {
+            Map<String, Object> duplicateData = new HashMap<>();
+            duplicateData.put("duplicateFileId", e.duplicateFileId());
+            duplicateData.put("userId", e.userId());
+            duplicateData.put("message", e.getMessage());
+
+            if (uploadId != null) {
+                duplicateData.put("uploadId", uploadId);
+            }
+
+            return ResponseEntity.ok().body(new BaseResponse(
+                    20004,
+                    MessageCode.DUPLICATE_FILE_UPLOAD.getCode(),
+                    MessageCode.DUPLICATE_FILE_UPLOAD.getDescription(),
+                    duplicateData
+            ));
+        } catch (FileFormatException e){
+            return buildErrorResponse(uploadId, chunkNumber, e.getMessage());
+        } catch (Exception e) {
+            log.error("Error uploading chunk", e);
+            return buildErrorResponse(uploadId, chunkNumber, "Failed to upload chunk: " + e.getMessage());
+        }
+    }
+
+    @PostMapping("/v{version}/private/files/chunk")
+    public ResponseEntity<BaseResponse> uploadChunk(
+            @RequestParam(value = "upload_id", required = false) String uploadId,
+            @RequestParam(value = "chunk_number", required = false) Integer chunkNumber,
+            @RequestParam(value = "chunk", required = false) MultipartFile chunk,
+            @RequestParam(value = "last_file", required = false) Boolean last_file) {
+        try {
+            if (chunk == null || chunk.isEmpty()) {
+                return buildErrorResponse(uploadId, chunkNumber, "Chunk file null or empty");
+            }
+            if (uploadId == null || uploadId.isBlank()) {
+                return buildErrorResponse(uploadId, chunkNumber, "Upload Id is required");
+            }
+            if (chunkNumber == null || chunkNumber < 0) {
+                return buildErrorResponse(uploadId, chunkNumber, "Valid chunk number is required");
+            }
+
+            Long userId = (Long) httpServletRequest.getAttribute("userId");
+
+            UploadProgressResponse uploadProgressResponse = fileUploadService.uploadPassportChunk(uploadId, chunkNumber,
+                    chunk, userId);
+
+            if (last_file) {
+                zipService.createAndSplitZip(userId,
+                        fileEntityService.getAllUserFiles(userId, List.of(FileStatus.PRIVATE)));
+            }
+
+            return buildSuccessResponse(uploadId, chunkNumber, chunk,
+                    fileEntityService.findFileIdByPath(uploadProgressResponse.getFilePath()));
+        }catch (FileFormatException e){
+            return buildErrorResponse(uploadId, chunkNumber, e.getMessage());
+        } catch (Exception e) {
+            log.error("Error uploading chunk", e);
+            return buildErrorResponse(uploadId, chunkNumber, "Failed to upload chunk: " + e.getMessage());
+        }
+    }
+
+    @GetMapping("/check/{fileId}")
+    public ResponseEntity<BaseResponse> check(@PathVariable String fileId) {
+        FileEntity fileEntity = fileEntityRepository.findByFileId(fileId);
+
+        File file = new File(fileEntity.getFilePath());
+        NoCopyCheckResult checkResult = noCopyFileService.checkFile(file,  FileProtector.Type.IMAGE);
+        log.info("checkResult: {}", checkResult);
+
+
+        return ResponseEntity.ok(new BaseResponse(1, 1, "1", checkResult));
+    }
+
+    @GetMapping("/v{version}/files/{fileId}/similar")
+    public ResponseEntity<BaseResponse> findSimilarFiles(
+            @PathVariable("version") int version,
+            @PathVariable String fileId,
+            @RequestParam(required = false) List<String> similarityLevels,
+            @PageableDefault(size = 20, sort = "hammingDistance") Pageable pageable) {
+
+        try {
+            FileEntity fileEntity = fileEntityRepository.findByFileId(fileId);
+
+            if (fileEntity == null) {
+                return ResponseEntity.ok().body(new BaseResponse(0, MessageCode.INVALID_FIELD.getCode(),
+                        MessageCode.INVALID_FIELD.getDescription(), null));
+            }
+
+            Long userId = (Long) httpServletRequest.getAttribute("userId");
+
+            BaseResponse response;
+            if ("image".equals(fileEntity.getMimeType())) {
+                Page<SimilarFileDTO> similarFilesPage = fileSimilarityService.findSimilarFiles(
+                        fileId, similarityLevels, pageable, userId);
+                response = buildSuccessResponse(similarFilesPage, MessageCode.SIMILAR_FILES_FOUND);
+            } else {
+                List<SimilarFileDTO> results = processNonImageFile(fileEntity, true);
+                log.info("results: {}", results);
+                response = buildSuccessResponse(results, MessageCode.SIMILAR_FILES_FOUND);
+                checkCounterService.incrementCheckCount(fileEntity.getUserId(), fileEntity.getMimeType());
+            }
+
+            return ResponseEntity.ok(response);
+        } catch(IllegalArgumentException e) {
+            log.error("Error with file extensions : {}", e.getMessage(), e);
+            return ResponseEntity.ok().body(new BaseResponse(MessageCode.FILE_FOR_SEARCH_NOT_VALID.getCode(),
+                    MessageCode.FILE_FOR_SEARCH_NOT_VALID.getCode(),
+                    MessageCode.FILE_FOR_SEARCH_NOT_VALID.getDescription(), null));
+        } catch (Exception e) {
+            log.error("Error finding similar files: {}", e.getMessage(), e);
+            return ResponseEntity.ok().body(new BaseResponse(MessageCode.INVALID_FIELD.getCode(),
+                    MessageCode.INVALID_FIELD.getCode(),
+                    MessageCode.INVALID_FIELD.getDescription(), null));
+        }
+    }
+
+    private List<SimilarFileDTO> processNonImageFile(FileEntity fileEntity, boolean cloud) throws Exception {
+        List<SimilarFileDTO> results = new ArrayList<>();
+        File file = null;
+        FileEntity duplicateByHash = fileSimilarityService.findDuplicateByHash(fileEntity.getFilePath(),
+                fileEntity.getMimeType(), fileEntity.getUserId(), cloud);
+
+        log.info("duplicateByHash: {}", duplicateByHash);
+
+        if (duplicateByHash != null) {
+            results.add(fileSimilarityService.buildDTO(duplicateByHash));
+
+            return results;
+        }
+
+        try {
+            file = cloudStorageService.readFileFromStorageByPath(fileEntity.getFilePath());
+            FileProtector.Type type = "document".equals(fileEntity.getMimeType()) ?
+                    FileProtector.Type.DOC : FileProtector.Type.AUDIO;
+
+            NoCopyCheckResult checkResult = noCopyFileService.checkFile(file, type);
+            log.info("checkResult: {}", checkResult);
+
+            switch (checkResult) {
+                case DocumentCheckResult.Success success -> {
+                    FileProtector.FileInfo info = success.getInfo();
+                    FileEntity entity = fileEntityRepository.findByFileId(info.getId());
+                    if (entity != null) {
+                        results.add(fileSimilarityService.buildDTO(entity));
+                    }
+                }
+                case AudioCheckResult.Success success -> {
+                    FileProtector.FileInfo info = success.getInfo();
+                    FileEntity entity = fileEntityRepository.findByFileId(info.getId());
+                    if (entity != null) {
+                        results.add(fileSimilarityService.buildDTO(entity));
+                    }
+                }
+                case DocumentCheckResult.Failed failed ->
+                        log.warn("Document check failed: {}", failed.getMessage());
+                case AudioCheckResult.Failed failed ->
+                        log.warn("Audio check failed: {}", failed.getMessage());
+                default -> log.warn("Unexpected result type: {}", checkResult.getClass().getSimpleName());
+            }
+        } catch (Exception e) {
+            throw new Exception("Files for search not valid");
+        } finally {
+            if (file != null && file.exists()) {
+                file.delete();
+            }
+        }
+
+        return results;
+    }
+
+    private BaseResponse buildSuccessResponse(Page<SimilarFileDTO> page, MessageCode messageCode) {
+        Map<String, Object> responseData = new HashMap<>();
+        responseData.put("content", page.getContent());
+        responseData.put("page", page.getNumber());
+        responseData.put("size", page.getSize());
+        responseData.put("totalElements", page.getTotalElements());
+        responseData.put("totalPages", page.getTotalPages());
+        responseData.put("hasNext", page.hasNext());
+        responseData.put("hasPrevious", page.hasPrevious());
+
+        return new BaseResponse(20004, messageCode.getCode(),
+                messageCode.getDescription(), responseData);
+    }
+
+    private BaseResponse buildSuccessResponse(List<SimilarFileDTO> list, MessageCode messageCode) {
+        Map<String, Object> responseData = new HashMap<>();
+        responseData.put("content", list);
+        responseData.put("totalElements", list.size());
+
+        return new BaseResponse(20004, messageCode.getCode(),
+                messageCode.getDescription(), responseData);
+    }
+
+    @GetMapping("/v{version}/files/progress/{uploadId}")
+    public ResponseEntity<BaseResponse> getUploadProgress(
+            @PathVariable("version") int version,
+            @PathVariable String uploadId) {
+
+        log.info("Getting progress for upload session: {}, version: {}", uploadId, version);
+
+        try {
+            var progress = fileUploadService.getUploadProgress(uploadId);
+
+            UploadProgress responseBody = UploadProgress.builder()
+                    .uploadId(progress.getUploadId())
+                    .fileName(progress.getFileName())
+                    .totalChunks(progress.getTotalChunks())
+                    .uploadedChunks(progress.getUploadedChunks())
+                    .status(progress.getStatus().toString())
+                    .progressPercentage(progress.getProgressPercentage())
+                    .filePath(progress.getFilePath())
+                    .remainingChunks(progress.getTotalChunks() - progress.getUploadedChunks())
+                    .build();
+
+            return ResponseEntity.ok().body(new BaseResponse(
+                    20004, MessageCode.SUCCESS.getCode(), MessageCode.SUCCESS.getDescription(), responseBody));
+        } catch (Exception e) {
+            log.error("Error getting progress for upload: {}", uploadId, e);
+
+            UploadProgress responseBody = UploadProgress.builder()
+                    .uploadId(uploadId)
+                    .build();
+
+            return ResponseEntity.ok().body(new BaseResponse(
+                    20004, MessageCode.FILE_UPLOAD_ERROR.getCode(),
+                    "Failed to get upload progress: " + e.getMessage(), responseBody));
+        }
+    }
+
+    @PostMapping("/v{version}/files/{uploadId}/complete")
+    public ResponseEntity<BaseResponse> completeUpload(
+            @PathVariable("version") int version,
+            @PathVariable String uploadId) {
+
+        log.info("Completing upload session: {}, version: {}", uploadId, version);
+
+        try {
+            var progress = fileUploadService.getUploadProgress(uploadId);
+
+            if (progress.getStatus() == UploadStatus.COMPLETED) {
+                CompleteUploadResponse responseBody = CompleteUploadResponse.builder()
+                        .uploadId(progress.getUploadId())
+                        .status(progress.getStatus().toString())
+                        .uploadedChunks(progress.getUploadedChunks())
+                        .totalChunks(progress.getTotalChunks())
+                        .message("Upload already completed")
+                        .filePath(progress.getFilePath())
+                        .build();
+
+                return ResponseEntity.ok().body(new BaseResponse(20004, MessageCode.SUCCESS.getCode(),
+                        "Upload already completed", responseBody));
+            }
+
+            if (progress.getUploadedChunks() < progress.getTotalChunks()) {
+                CompleteUploadResponse responseBody = CompleteUploadResponse.builder()
+                        .uploadId(progress.getUploadId())
+                        .status(progress.getStatus().toString())
+                        .uploadedChunks(progress.getUploadedChunks())
+                        .totalChunks(progress.getTotalChunks())
+                        .message("Not all chunks uploaded")
+                        .build();
+
+                return ResponseEntity.ok().body(new BaseResponse(20004, MessageCode.INCOMPLETE_UPLOAD.getCode(),
+                        "Not all chunks uploaded", responseBody));
+            }
+
+            CompleteUploadResponse responseBody = CompleteUploadResponse.builder()
+                    .uploadId(progress.getUploadId())
+                    .status(progress.getStatus().toString())
+                    .uploadedChunks(progress.getUploadedChunks())
+                    .totalChunks(progress.getTotalChunks())
+                    .message("File assembly in progress")
+                    .build();
+
+            return ResponseEntity.ok().body(new BaseResponse(20004, MessageCode.SUCCESS.getCode(),
+                    "File assembly in progress", responseBody));
+
+        } catch (Exception e) {
+            log.error("Error completing upload: {}", uploadId, e);
+
+            CompleteUploadResponse responseBody = CompleteUploadResponse.builder()
+                    .uploadId(uploadId)
+                    .build();
+
+            return ResponseEntity.ok().body(new BaseResponse(20004, MessageCode.FILE_UPLOAD_ERROR.getCode(),
+                    "Failed to complete upload: " + e.getMessage(), responseBody));
+        }
+    }
+
+    @GetMapping("/v{version}/files/public-download/{fileId}")
+    public ResponseEntity<?> downloadFile(
+            @PathVariable(required = false) String fileId, @PathVariable(required = false) Integer version) {
+        FileEntityResponse entityResponse = fileEntityService.getById(fileId, version);
+        FileStatus status = entityResponse.getStatus();
+
+        if (status.equals(FileStatus.BLOCKED) || status.equals(FileStatus.DELETED) ||
+                status.equals(FileStatus.REMOVED)) {
+            Map<String, Object> errorData = new HashMap<>();
+            errorData.put("fileId", entityResponse.getId());
+
+            return ResponseEntity.ok().body(new BaseResponse(20004,
+                    MessageCode.FILE_IS_BLOCKED.getCode(),
+                    MessageCode.FILE_IS_BLOCKED.getDescription(),
+                    errorData));
+        }
+
+        if (!entityResponse.getPermissions().get(PermissionType.DOWNLOAD)) {
+            Map<String, Object> errorData = new HashMap<>();
+            errorData.put("fileId", entityResponse.getId());
+
+            return ResponseEntity.ok().body(new BaseResponse(20004,
+                    MessageCode.NOT_HAVE_DOWNLOAD_PERMISSION.getCode(),
+                    MessageCode.NOT_HAVE_DOWNLOAD_PERMISSION.getDescription(),
+                    errorData));
+        }
+
+        byte[] bytes = cloudStorageService.readFileFromStorageBytes(entityResponse.getProtectedFilePath());
+
+        return ResponseEntity.ok()
+                .contentType(MediaType.APPLICATION_OCTET_STREAM)
+                .header(HttpHeaders.CONTENT_DISPOSITION,
+                        "attachment; filename=\"" + entityResponse.getFileName() + "\"")
+                .body(bytes);
+    }
+
+    @GetMapping("/v{version}/files/download/{fileId}")
+    public ResponseEntity<?> downloadFile(
+            @PathVariable(required = false) String fileId,
+            @PathVariable(required = false) Integer version,
+            @RequestHeader(value = "Authorization", required = false) String tokenHeader) {
+        try {
+            if (tokenHeader == null || tokenHeader.isBlank()) {
+                Map<String, Object> errorData = new HashMap<>();
+                errorData.put("token", tokenHeader);
+
+                return ResponseEntity.ok().body(new BaseResponse(20004,
+                        MessageCode.TOKEN_IS_NULL.getCode(),
+                        MessageCode.TOKEN_IS_NULL.getDescription(),
+                        errorData));
+            }
+
+            Long userId = (Long) httpServletRequest.getAttribute("userId");
+            FileEntityResponse entityResponse = fileEntityService.getById(fileId, version);
+            FileStatus status = entityResponse.getStatus();
+
+            if (status.equals(FileStatus.BLOCKED) || status.equals(FileStatus.DELETED) ||
+                    status.equals(FileStatus.REMOVED)) {
+                Map<String, Object> errorData = new HashMap<>();
+                errorData.put("fileId", entityResponse.getId());
+
+                return ResponseEntity.ok().body(new BaseResponse(20004,
+                        MessageCode.FILE_IS_BLOCKED.getCode(),
+                        MessageCode.FILE_IS_BLOCKED.getDescription(),
+                        errorData));
+            }
+
+            if (!entityResponse.getPermissions().get(PermissionType.DOWNLOAD)) {
+                Map<String, Object> errorData = new HashMap<>();
+                errorData.put("fileId", entityResponse.getId());
+
+                return ResponseEntity.ok().body(new BaseResponse(20004,
+                        MessageCode.NOT_HAVE_DOWNLOAD_PERMISSION.getCode(),
+                        MessageCode.NOT_HAVE_DOWNLOAD_PERMISSION.getDescription(),
+                        errorData));
+            }
+
+            User fileUser = userRepository.findById(entityResponse.getUserId()).orElseThrow();
+            User user = userRepository.findById(userId).orElseThrow();
+            Company companyUser = user.getCompany();
+
+            if (companyUser != null && !fileUser.getCompany().getId().equals(companyUser.getId())) {
+                Map<String, Object> errorData = new HashMap<>();
+                errorData.put("token", tokenHeader);
+
+                return ResponseEntity.ok().body(new BaseResponse(20004,
+                        MessageCode.USER_NOT_HAD_PERMISSION.getCode(),
+                        MessageCode.USER_NOT_HAD_PERMISSION.getDescription(),
+                        errorData));
+            }
+
+            if (companyUser == null && !entityResponse.getUserId().equals(userId)) {
+                Map<String, Object> errorData = new HashMap<>();
+                errorData.put("token", tokenHeader);
+
+                return ResponseEntity.ok().body(new BaseResponse(20004,
+                        MessageCode.USER_NOT_HAD_PERMISSION.getCode(),
+                        MessageCode.USER_NOT_HAD_PERMISSION.getDescription(),
+                        errorData));
+            }
+
+            if (entityResponse.getStatus().equals(FileStatus.DELETED)) {
+                Map<String, Object> errorData = new HashMap<>();
+                errorData.put("file_status", entityResponse.getStatus());
+
+                return ResponseEntity.ok().body(new BaseResponse(20004,
+                        MessageCode.FILE_DELETE.getCode(),
+                        MessageCode.FILE_DELETE.getDescription(),
+                        errorData));
+            }
+
+            byte[] bytes = cloudStorageService.readFileFromStorageBytes(entityResponse.getProtectedFilePath());
+
+            return ResponseEntity.ok()
+                    .contentType(MediaType.APPLICATION_OCTET_STREAM)
+                    .header(HttpHeaders.CONTENT_DISPOSITION,
+                            "attachment; filename=\"" + entityResponse.getFileName() + "\"")
+                    .body(bytes);
+        } catch (FileEntityNotFoundException e) {
+            Map<String, Object> errorData = new HashMap<>();
+            errorData.put("fileId", fileId);
+
+            return ResponseEntity.ok().body(new BaseResponse(20004,
+                    MessageCode.FILE_NOT_FOUND.getCode(),
+                    MessageCode.FILE_NOT_FOUND.getDescription(),
+                    errorData));
+        } catch (NotFoundAuthToken e) {
+            Map<String, Object> errorData = new HashMap<>();
+            errorData.put("token", tokenHeader);
+
+            return ResponseEntity.ok().body(new BaseResponse(20004,
+                    MessageCode.AUTH_TOKEN_NOT_FOUND.getCode(),
+                    MessageCode.AUTH_TOKEN_NOT_FOUND.getDescription(),
+                    errorData));
+        }
+    }
+
+    @PostMapping("/file/link")
+    public ResponseEntity<?> downloadFile(@RequestBody DocViewerRequest viewerRequest) {
+        try {
+            Long userId = httpServletRequest.getAttribute("userId") == null ? 0L:
+                    (Long) httpServletRequest.getAttribute("userId");
+
+            if (viewerRequest.getFileId() == null) {
+                return ResponseEntity.ok().body(new BaseResponse(0,
+                        MessageCode.NOT_VALID_FIELD.getCode(),
+                        MessageCode.NOT_VALID_FIELD.getDescription(),
+                        "file_id is required"));
+            }
+
+            FileEntityResponse entityResponse = fileEntityService.getById(viewerRequest.getFileId(), 0);
+            FileStatus status = entityResponse.getStatus();
+
+            if (status.equals(FileStatus.BLOCKED) || status.equals(FileStatus.DELETED) ||
+                    status.equals(FileStatus.REMOVED)) {
+                Map<String, Object> errorData = new HashMap<>();
+                errorData.put("fileId", entityResponse.getId());
+
+                return ResponseEntity.ok().body(new BaseResponse(0,
+                        MessageCode.FILE_IS_BLOCKED.getCode(),
+                        MessageCode.FILE_IS_BLOCKED.getDescription(),
+                        errorData));
+            }
+
+            byte[] bytes = cloudStorageService.readFileFromStorageBytes(entityResponse.getProtectedFilePath());
+
+            dockViewService.createDockView(viewerRequest, userId);
+
+            String filename = entityResponse.getFileName();
+            String encodedFilename = URLEncoder.encode(filename, StandardCharsets.UTF_8)
+                    .replace("+", "%20");
+
+            String safeFilename = filename.replaceAll("[^\\x00-\\x7F]", "_");
+
+            return ResponseEntity.ok()
+                    .contentType(MediaType.APPLICATION_OCTET_STREAM)
+                    .header(HttpHeaders.CONTENT_DISPOSITION,
+                            "attachment; filename=\"" + safeFilename + "\"; filename*=UTF-8''" + encodedFilename)
+                    .body(bytes);
+        } catch (FileEntityNotFoundException e) {
+            Map<String, Object> errorData = new HashMap<>();
+            errorData.put("fileId", viewerRequest.getFileId());
+
+            return ResponseEntity.ok().body(new BaseResponse(0,
+                    MessageCode.FILE_NOT_FOUND.getCode(),
+                    MessageCode.FILE_NOT_FOUND.getDescription(),
+                    errorData));
+        } catch (NotFoundAuthToken e) {
+            Map<String, Object> errorData = new HashMap<>();
+            errorData.put("token", viewerRequest.getFileId());
+
+            return ResponseEntity.ok().body(new BaseResponse(0,
+                    MessageCode.AUTH_TOKEN_NOT_FOUND.getCode(),
+                    MessageCode.AUTH_TOKEN_NOT_FOUND.getDescription(),
+                    errorData));
+        }
+    }
+
+    @GetMapping("/check/file_stats")
+    public ResponseEntity<?> checkFileProtectStats() {
+        Long userId = (Long) httpServletRequest.getAttribute("userId");
+
+        Map<String, Object> fileTypeStats = protectionsLimitService.getFileTypeStats(userId);
+
+        return ResponseEntity.ok().body(fileTypeStats);
+    }
+
+    private ResponseEntity<BaseResponse> buildSuccessResponse(String uploadId, Integer chunkNumber, MultipartFile chunk,
+                                                              String fileId) {
+        ChunkUploadResponse responseBody = ChunkUploadResponse.builder()
+                .uploadId(uploadId)
+                .chunkNumber(chunkNumber)
+                .chunkSize(chunk.getSize())
+                .fileId(fileId)
+                .message("Chunk uploaded successfully")
+                .build();
+
+        return ResponseEntity.ok().body(new BaseResponse(
+                20000,
+                MessageCode.SUCCESS.getCode(),
+                "Chunk uploaded successfully",
+                responseBody));
+    }
+
+    private ResponseEntity<BaseResponse> buildErrorResponse(String uploadId, Integer chunkNumber, String errorMessage) {
+        ChunkUploadResponse responseBody = ChunkUploadResponse.builder()
+                .uploadId(uploadId)
+                .chunkNumber(chunkNumber)
+                .build();
+
+        return ResponseEntity.ok().body(new BaseResponse(
+                20004,
+                MessageCode.FILE_UPLOAD_ERROR.getCode(),
+                errorMessage,
+                responseBody));
+    }
+
+    private ResponseEntity<BaseResponse> createValidationErrorResponse(BindingResult bindingResult, Integer msgId) {
+        List<Map<String, String>> fieldErrors = bindingResult.getFieldErrors()
+                .stream()
+                .map(this::createErrorDetail)
+                .collect(Collectors.toList());
+
+        RegAnswer regAnswer = new RegAnswer();
+        regAnswer.setFieldErrors(fieldErrors);
+
+        return ResponseEntity.ok().body(new BaseResponse(msgId, MessageCode.INVALID_FIELD.getCode(),
+                MessageCode.INVALID_FIELD.getDescription(), regAnswer));
+    }
+
+    private Map<String, String> createErrorDetail(FieldError fieldError) {
+        Map<String, String> errorDetail = new HashMap<>();
+        errorDetail.put("field", fieldError.getField());
+        errorDetail.put("code", fieldError.getCode() != null ? fieldError.getCode() : "VALIDATION_ERROR");
+        errorDetail.put("message", fieldError.getDefaultMessage());
+
+        if (fieldError.getRejectedValue() != null &&
+                !fieldError.getField().toLowerCase().contains("password")) {
+            errorDetail.put("rejected_value", fieldError.getRejectedValue().toString());
+        }
+
+        return errorDetail;
+    }
+
+    private MediaType getMediaType(FileEntity fileEntity) {
+        try {
+            return MediaType.parseMediaType(fileEntity.getMimeType());
+        } catch (InvalidMediaTypeException e) {
+            String extension = fileEntity.getFileExtension().toLowerCase();
+            switch (extension) {
+                case "jpg":
+                case "jpeg":
+                    return MediaType.IMAGE_JPEG;
+                case "png":
+                    return MediaType.IMAGE_PNG;
+                case "pdf":
+                    return MediaType.APPLICATION_PDF;
+                default:
+                    return MediaType.APPLICATION_OCTET_STREAM;
+            }
+        }
+    }
+}

src/main/java/ru/soune/nocopy/controller/FileController.java

@@ -0,0 +1,188 @@
+package ru.soune.nocopy.controller;
+
+import com.google.common.io.ByteStreams;
+import com.vrt.NoCopyFileService;
+import com.vrt.fileprotection.FileProtector;
+import lombok.AllArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.core.io.InputStreamResource;
+import org.springframework.core.io.Resource;
+import org.springframework.http.*;
+import org.springframework.web.bind.annotation.*;
+import org.springframework.web.servlet.mvc.method.annotation.StreamingResponseBody;
+import ru.soune.nocopy.dto.file.CheckStatus;
+import ru.soune.nocopy.entity.file.FileEntity;
+import ru.soune.nocopy.entity.file.ProtectionStatus;
+import ru.soune.nocopy.entity.user.ProtectedFileCheck;
+import ru.soune.nocopy.entity.user.User;
+import ru.soune.nocopy.repository.FileEntityRepository;
+import ru.soune.nocopy.repository.UserRepository;
+import ru.soune.nocopy.service.file.CheckCounterService;
+import ru.soune.nocopy.service.file.ZipService;
+import ru.soune.nocopy.service.file.cloud.CloudStorageService;
+import ru.soune.nocopy.util.FileUtil;
+import software.amazon.awssdk.services.s3.model.NoSuchKeyException;
+
+import java.io.*;
+import java.net.URLEncoder;
+import java.nio.charset.StandardCharsets;
+
+@RestController
+@RequestMapping("/api/files")
+@Slf4j
+@AllArgsConstructor
+public class FileController {
+
+    private FileEntityRepository fileRepository;
+
+    private CheckCounterService checkCounterService;
+
+    private UserRepository userRepository;
+
+    private NoCopyFileService noCopyFileService;
+
+    private FileUtil fileUtil;
+
+    private ZipService zipService;
+
+    private CloudStorageService cloudStorageService;
+
+    @GetMapping("/public/{fileId}")
+    public ResponseEntity<StreamingResponseBody> getPublicFile(@PathVariable String fileId) {
+        try {
+            FileEntity fileEntity = fileRepository.findById(fileId)
+                    .orElseThrow(() -> new FileNotFoundException("Not found in DB: " + fileId));
+
+            MediaType mediaType = getMediaType(fileEntity);
+
+            ContentDisposition contentDisposition = ContentDisposition.inline()
+                    .filename(fileEntity.getOriginalFileName(), StandardCharsets.UTF_8)
+                    .build();
+
+            StreamingResponseBody responseBody = outputStream -> {
+                try (InputStream inputStream = cloudStorageService.readFileFromStorage(fileEntity.getFilePath())) {
+                    ByteStreams.copy(inputStream, outputStream);
+                } catch (NoSuchKeyException e) {
+                    log.error("File disappeared from S3 during streaming: {}", fileId, e);
+                    throw new IOException("File not found in storage", e);
+                }
+            };
+
+            return ResponseEntity.ok()
+                    .contentType(mediaType)
+                    .header(HttpHeaders.CONTENT_DISPOSITION, contentDisposition.toString())
+                    .header(HttpHeaders.CACHE_CONTROL, "public, max-age=3600")
+                    .body(responseBody);
+        } catch (FileNotFoundException e) {
+            log.warn("File not found in DB: {}", fileId);
+            return ResponseEntity.notFound().build();
+        } catch (NoSuchKeyException e) {
+            log.warn("File not found in S3: {}", fileId);
+            return ResponseEntity.status(HttpStatus.NOT_FOUND).build();
+        } catch (Exception e) {
+            log.error("Error reading file: {}", fileId, e);
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build();
+        }
+    }
+
+    private MediaType getMediaType(FileEntity fileEntity) {
+        try {
+            return MediaType.parseMediaType(fileEntity.getMimeType());
+        } catch (InvalidMediaTypeException e) {
+            String extension = fileEntity.getFileExtension().toLowerCase();
+            switch (extension) {
+                case "jpg":
+                case "jpeg":
+                    return MediaType.IMAGE_JPEG;
+                case "png":
+                    return MediaType.IMAGE_PNG;
+                case "pdf":
+                    return MediaType.APPLICATION_PDF;
+                default:
+                    return MediaType.APPLICATION_OCTET_STREAM;
+            }
+        }
+    }
+
+    @GetMapping("/protected/{fileId}/{type}")
+    public ResponseEntity<Resource> getProtectedFile(
+            @PathVariable String fileId, @PathVariable String type) throws IOException {
+
+        FileEntity fileEntity = fileRepository.findById(fileId)
+                .orElseThrow(() -> new RuntimeException("File not found"));
+
+        String filePath = type.equals("thumbnail") ? fileEntity.getThumbnailPath(): fileEntity.getFilePath();
+
+//        InputStream file = cloudStorageService.readFileFromStorage(filePath);
+
+//        if (file == null || !file.exists()) {
+//            log.error("File not found in storage: {}", fileEntity.getFilePath());
+//            return ResponseEntity.notFound().build();
+//        }
+
+        if (fileEntity.getProtectionStatus() == ProtectionStatus.NOT_PROTECTED ||
+                fileEntity.getProtectionStatus() == ProtectionStatus.PROCESSING) {
+            throw new RuntimeException("File is not protected");
+        }
+
+        String fileName = fileEntity.getOriginalFileName().replace("." +
+                fileEntity.getFileExtension(), "") + "_nocopy_protected" +
+                "." + fileEntity.getFileExtension();
+        String encodedFileName = URLEncoder.encode(fileName, StandardCharsets.UTF_8)
+                .replace("+", "%20");
+
+        InputStreamResource resource = new InputStreamResource(cloudStorageService.readFileFromStorage(filePath));
+
+        return ResponseEntity.ok()
+                .contentType(new MediaType(fileEntity.getMimeType(), fileEntity.getFileExtension()))
+                .header(HttpHeaders.CONTENT_DISPOSITION,
+                        "inline; filename*=UTF-8''" + encodedFileName)
+                .body(resource);
+    }
+
+    @GetMapping("check-file/status/{userId}")
+    public ResponseEntity<CheckStatus> getStatus(@PathVariable Long userId) {
+        CheckStatus status = checkCounterService.getCurrentStatus(userId);
+
+        return ResponseEntity.ok(status);
+    }
+
+    @PostMapping("check-file/update-limit/{userId}/{limit}")
+    public ResponseEntity<ProtectedFileCheck> getStatus(@PathVariable Long userId, @PathVariable Integer limit) {
+        User user = userRepository.findById(userId).orElseThrow();
+        ProtectedFileCheck protectedFileCheck = checkCounterService.updateLimit(user, limit);
+
+        return ResponseEntity
+                .ok()
+                .body(protectedFileCheck);
+    }
+
+    @PostMapping("protect/{fileId}/{convertTo}")
+    public ResponseEntity<FileProtector.FileInfo> convert(@PathVariable String fileId, @PathVariable String convertTo) {
+        FileEntity file = fileRepository.findByFileId(fileId);
+        FileProtector.FileInfo fileInfo = fileUtil.createFileInfo(file, convertTo);
+
+        noCopyFileService.addFile(fileInfo);
+
+        return ResponseEntity
+                .ok()
+                .body(fileInfo);
+    }
+
+    @GetMapping("/download/user-passport/archive/{userId}")
+    public ResponseEntity<byte[]> downloadPassportZip(@PathVariable Long userId) {
+        try {
+            byte[] zipBytes = zipService.assembleZipFromSplitFiles(userId);
+
+            return ResponseEntity.ok()
+                    .header(HttpHeaders.CONTENT_DISPOSITION,
+                            "attachment; filename=passport_" + userId + ".zip")
+                    .contentType(MediaType.APPLICATION_OCTET_STREAM)
+                    .contentLength(zipBytes.length)
+                    .body(zipBytes);
+        } catch (IOException e) {
+            log.error("Failed to assemble passport for user {}", userId, e);
+            return ResponseEntity.internalServerError().build();
+        }
+    }
+}

src/main/java/ru/soune/nocopy/controller/GlobalSearchController.java

@@ -0,0 +1,116 @@
+package ru.soune.nocopy.controller;
+
+import jakarta.servlet.http.HttpServletRequest;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.data.domain.Page;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+import ru.soune.nocopy.dto.search.GlobalSearchStartRequest;
+import ru.soune.nocopy.dto.search.GlobalSearchStartResponse;
+import ru.soune.nocopy.dto.search.GlobalSearchStatusResponse;
+import ru.soune.nocopy.dto.violation.FileViolationSummaryDTO;
+import ru.soune.nocopy.dto.violation.ViolationRequest;
+import ru.soune.nocopy.entity.file.FileEntity;
+import ru.soune.nocopy.entity.search.GlobalSearchTask;
+import ru.soune.nocopy.entity.search.SearchStatus;
+import ru.soune.nocopy.repository.GlobalSearchTaskRepository;
+import ru.soune.nocopy.service.search.GlobalSearchService;
+import ru.soune.nocopy.service.violation.ViolationService;
+
+import java.util.*;
+
+@Slf4j
+@RestController
+@RequestMapping("/api/v1/global-search")
+@RequiredArgsConstructor
+public class GlobalSearchController {
+
+    private final GlobalSearchService globalSearchService;
+
+    private final GlobalSearchTaskRepository searchTaskRepository;
+
+    private final ViolationService violationService;
+
+    private final HttpServletRequest httpServletRequest;
+
+    @PostMapping("/start")
+    public ResponseEntity<?> startSearch(
+            @RequestBody GlobalSearchStartRequest request) {
+        GlobalSearchStartResponse response = new GlobalSearchStartResponse();
+
+        Long userId = (Long) httpServletRequest.getAttribute("userId");
+
+        List<FileEntity> filesToProcess = globalSearchService.getFilesToProcess(request, userId);
+
+        if (filesToProcess.isEmpty()) return ResponseEntity.ok().body("Files for search not found");
+
+        String taskId = globalSearchService.startSearch(request, userId, filesToProcess);
+
+        response.setTaskId(taskId);
+        response.setStatus(SearchStatus.ACCEPTED.name());
+        response.setTotalFiles(filesToProcess.size());
+
+        return ResponseEntity.ok(response);
+    }
+
+    @GetMapping("/actual-task")
+    public ResponseEntity<?> getStatus() {
+        Optional<GlobalSearchTask> taskOptional;
+
+        Long userId = (Long) httpServletRequest.getAttribute("userId");
+
+        taskOptional = searchTaskRepository.findByUserIdAndStatus(userId,
+                "PROCESSING");
+
+        if (taskOptional.isEmpty()) return ResponseEntity.ok().body("Task not found");
+
+        return ResponseEntity.ok(taskOptional.get());
+    }
+
+    @GetMapping("/violation-summary")
+    public ResponseEntity<?> getSummary() {
+        List<FileViolationSummaryDTO> fileViolationsSummary;
+
+        Long userId = (Long) httpServletRequest.getAttribute("userId");
+
+        fileViolationsSummary = violationService.getFileViolationsSummary(userId);
+
+        if (fileViolationsSummary.isEmpty()) return ResponseEntity.ok().body("Violations summary not found");
+
+        return ResponseEntity.ok(fileViolationsSummary);
+    }
+
+
+    @PostMapping("/violation-summary-with-files")
+    public ResponseEntity<?> getViolations(@RequestBody ViolationRequest request) {
+        Long userId = (Long) httpServletRequest.getAttribute("userId");
+        Page<FileViolationSummaryDTO> result = violationService.getFileViolationsSummary(
+                userId, request.getFileName(), request.getSortDirection(),
+                request.getPage(), request.getSize(), request.getStartDate(), request.getEndDate());
+
+        return ResponseEntity.ok(result);
+    }
+
+    @GetMapping("/status/{taskId}")
+    public ResponseEntity<?> getStatus(@PathVariable String taskId) {
+        GlobalSearchStatusResponse response;
+        Long userId = (Long) httpServletRequest.getAttribute("userId");
+
+        Optional<GlobalSearchTask> taskOptional = searchTaskRepository.findByTaskIdAndUserId(taskId, userId);
+
+        if (taskOptional.isEmpty()) return ResponseEntity.ok().body("Task not found");
+
+        GlobalSearchTask task = taskOptional.orElseThrow();
+
+        int progress = task.getTotalFiles() > 0 ? task.getProcessedFiles() * 100 / task.getTotalFiles() : 0;
+
+        response = new GlobalSearchStatusResponse();
+        response.setTaskId(taskId);
+        response.setStatus(task.getStatus());
+        response.setProgress(progress);
+
+
+        return ResponseEntity.ok(response);
+    }
+}

src/main/java/ru/soune/nocopy/controller/HealtCheckController.java

@@ -0,0 +1,52 @@
+package ru.soune.nocopy.controller;
+
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.http.HttpStatus;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.HashMap;
+import java.util.Map;
+
+@RestController
+@RequestMapping("check/api")
+public class HealtCheckController {
+
+    @GetMapping("/healt")
+    public HttpStatus healtCheck() {
+        return HttpStatus.OK;
+    }
+
+    @Value("${BUILD_TIME_BACK:unknown}")
+    private String buildTimeBack;
+
+    @GetMapping("/build")
+    public BuildInfo getBuildInfo() {
+        return new BuildInfo(buildTimeBack);
+    }
+
+    @GetMapping("/api/debug/memory")
+    public Map<String, String> getMemoryInfo() {
+        Runtime runtime = Runtime.getRuntime();
+        long mb = 1024 * 1024;
+
+        Map<String, String> info = new HashMap<>();
+        info.put("maxMemory (MB)", String.valueOf(runtime.maxMemory() / mb));
+        info.put("totalMemory (MB)", String.valueOf(runtime.totalMemory() / mb));
+        info.put("freeMemory (MB)", String.valueOf(runtime.freeMemory() / mb));
+        info.put("usedMemory (MB)", String.valueOf((runtime.totalMemory() - runtime.freeMemory()) / mb));
+        info.put("availableProcessors", String.valueOf(runtime.availableProcessors()));
+
+        info.put("JAVA_TOOL_OPTIONS", System.getenv("JAVA_TOOL_OPTIONS"));
+        info.put("JAVA_OPTS", System.getenv("JAVA_OPTS"));
+
+        return info;
+    }
+
+    static class BuildInfo {
+        public String buildTimeBack;
+
+        public BuildInfo(String buildTimeBack) {
+            this.buildTimeBack = buildTimeBack;
+        }
+    }
+}

src/main/java/ru/soune/nocopy/controller/MigrationController.java

@@ -0,0 +1,83 @@
+package ru.soune.nocopy.controller;
+
+
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+import ru.soune.nocopy.dto.docviewer.DockViewResponse;
+import ru.soune.nocopy.entity.docviewer.DockView;
+import ru.soune.nocopy.entity.file.FileEntity;
+import ru.soune.nocopy.entity.user.User;
+import ru.soune.nocopy.migration.S3MigrationTool;
+import ru.soune.nocopy.repository.DockViewRepository;
+import ru.soune.nocopy.repository.FileEntityRepository;
+import ru.soune.nocopy.repository.UserRepository;
+import ru.soune.nocopy.service.geo.GeoCountryService;
+
+import java.util.List;
+import java.util.concurrent.CompletableFuture;
+
+@RestController
+@RequestMapping("/api/admin/migration")
+@RequiredArgsConstructor
+@Slf4j
+public class MigrationController {
+
+    private final S3MigrationTool migrationTool;
+
+    private final DockViewRepository dockViewRepository;
+
+    private final GeoCountryService geoCountryService;
+
+    private final UserRepository userRepository;
+
+    private final FileEntityRepository fileEntityRepository;
+
+    @PostMapping("/start")
+    public ResponseEntity<String> startMigration() {
+        log.info("Migration triggered via API");
+
+        CompletableFuture.runAsync(() -> {
+            try {
+                migrationTool.migrationFilesToS3();
+            } catch (Exception e) {
+                log.error("Migration failed", e);
+            }
+        });
+
+        return ResponseEntity.ok("Migration started. Check logs for progress.");
+    }
+
+    @PostMapping("/status")
+    public ResponseEntity<String> getStatus() {
+        return ResponseEntity.ok("Check application logs and migration_failed.txt for details");
+    }
+
+    @PostMapping("/fill-dock-view")
+    public ResponseEntity<String> fillDockView() {
+        List<DockView> dockViews = dockViewRepository.findAll();
+
+        for (DockView dockView: dockViews) {
+            String viewerIp = dockView.getViewerIp();
+            Long viewerId = dockView.getViewerId();
+            String geoEnName = geoCountryService.getCityByIp(viewerIp, "en") + "/" +
+                    geoCountryService.getCountryByIp(viewerIp, "en");
+            String geoRuName = geoCountryService.getCityByIp(viewerIp, "ru") + "/" +
+                    geoCountryService.getCountryByIp(viewerIp, "ru");
+            User user = userRepository.findById(viewerId).orElse(null);
+            FileEntity file = fileEntityRepository.findByFileId(dockView.getFileId());
+
+            dockView.setGeoNameRu(geoRuName);
+            dockView.setGeoNameEn(geoEnName);
+            dockView.setViewerName(user == null ? "guest" : user.getFullName());
+            dockView.setDocName(file.getOriginalFileName());
+
+            dockViewRepository.save(dockView);
+        }
+
+        return ResponseEntity.ok("fill old dock view");
+    }
+}

src/main/java/ru/soune/nocopy/controller/PaymentController.java

@@ -0,0 +1,123 @@
+package ru.soune.nocopy.controller;
+
+import jakarta.servlet.http.HttpServletRequest;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+import ru.soune.nocopy.entity.payment.Payment;
+import ru.soune.nocopy.exception.PaymentNotFoundException;
+import ru.soune.nocopy.exception.TariffNotFoundException;
+import ru.soune.nocopy.exception.UserNotFoundException;
+import ru.soune.nocopy.service.payment.PaymentService;
+
+import java.util.HashMap;
+import java.util.Map;
+
+@RestController
+@RequestMapping("/api/payments")
+@RequiredArgsConstructor
+@Slf4j
+public class PaymentController {
+
+    private final PaymentService paymentService;
+
+    private final HttpServletRequest httpServletRequest;
+
+    @PostMapping("/create")
+    public ResponseEntity<?> createPayment(@RequestParam String email, @RequestParam Long tariffId,
+                                           @RequestParam String operationType, @RequestParam String operationUuid) {
+        try {
+            Payment payment = paymentService.createPayment(email, tariffId, operationType, operationUuid);
+
+            return ResponseEntity.ok(payment);
+        } catch (TariffNotFoundException e) {
+            return ResponseEntity
+                    .status(HttpStatus.NOT_FOUND)
+                    .body(Map.of("error", "Tariff not found", "message", e.getMessage()));
+        } catch (UserNotFoundException e) {
+            return ResponseEntity
+                    .status(HttpStatus.NOT_FOUND)
+                    .body(Map.of("error", "User not found", "message", e.getMessage()));
+        } catch (Exception e) {
+            return ResponseEntity
+                    .status(HttpStatus.INTERNAL_SERVER_ERROR)
+                    .body(Map.of("error", "Internal server error", "message", e.getMessage()));
+        }
+    }
+
+    @PostMapping("webhook/yookassa")
+    public void handleYooKassaNotification(@RequestBody Map<String, Object> notification) {
+        try {
+            paymentService.handlePaymentNotification(notification);
+            log.info("Notification from yookassa: " + notification);
+        } catch (PaymentNotFoundException e) {
+            log.error("Error processing payment notification", e);
+        }
+    }
+
+    @PostMapping("/auto-renewal")
+    public ResponseEntity<?> disableAutoRenewal(@RequestParam(value = "renewal") Boolean renewal,
+            @RequestHeader(value = "Authorization", required = false) String tokenHeader) {
+        try {
+            if (tokenHeader == null || tokenHeader.isBlank()) {
+                Map<String, Object> errorData = new HashMap<>();
+                errorData.put("token", tokenHeader);
+
+                return ResponseEntity.ok().body(Map.of("error", errorData));
+            }
+
+            Long userId = (Long) httpServletRequest.getAttribute("userId");
+
+            paymentService.changeAutoRenewal(userId, renewal);
+            return ResponseEntity.ok(Map.of("message", "Auto-renewal changed:" + renewal));
+        } catch (UserNotFoundException e) {
+            return ResponseEntity.status(HttpStatus.NOT_FOUND)
+                    .body(Map.of("error", e.getMessage()));
+        }
+    }
+
+    @DeleteMapping("/methods/{paymentMethodId}")
+    public ResponseEntity<?> deletePaymentMethod(@RequestHeader(value = "Authorization", required = false) String tokenHeader,
+                                                 @PathVariable String paymentMethodId) {
+        try {
+            if (tokenHeader == null || tokenHeader.isBlank()) {
+                Map<String, Object> errorData = new HashMap<>();
+                errorData.put("token", tokenHeader);
+
+                return ResponseEntity.ok().body(Map.of("error", errorData));
+            }
+
+            Long userId = (Long) httpServletRequest.getAttribute("userId");
+
+            paymentService.deletePaymentMethod(userId, paymentMethodId);
+            return ResponseEntity.ok(Map.of("message", "Payment method deleted"));
+        } catch (UserNotFoundException e) {
+            return ResponseEntity.status(HttpStatus.NOT_FOUND)
+                    .body(Map.of("error", e.getMessage()));
+        } catch (RuntimeException e) {
+            return ResponseEntity.status(HttpStatus.BAD_REQUEST)
+                    .body(Map.of("error", e.getMessage()));
+        }
+    }
+
+    @GetMapping("/methods")
+    public ResponseEntity<?> getPaymentMethods(@RequestHeader(value = "Authorization", required = false) String tokenHeader) {
+        try {
+            if (tokenHeader == null || tokenHeader.isBlank()) {
+                Map<String, Object> errorData = new HashMap<>();
+                errorData.put("token", tokenHeader);
+
+                return ResponseEntity.ok().body(Map.of("error", errorData));
+            }
+
+            Long userId = (Long) httpServletRequest.getAttribute("userId");
+
+            return ResponseEntity.ok(paymentService.getUserPaymentMethods(userId));
+        } catch (UserNotFoundException e) {
+            return ResponseEntity.status(HttpStatus.NOT_FOUND)
+                    .body(Map.of("error", e.getMessage()));
+        }
+    }
+}

src/main/java/ru/soune/nocopy/controller/PayoutController.java

@@ -0,0 +1,201 @@
+package ru.soune.nocopy.controller;
+
+
+import jakarta.servlet.http.HttpServletRequest;
+import jakarta.validation.Valid;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+import ru.soune.nocopy.dto.payout.*;
+import ru.soune.nocopy.entity.payout.BankTransferPayoutMethod;
+import ru.soune.nocopy.entity.payout.CardPayoutMethod;
+import ru.soune.nocopy.entity.payout.PayoutRequest;
+import ru.soune.nocopy.entity.payout.PayoutType;
+import ru.soune.nocopy.entity.user.User;
+import ru.soune.nocopy.exception.InsufficientFundsException;
+import ru.soune.nocopy.exception.InvalidPayoutMethodException;
+import ru.soune.nocopy.exception.PendingPayoutExistsException;
+import ru.soune.nocopy.service.payout.PayoutMethodService;
+import ru.soune.nocopy.service.payout.PayoutRequestService;
+import ru.soune.nocopy.service.user.UserService;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.stream.Collectors;
+
+@RestController
+@RequestMapping("/api/payouts")
+@RequiredArgsConstructor
+@Slf4j
+public class PayoutController {
+
+    private final PayoutRequestService payoutRequestService;
+
+    private final PayoutMethodService payoutMethodService;
+
+    private final HttpServletRequest httpServletRequest;
+
+    private final UserService userService;
+
+    /*
+       Create payout
+     */
+    @PostMapping("/create-request")
+    public ResponseEntity<?> createPayoutRequest(@Valid @RequestBody PayoutRequestDTO request) {
+        Long userId = (Long) httpServletRequest.getAttribute("userId");
+        User user = userService.getUserById(userId).orElse(null);
+
+        if (user == null) {
+            return ResponseEntity.status(HttpStatus.NOT_FOUND).body("User not found with id: " + userId);
+        }
+
+        try {
+            PayoutRequest payoutRequest = payoutRequestService.createPayoutRequest(user.getId(), request);
+            return ResponseEntity.status(HttpStatus.CREATED).body(payoutRequest);
+        } catch (InsufficientFundsException | PendingPayoutExistsException | InvalidPayoutMethodException e) {
+            return ResponseEntity.status(HttpStatus.CONFLICT).body(e.getMessage());
+        }
+    }
+
+    /*
+        Completed payout
+     */
+    @PostMapping("/requests/{requestId}/process")
+    public ResponseEntity<PayoutRequest> processPayoutRequest(@PathVariable Long requestId) {
+        PayoutRequest processed = payoutRequestService.processRequest(requestId);
+
+        return ResponseEntity.ok(processed);
+    }
+
+    /*
+       Cancel payout
+     */
+    @PostMapping("/requests/{requestId}/cancel")
+    public ResponseEntity<PayoutRequest> cancelPayoutRequest(@PathVariable Long requestId) {
+        Long userId = (Long) httpServletRequest.getAttribute("userId");
+        User user = userService.getUserById(userId).orElse(null);
+
+        if (user == null) {
+            return ResponseEntity.notFound().build();
+        }
+
+        PayoutRequest cancelled = payoutRequestService.cancelPayoutRequest(user.getId(), requestId);
+
+        return ResponseEntity.ok(cancelled);
+    }
+
+    /*
+       Get user payouts
+     */
+    @GetMapping("/requests")
+    public ResponseEntity<List<PayoutRequest>> getUserRequests() {
+        Long userId = (Long) httpServletRequest.getAttribute("userId");
+        User user = userService.getUserById(userId).orElse(null);
+
+        if (user == null) {
+            return ResponseEntity.notFound().build();
+        }
+
+        return ResponseEntity.ok(payoutRequestService.getUserPayoutRequests(user.getId()));
+    }
+
+    /*
+         Get payout by id
+    */
+    @GetMapping("/requests/{requestId}")
+    public ResponseEntity<PayoutRequest> getPayoutRequest(@PathVariable Long requestId) {
+        Long userId = (Long) httpServletRequest.getAttribute("userId");
+        User user = userService.getUserById(userId).orElse(null);
+
+        if (user == null) {
+            return ResponseEntity.notFound().build();
+        }
+
+        return ResponseEntity.ok(payoutRequestService.getPayoutRequest(user.getId(), requestId));
+    }
+
+    /*
+             Get payout by id
+     */
+    @GetMapping("user/payout-methods")
+    public ResponseEntity<List<PayoutMethodDTO>> getUserMethods() {
+        Long userId = (Long) httpServletRequest.getAttribute("userId");
+        User user = userService.getUserById(userId).orElse(null);
+
+        if (user == null) {
+            return ResponseEntity.notFound().build();
+        }
+
+        return ResponseEntity.ok(payoutMethodService.getUserMethods(user.getId()));
+    }
+
+    /*
+         Get payout-methods
+     */
+    @GetMapping("/payout-methods")
+    public ResponseEntity<List<PayoutMethodTypeDTO>> getAvailableMethodTypes() {
+        List<PayoutMethodTypeDTO> types = Arrays.stream(PayoutType.values())
+                .map(type -> PayoutMethodTypeDTO.builder()
+                        .code(type.name())
+                        .name(type.getDisplayName())
+                        .build())
+                .collect(Collectors.toList());
+
+        return ResponseEntity.ok(types);
+    }
+    /*
+         add card method by userId
+       */
+    @PostMapping("/payout-method/card")
+    public ResponseEntity<PayoutMethodDTO> addCardMethod(@Valid @RequestBody AddCardRequest request) {
+        Long userId = (Long) httpServletRequest.getAttribute("userId");
+        User user = userService.getUserById(userId).orElse(null);
+
+        if (user == null) {
+            return ResponseEntity.notFound().build();
+        }
+
+        CardPayoutMethod method = payoutMethodService.addCardMethod(user.getId(), request);
+
+        return ResponseEntity.status(HttpStatus.CREATED)
+                .body(payoutMethodService.convertToDto(method));
+    }
+
+    /*
+         add bank payout-method
+     */
+    @PostMapping("/payout-method/bank-transfer")
+    public ResponseEntity<PayoutMethodDTO> addBankTransferMethod(@Valid @RequestBody AddBankTransferRequest request) {
+        Long userId = (Long) httpServletRequest.getAttribute("userId");
+        User user = userService.getUserById(userId).orElse(null);
+
+        if (user == null) {
+            return ResponseEntity.notFound().build();
+        }
+
+        BankTransferPayoutMethod method = payoutMethodService.addBankTransferMethod(user.getId(), request);
+
+        return ResponseEntity.status(HttpStatus.CREATED)
+                .body(payoutMethodService.convertToDto(method));
+    }
+
+
+    /*
+         set default bank payout-method
+     */
+    @PutMapping("/payout-method/{methodId}/default")
+    public ResponseEntity<Void> setDefaultMethod(@PathVariable Long methodId) {
+        Long userId = (Long) httpServletRequest.getAttribute("userId");
+        User user = userService.getUserById(userId).orElse(null);
+
+        if (user == null) {
+            return ResponseEntity.notFound().build();
+        }
+
+        payoutMethodService.setDefaultMethod(user.getId(), methodId);
+
+        return ResponseEntity.ok().build();
+    }
+}

src/main/java/ru/soune/nocopy/controller/SearchSettingsController.java

@@ -0,0 +1,58 @@
+package ru.soune.nocopy.controller;
+
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+import ru.soune.nocopy.configuration.search.SearchProperties;
+import ru.soune.nocopy.dto.BaseResponse;
+import ru.soune.nocopy.dto.search.config.SearchSettingsDto;
+
+import java.util.Map;
+
+
+@Slf4j
+@RestController
+@RequestMapping("/api/search/settings")
+@RequiredArgsConstructor
+public class SearchSettingsController {
+
+    private final SearchProperties searchProperties;
+
+    @GetMapping
+    public ResponseEntity<?> getSettings() {
+        SearchSettingsDto dto = new SearchSettingsDto();
+
+        dto.setEngines(Map.of(
+                "yandex", searchProperties.getEngines().get("yandex").isEnabled(),
+                "google", searchProperties.getEngines().get("google").isEnabled()));
+
+        dto.setProxyEnabled(searchProperties.getProxy().isEnabled());
+
+        return ResponseEntity.ok().body(BaseResponse.builder()
+                .messageDesc("Success")
+                .messageBody(dto)
+                .build());
+    }
+
+    @PutMapping
+    public ResponseEntity<?> updateSettings(@RequestBody SearchSettingsDto settings) {
+        if (settings.getEngines() != null) {
+            settings.getEngines().forEach((key, value) -> {
+                if (searchProperties.getEngines().containsKey(key)) {
+                    searchProperties.getEngines().get(key).setEnabled(value);
+                }
+            });
+        }
+
+        if (settings.getProxyEnabled() != null) {
+            searchProperties.getProxy().setEnabled(settings.getProxyEnabled());
+        }
+
+        log.info("Settings updated: {}", settings);
+
+        return ResponseEntity.ok().body(BaseResponse.builder()
+                .messageDesc("Settings updated")
+                .build());
+    }
+}

src/main/java/ru/soune/nocopy/controller/UserController.java

@@ -0,0 +1,191 @@
+package ru.soune.nocopy.controller;
+
+import jakarta.servlet.http.HttpServletRequest;
+import lombok.RequiredArgsConstructor;
+import org.springframework.http.ResponseEntity;
+import org.springframework.security.crypto.password.PasswordEncoder;
+import org.springframework.web.bind.annotation.*;
+import ru.soune.nocopy.dto.BaseResponse;
+import ru.soune.nocopy.dto.MessageCode;
+import ru.soune.nocopy.dto.register.ChangePasswordRequest;
+import ru.soune.nocopy.dto.register.RegAnswer;
+import ru.soune.nocopy.dto.register.RegRequest;
+import ru.soune.nocopy.dto.tarriff.TariffInfoDTO;
+import ru.soune.nocopy.dto.user.UserDTO;
+import ru.soune.nocopy.dto.user.UserRequest;
+import ru.soune.nocopy.entity.tarif.Tariff;
+import ru.soune.nocopy.entity.tarif.TariffInfo;
+import ru.soune.nocopy.entity.user.User;
+import ru.soune.nocopy.exception.InvalidUserEmail;
+import ru.soune.nocopy.exception.NotValidFieldException;
+import ru.soune.nocopy.exception.UserNotFoundException;
+import ru.soune.nocopy.mapper.UserMapper;
+import ru.soune.nocopy.repository.UserRepository;
+import ru.soune.nocopy.service.file.FileStatsService;
+import ru.soune.nocopy.service.tariff.TariffService;
+import ru.soune.nocopy.service.user.UserService;
+import ru.soune.nocopy.util.JwtUtil;
+
+import java.util.Arrays;
+import java.util.Map;
+
+@RestController
+@RequestMapping("v1/api/user")
+@RequiredArgsConstructor
+public class UserController {
+
+    private final UserRepository userRepository;
+
+    private final UserService userService;
+
+    private final UserMapper userMapper;
+
+    private final PasswordEncoder passwordEncoder;
+
+    private final TariffService tariffService;
+
+    private final FileStatsService fileStatsService;
+
+    private final JwtUtil jwtUtil;
+
+    private final HttpServletRequest httpServletRequest;
+
+
+    @GetMapping
+    public ResponseEntity<UserDTO> getUser(@RequestParam("email") String email) {
+        User user = userRepository.findByEmail(email);
+
+        if (user != null) {
+            UserDTO userDTO = userMapper.toDTO(user);
+            userDTO.setEmail(email);
+            userDTO.setFullName(user.getFullName());
+            userDTO.setVerifiedStatus(user.getVerificationStatus());
+
+            if (user.getCompany() != null) {
+                userDTO.setCompany(user.getCompany().getCompanyName());
+            }
+
+            if (user.canManageCompanySettings() || user.canLogin() && user.getCompany() == null) {
+                userDTO.setTariffs(tariffService.getTariffByAccountType(user));
+
+                Long fileOnDisk = user.canManageCompanySettings() ?
+                        fileStatsService.calculateCompanyFileSize(user.getId()):
+                        fileStatsService.calculateUserFileSize(user.getId());
+
+                Integer filesCount =  user.canManageCompanySettings() ?
+                        fileStatsService.filesCompanyCount(user.getId()):
+                        fileStatsService.filesUserCount(user.getId());
+
+                TariffInfo personalTariffInfo;
+
+                if (user.getCompany() == null) {
+                    personalTariffInfo = user.getPersonalTariffInfo();
+                } else {
+                    personalTariffInfo = user.getCompany().getTariffInfo();
+                }
+
+                Tariff tariff = personalTariffInfo.getTariff();
+
+                TariffInfoDTO infoDTO = TariffInfoDTO.builder().tokens(personalTariffInfo.getTokens())
+                        .id(personalTariffInfo.getId())
+                        .tariffName(tariff.getName())
+                        .status(personalTariffInfo.getStatus().name())
+                        .tariffId(tariff.getId())
+                        .currentFileCounts(filesCount)
+                        .maxFileCounts(tariff.getMaxFilesCount())
+                        .currentFileOnDisk(fileOnDisk)
+                        .maxFileOnDisk(tariff.getDiskSize())
+                        .startTariff(personalTariffInfo.getStartTariff())
+                        .endTariff(personalTariffInfo.getEndTariff())
+                        .tokens(personalTariffInfo.getTokens() + personalTariffInfo.getBoughtTokens())
+                        .build();
+
+                userDTO.setTariffInfo(infoDTO);
+            }
+
+            userDTO.setPhone(user.getPhone());
+            userDTO.setGenderType(user.getGenderType());
+            userDTO.setBirthday(user.getBirthday());
+            userDTO.setCreatedAt(user.getCreatedAt());
+            userDTO.setActive(user.isActive());
+            userDTO.setPermission(user.getUserPermissions());
+
+            return ResponseEntity.ok(userDTO);
+        }
+
+        return ResponseEntity.notFound().build();
+    }
+
+    //TODO fix mapper,doesnot exist all fields
+    @PostMapping("/change-password")
+    public ResponseEntity<UserDTO> updateUser(@RequestBody ChangePasswordRequest changePasswordRequest) {
+        Long userId = (Long) httpServletRequest.getAttribute("userId");
+        User user = userService.getUserById(userId).orElse(null);
+
+        if (user == null) {
+            throw  new UserNotFoundException("User not found by id: " + userId);
+        }
+
+        if (!changePasswordRequest.getEmail().equals(user.getEmail())) {
+            throw new InvalidUserEmail("Email is not valid: " + changePasswordRequest.getEmail() + "not found");
+        }
+
+        User updateUser = userService.changePassword(user, changePasswordRequest);
+
+        return ResponseEntity.ok(userMapper.toDTO(updateUser));
+    }
+
+    @PatchMapping("/user-update")
+    public ResponseEntity<UserDTO> updateUser(@RequestBody UserRequest userRequest) {
+        Long userId = (Long) httpServletRequest.getAttribute("userId");
+        User user = userService.getUserById(userId).orElse(null);
+
+        if (user == null) {
+            throw  new UserNotFoundException("User not found by id: " + userId);
+        }
+
+        return ResponseEntity.ok(userService.updateUser(userRequest, user));
+    }
+
+    @PostMapping("/create-user")
+    public ResponseEntity<?> addUser(@RequestBody RegRequest registerRequest) {
+
+        if (userRepository.existsByEmail(registerRequest.getEmail()) ||
+                userRepository.existsByPhone(registerRequest.getPhone())) {
+            RegAnswer regAnswer = new RegAnswer();
+            regAnswer.setFieldErrors(Arrays.asList(Map.of("email", registerRequest.getEmail())));
+            regAnswer.setFieldErrors(Arrays.asList(Map.of("phone", registerRequest.getPhone())));
+
+            throw new NotValidFieldException("User already exists with email:" + registerRequest.getEmail() + " or phone: " +
+                    registerRequest.getPhone(), new BaseResponse(2,
+                    MessageCode.REG_EMAIL_OR_PHONE_EXISTS.getCode(),
+                    MessageCode.REG_EMAIL_OR_PHONE_EXISTS.getDescription(), regAnswer));
+        }
+
+        User user = new User();
+        user.setFullName(registerRequest.getFullName());
+        user.setEmail(registerRequest.getEmail());
+        user.setPassword(passwordEncoder.encode(registerRequest.getPassword()));
+        user.setActive(true);
+        user.setEmailVerified(true);
+
+        if (registerRequest.getPhone() != null) {
+            user.setPhone(registerRequest.getPhone());
+        }
+
+        User savedUser = userRepository.save(user);
+
+        String authToken = jwtUtil.generateToken(savedUser.getId(), savedUser.getEmail());
+
+        return ResponseEntity.ok().body(Map.of(
+                "user", savedUser,
+                "token", authToken));
+    }
+
+    @DeleteMapping("/delete-user/{userId}")
+    public ResponseEntity<?> addUser(@PathVariable Long userId) {
+        userRepository.deleteById(userId);
+        return ResponseEntity.ok().body(Map.of("userId", userId, "deleted", "true"));
+    }
+
+}

src/main/java/ru/soune/nocopy/dto/BaseRequest.java

@@ -0,0 +1,21 @@
+package ru.soune.nocopy.dto;
+
+import com.fasterxml.jackson.annotation.JsonFormat;
+import com.fasterxml.jackson.annotation.JsonProperty;
+import lombok.Data;
+
+@Data
+@JsonFormat(with = JsonFormat.Feature.ACCEPT_CASE_INSENSITIVE_PROPERTIES)
+public class BaseRequest {
+    @JsonProperty("version")
+    Integer version;
+
+    @JsonProperty("msg_id")
+    Integer msgId;
+
+    @JsonProperty("message_body")
+    Object messageBody;
+
+    @JsonProperty(value = "admin_id", required = false)
+    Long adminId;
+}

src/main/java/ru/soune/nocopy/dto/BaseResponse.java

@@ -0,0 +1,25 @@
+package ru.soune.nocopy.dto;
+
+import com.fasterxml.jackson.annotation.JsonFormat;
+import com.fasterxml.jackson.annotation.JsonProperty;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+
+@Data
+@AllArgsConstructor
+@Builder
+@JsonFormat(with = JsonFormat.Feature.ACCEPT_CASE_INSENSITIVE_PROPERTIES)
+public class BaseResponse {
+    @JsonProperty("msg_id")
+    private Integer msgId;
+
+    @JsonProperty("message_code")
+    private Integer messageCode;
+
+    @JsonProperty("message_desc")
+    private String messageDesc;
+
+    @JsonProperty("message_body")
+    private Object messageBody;
+}

src/main/java/ru/soune/nocopy/dto/MessageCode.java

@@ -0,0 +1,97 @@
+package ru.soune.nocopy.dto;
+
+public enum MessageCode {
+    SUCCESS(0, "Operation successful"),
+    SUCCESS_MODERATION(0, "File moderated successfully"),
+    REG_EMAIL_EXISTS(1, "Email already registered"),
+    REG_EMAIL_OR_PHONE_EXISTS(1, "Email or phone already registered"),
+    REFERRAL_LINK_IS_NOT_EXIST(1, "Refferal link is not exist"),
+    FILE_IS_BLOCKED(1, "File is blocked,deleted or removed"),
+    INVALID_FIELD(2, "Invalid field"),
+    MAIL_VERIFIED_NULL(2, "Mail verified null"),
+    INVALID_TOKEN(2, "Token not found or time expired"),
+    TOKEN_IS_ALIVE(2, "Token is alive"),
+    INVALID_ACTION(2, "Invalid action"),
+    FILE_UPLOAD_ERROR(2, "File upload error"),
+    DUPLICATE_FILE_UPLOAD(2, "Duplicate file upload"),
+    FILE_DOWNLOAD_ERROR(2, "File download error"),
+    FILE_NOT_EXIST(2, "File not exist on disk"),
+    FILE_DELETE(2, "File was deleted"),
+    USER_NOT_HAD_PERMISSION(2, "User not have permission for file"),
+    NOT_OWNER_FILE_STATUS_VIOLATION(2, "Violation in not owner file status"),
+    USER_NOT_VERIFIED(2, "User not verified"),
+    LAW_CASE_NOT_FOUND(4, "Law case not found"),
+    PERMISSION_NOT_FOUND(2, "Permission not found"),
+    INVALID_CREDENTIALS(2, "Invalid credentials"),
+    USER_NOT_FOUND(2, "User not found"),
+    LAW_CASE_ALREADY_EXIST(2, "Law case already exists"),
+    COMPLAINT_ALREADY_EXIST(2, "Complaint already exists"),
+    COMPLAINT_NOT_FOUND(4, "Complaint not found"),
+    FILE_DOWNLOAD_ERROR_NOT_CORRECT_FIELD(2, "Not correct field"),
+    TOKEN_IS_NULL(2, "Token field is null"),
+    IMAGE_FOUND_ERROR(2, "Image found error"),
+    INVALID_JSON_BODY(2, "Invalid fields in JSON object"),
+    INCOMPLETE_UPLOAD(2, "Not load all chunks"),
+    USER_NOT_HAVE_TOKEN(2, "Not have tokens"),
+    MSG_ID_NOT_FOUND(4, "Message id not found"),
+    FILE_ENTITY_ERROR(2, "File entity error"),
+    NOT_VALID_FIELD(2, "Not valid field"),
+    ACCESS_DENIED(2, "Access denied"),
+    AUTH_EMAIL_NOT_FOUND(4, "Email not COMPLAINT_OR_LAW_CASE_IN_WORK"),
+    AUTH_EMAIL_OR_TOKEN_NOT_FOUND(4, "Email or Token not found "),
+    AUTH_TOKEN_MISMATCH(4, "Token mismatch"),
+    AUTH_TOKEN_NOT_FOUND(4, "Token not found"),
+    FILE_NOT_FOUND(4, "File not found"),
+    AUTH_PASSWORD_NOT_MATCHES(2, "Password does not match"),
+    SEND_EMAIL_EXCEPTION(2, "Send email exception"),
+    SIMILAR_FILES_FOUND(0, "Similar files found"),
+    FILE_IS_PROTECTED(0, "File is protected"),
+    FILE_IS_NOT_PROTECTED(0, "File is not protected"),
+    TARIFF_IS_ADD(0, "Tariff is added"),
+    TARIFF_IS_DELETED(0, "Tariff is deleted"),
+    TARIFF_IS_NOT_DELETED(0, "Tariff is not deleted,use some users"),
+    TARIFF_IS_UPDATED(0, "Tariff is updated"),
+    TARIFF_IS_NOT_FOUND(0, "Tariff is not found"),
+    VALIDATION_ERROR(2, "Validation error"),
+    RESOURCE_NOT_FOUND(4, "Resource not found"),
+    OPERATION_NOT_FOUND(4, "Operation not found"),
+    INTERNAL_ERROR(4, "Internal server error"),
+    COMPANY_NOT_FOUND(4, "Company not found"),
+    PAYMENT_NOT_FOUND(4, "Payment not found"),
+    COMPANY_ALREADY_EXISTS(2, "Company already exists"),
+    USER_LIMIT_IS_OVER(2, "Over user limits"),
+    MONITORING_TYPE_NOT_FOUND(4, "Monitoring type not found"),
+    ERROR_TARIFF_INFO(2, "Erorr with tariff info"),
+    FILE_FOR_SEARCH_NOT_VALID(2, "File for search unsupported"),
+    ILLEGAL_STATE(2, "File is not in moderation state"),
+    NOT_VALID_FILE_TYPE_OR_COUNT_FILE(2, "Cost for file type not found, count is negative or files count" +
+            "more than max valid"),
+    USER_NOT_ACTIVE(2, "User not active"),
+    NOTION_NOT_FOUND(4, "Notion not found"),
+    NOT_FOUND(4, "Notion not found"),
+    MESSAGE_IS_REQUIRED_FOR_NOTION(4, "Message is required for notion"),
+    USER_VERIFICATIONS_NOT_FOUND(4, "Verifications not found"),
+    COMPLAINT_OR_LAW_CASE_IN_WORK(2, "Complaint or lawcase in work"),
+    NOT_VALID_STATUS(2, "Not valid status"),
+    PERMISSION_NOT_VALID(2, "Not valid permission"),
+    NOT_HAVE_DOWNLOAD_PERMISSION(2, "Not haver permission for download"),
+    ADMIN_USER_NOT_FOUND(4, "Verifications ,user or admin not found");
+
+
+    private final Integer code;
+
+    private final String description;
+
+    MessageCode(Integer code, String description) {
+        this.code = code;
+        this.description = description;
+    }
+
+    public Integer getCode() {
+        return code;
+    }
+
+    public String getDescription() {
+        return description;
+    }
+}

src/main/java/ru/soune/nocopy/dto/TokenProcessRequest.java

@@ -0,0 +1,9 @@
+package ru.soune.nocopy.dto;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+import lombok.Data;
+
+@Data
+public class TokenProcessRequest {
+
+}

src/main/java/ru/soune/nocopy/dto/company/CompanyActionRequestDto.java

@@ -0,0 +1,23 @@
+package ru.soune.nocopy.dto.company;
+
+import lombok.Data;
+import java.util.Map;
+
+@Data
+public class CompanyActionRequestDto {
+    private String action;
+    private String companyId;
+    private String companyName;
+    private Map<String, Object> companyData;
+    private Long userId;
+    private Map<String, Object> searchParams;
+    private PageableParams pageable;
+
+    @Data
+    public static class PageableParams {
+        private int page;
+        private int size;
+        private String sort;
+        private String direction;
+    }
+}

src/main/java/ru/soune/nocopy/dto/company/CompanyResponseDto.java

@@ -0,0 +1,16 @@
+package ru.soune.nocopy.dto.company;
+
+import lombok.Data;
+import java.time.LocalDateTime;
+
+@Data
+public class CompanyResponseDto {
+    private String id;
+    private String companyName;
+    private String phone;
+    private String address;
+    private String email;
+    private LocalDateTime registerDate;
+    private LocalDateTime updateDate;
+    private long userCount;
+}

src/main/java/ru/soune/nocopy/dto/complaint/BaseResponse.java

@@ -0,0 +1,35 @@
+package ru.soune.nocopy.dto.complaint;
+import com.fasterxml.jackson.annotation.JsonProperty;
+import lombok.Builder;
+import lombok.Data;
+
+@Data
+@Builder
+public class BaseResponse {
+    @JsonProperty("status")
+    private String status;
+
+    @JsonProperty("message")
+    private String message;
+
+    @JsonProperty("data")
+    private Object data;
+
+    @JsonProperty("error_code")
+    private String errorCode;
+
+    public static BaseResponse success(Object data) {
+        return BaseResponse.builder()
+                .status("SUCCESS")
+                .data(data)
+                .build();
+    }
+
+    public static BaseResponse error(String message, String errorCode) {
+        return BaseResponse.builder()
+                .status("ERROR")
+                .message(message)
+                .errorCode(errorCode)
+                .build();
+    }
+}

src/main/java/ru/soune/nocopy/dto/complaint/ComplaintRequest.java

@@ -0,0 +1,38 @@
+package ru.soune.nocopy.dto.complaint;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+import lombok.Data;
+import java.util.List;
+
+@Data
+public class ComplaintRequest {
+    @JsonProperty("action")
+    private String action;
+
+    @JsonProperty("id")
+    private Long id;
+
+    @JsonProperty("violation_id")
+    private Long violationId;
+
+    @JsonProperty("text")
+    private String complaintText;
+
+    @JsonProperty("email")
+    private String email;
+
+    @JsonProperty("status")
+    private String status;
+
+    @JsonProperty("page")
+    private Integer page;
+
+    @JsonProperty("size")
+    private Integer size;
+
+    @JsonProperty("sort_by")
+    private String sortBy;
+
+    @JsonProperty("sort_direction")
+    private String sortDirection;
+}

src/main/java/ru/soune/nocopy/dto/complaint/ComplaintResponse.java

@@ -0,0 +1,42 @@
+package ru.soune.nocopy.dto.complaint;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+import java.util.List;
+
+@Data
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+public class ComplaintResponse {
+    @JsonProperty("id")
+    private Long id;
+
+    @JsonProperty("status")
+    private String status;
+
+    @JsonProperty("complaint_text")
+    private String complaintText;
+
+    @JsonProperty("violation_id")
+    private Long violationId;
+
+    @JsonProperty("email")
+    private String email;
+
+    @JsonProperty("created_at")
+    private String createdAt;
+
+    @JsonProperty("updated_at")
+    private String updatedAt;
+
+    @JsonProperty("not_moderated")
+    private Boolean notModerated;
+
+    @JsonProperty("file_id")
+    private String fileId;
+}

src/main/java/ru/soune/nocopy/dto/complaint/LawCasePageResponse.java

@@ -0,0 +1,17 @@
+package ru.soune.nocopy.dto.complaint;
+
+import lombok.Builder;
+import lombok.Data;
+import java.util.List;
+
+@Data
+@Builder
+public class LawCasePageResponse {
+    private List<LawCaseResponse> content;
+    private int pageNumber;
+    private int pageSize;
+    private long totalElements;
+    private int totalPages;
+    private boolean last;
+    private boolean first;
+}

src/main/java/ru/soune/nocopy/dto/complaint/LawCaseRequest.java

@@ -0,0 +1,32 @@
+package ru.soune.nocopy.dto.complaint;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+import lombok.Data;
+import ru.soune.nocopy.entity.complaint.LawCasePriority;
+import ru.soune.nocopy.entity.complaint.LawCaseType;
+
+import java.math.BigDecimal;
+
+@Data
+public class LawCaseRequest {
+    private Long id;
+    //required
+    private String name;
+    //required
+    private String description;
+    private BigDecimal amount;
+    private String priority = LawCasePriority.HIGH.toString();
+    private String type;
+    private String lawyer;
+    private Integer pageSize = 5;
+    private Integer pageNumber = 0;
+    private String sortBy = "updatedAt";
+    private String sortDir = "desc";
+    private String action;
+    private String filterType;
+    private String filterLawyer;
+    private String filterPriority;
+    @JsonProperty("violation_id")
+    private Long violationId;
+
+}

src/main/java/ru/soune/nocopy/dto/complaint/LawCaseResponse.java

@@ -0,0 +1,71 @@
+package ru.soune.nocopy.dto.complaint;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+import lombok.Builder;
+import lombok.Data;
+import ru.soune.nocopy.entity.complaint.LawCase;
+import ru.soune.nocopy.entity.complaint.LawCasePriority;
+import ru.soune.nocopy.entity.complaint.LawCaseType;
+
+import java.math.BigDecimal;
+import java.time.LocalDateTime;
+import java.util.List;
+
+@Data
+@Builder
+public class LawCaseResponse {
+    private Long id;
+
+    private String name;
+
+    private String description;
+
+    private BigDecimal amount;
+
+    private LawCasePriority priority;
+
+    private LawCaseType type;
+
+    private String lawyer;
+
+    @JsonProperty("created_at")
+    private LocalDateTime createdAt;
+
+    @JsonProperty("updated_at")
+    private LocalDateTime updatedAt;
+
+    @JsonProperty("page_number")
+    private int pageNumber;
+
+    @JsonProperty("page_size")
+    private int pageSize;
+
+    @JsonProperty("total_elements")
+    private long totalElements;
+
+    @JsonProperty("total_pages")
+    private int totalPages;
+
+    @JsonProperty("violation_id")
+    private long violationId;
+
+    @JsonProperty("file_id")
+    private String fileId;
+
+    private List<LawCaseResponse> content;
+
+    public static LawCaseResponse fromEntity(LawCase lawCase) {
+        return LawCaseResponse.builder()
+                .id(lawCase.getId())
+                .name(lawCase.getName())
+                .description(lawCase.getDescription())
+                .amount(lawCase.getAmount())
+                .priority(lawCase.getPriority())
+                .type(lawCase.getType())
+                .lawyer(lawCase.getLawyer())
+                .createdAt(lawCase.getCreatedAt())
+                .updatedAt(lawCase.getUpdatedAt())
+                .violationId(lawCase.getViolationId())
+                .build();
+    }
+}

src/main/java/ru/soune/nocopy/dto/complaint/PaginatedResponse.java

@@ -0,0 +1,17 @@
+package ru.soune.nocopy.dto.complaint;
+
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import java.util.List;
+
+@Data
+@AllArgsConstructor
+public class PaginatedResponse<T> {
+    private List<T> content;
+    private long totalElements;
+    private int totalPages;
+    private int pageNumber;
+    private int pageSize;
+    private boolean first;
+    private boolean last;
+}

src/main/java/ru/soune/nocopy/dto/cost/CostRequest.java

@@ -0,0 +1,15 @@
+package ru.soune.nocopy.dto.cost;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+import lombok.Data;
+
+@Data
+public class CostRequest {
+    String action;
+
+    @JsonProperty("file_type")
+    String fileType;
+
+    @JsonProperty("count_files")
+    Integer countFilesForProtect;
+}

src/main/java/ru/soune/nocopy/dto/cost/CostResponse.java

@@ -0,0 +1,22 @@
+package ru.soune.nocopy.dto.cost;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+import lombok.Builder;
+import lombok.Data;
+
+@Data
+@Builder
+public class CostResponse {
+    private int cost;
+
+    private Boolean success;
+
+    @JsonProperty("max_files_for_check")
+    private Integer maxFilesForCheck;
+
+    @JsonProperty("count_file")
+    private Integer countFile;
+
+    @JsonProperty("tokens_count")
+    private int needTokensCount;
+}

src/main/java/ru/soune/nocopy/dto/dadata/DaDataAddress.java

@@ -0,0 +1,10 @@
+package ru.soune.nocopy.dto.dadata;
+
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+import lombok.Data;
+
+@Data
+@JsonIgnoreProperties(ignoreUnknown = true)
+public class DaDataAddress {
+    private String value;
+}

src/main/java/ru/soune/nocopy/dto/dadata/DaDataData.java

@@ -0,0 +1,11 @@
+package ru.soune.nocopy.dto.dadata;
+
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+import lombok.Data;
+
+@Data
+@JsonIgnoreProperties(ignoreUnknown = true)
+public class DaDataData {
+    private String inn;
+    private DaDataAddress address;
+}

src/main/java/ru/soune/nocopy/dto/dadata/DaDataRequest.java

@@ -0,0 +1,11 @@
+package ru.soune.nocopy.dto.dadata;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+import lombok.Data;
+
+@Data
+public class DaDataRequest {
+
+    @JsonProperty("inn")
+    private String inn;
+}

src/main/java/ru/soune/nocopy/dto/dadata/DaDataResponse.java

@@ -0,0 +1,16 @@
+package ru.soune.nocopy.dto.dadata;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+import lombok.Data;
+
+@Data
+public class DaDataResponse {
+    @JsonProperty("companyName")
+    private String companyName;
+
+    @JsonProperty("inn")
+    private String inn;
+
+    @JsonProperty("address")
+    private String address;
+}

src/main/java/ru/soune/nocopy/dto/dadata/DaDataSuggestion.java

@@ -0,0 +1,11 @@
+package ru.soune.nocopy.dto.dadata;
+
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+import lombok.Data;
+
+@Data
+@JsonIgnoreProperties(ignoreUnknown = true)
+public class DaDataSuggestion {
+    private String value;
+    private DaDataData data;
+}

src/main/java/ru/soune/nocopy/dto/dadata/DaDataWrapper.java

@@ -0,0 +1,12 @@
+package ru.soune.nocopy.dto.dadata;
+
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+import lombok.Data;
+
+import java.util.List;
+
+@Data
+@JsonIgnoreProperties(ignoreUnknown = true)
+public class DaDataWrapper {
+    private List<DaDataSuggestion> suggestions;
+}

src/main/java/ru/soune/nocopy/dto/docviewer/DocViewerRequest.java

@@ -0,0 +1,36 @@
+package ru.soune.nocopy.dto.docviewer;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+import lombok.Builder;
+import lombok.Data;
+
+@Data
+@Builder
+public class DocViewerRequest {
+    @JsonProperty("file_id")
+    private String fileId;
+
+    @JsonProperty("ip")
+    private String ip;
+
+    @JsonProperty("user_agent")
+    private String userAgent;
+
+    @JsonProperty("page")
+    private int page = 0;
+
+    @JsonProperty("size")
+    private int size = 10;
+
+    @JsonProperty("sort_by")
+    private String sortBy = "createdAt";
+
+    @JsonProperty("sort_direction")
+    private String sortDirection = "desc";
+
+    @JsonProperty("action")
+    private String action;
+
+    @JsonProperty("locale")
+    private String locale;
+}

src/main/java/ru/soune/nocopy/dto/docviewer/DockViewResponse.java

@@ -0,0 +1,31 @@
+package ru.soune.nocopy.dto.docviewer;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+import java.time.LocalDateTime;
+
+@Data
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+public class DockViewResponse {
+
+    @JsonProperty("city")
+    private String city;
+
+    @JsonProperty("country")
+    private String country;
+
+    @JsonProperty("viewer")
+    private String viewer;
+
+    @JsonProperty("document")
+    private String document;
+
+    @JsonProperty("view_date")
+    private LocalDateTime viewDate;
+}

src/main/java/ru/soune/nocopy/dto/docviewer/DockViewStatsResponse.java

@@ -0,0 +1,55 @@
+package ru.soune.nocopy.dto.docviewer;
+
+import com.fasterxml.jackson.annotation.JsonInclude;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+import java.time.LocalDateTime;
+import java.util.List;
+
+@Data
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+@JsonInclude(JsonInclude.Include.NON_NULL)
+public class DockViewStatsResponse {
+    private String fileId;
+
+    private Long totalViews;
+
+    private Long uniqueIps;
+
+    private Long uniqueUsers;
+
+    private int documentsCount;
+
+    private int uniqueCountryCount;
+
+    private int uniqueCityCount;
+
+    private LocalDateTime firstViewDate;
+
+    private LocalDateTime lastViewDate;
+
+    private List<DockViewStatsResponse> content;
+
+    private List<DockViewResponse> history;
+
+    private Integer pageNumber;
+
+    private Integer pageSize;
+
+    private Long totalElements;
+
+    private Integer totalPages;
+
+    private Boolean isLast;
+
+    private Boolean isFirst;
+
+    private Boolean hasNext;
+
+    private Boolean hasPrevious;
+}

src/main/java/ru/soune/nocopy/dto/file/ActionResponse.java

@@ -0,0 +1,17 @@
+package ru.soune.nocopy.dto.file;
+
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+import java.util.List;
+
+@Data
+@Builder
+@AllArgsConstructor
+@NoArgsConstructor
+public class ActionResponse {
+    private List<String> availableActions;
+    private String action;
+}

src/main/java/ru/soune/nocopy/dto/file/AppealInfo.java

@@ -0,0 +1,14 @@
+package ru.soune.nocopy.dto.file;
+
+import lombok.Builder;
+import lombok.Data;
+
+import java.time.LocalDateTime;
+
+@Data
+@Builder
+public class AppealInfo {
+    private String appealId;
+    private String status;
+    private LocalDateTime createdAt;
+}

src/main/java/ru/soune/nocopy/dto/file/AppealRequest.java

@@ -0,0 +1,12 @@
+package ru.soune.nocopy.dto.file;
+
+import lombok.Builder;
+import lombok.Data;
+
+@Data
+@Builder
+public class AppealRequest {
+    private String fileId;
+    private String appealReason;
+    private String additionalInfo;
+}