fix type GF_AUTH

Dockerfile

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

build.gradle

@@ -28,20 +28,12 @@ dependencies {
 	implementation 'org.springframework.boot:spring-boot-starter-validation'
 	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'
-
-	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'

docker-compose.yaml

@@ -1,93 +1,37 @@
 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
-
   db:
     image: postgres:17
     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_SHARED_BUFFERS: 512MB
-      POSTGRES_EFFECTIVE_CACHE_SIZE: 1536MB
     ports:
       - "54320:5432"
     volumes:
       - pgdata:/var/lib/postgresql/data
     container_name: postgres
-    networks:
-      app-network:
-        aliases:
-          - database
 
   app:
-    build: .
+#    image: popovtsev/ncp
-    container_name: app-backend
+    build:  .
-    deploy:
+    container_name: no_copy_app
-      resources:
-        limits:
-          cpus: '1.5'
-          memory: 1G
-        reservations:
-          cpus: '0.5'
-          memory: 512M
     environment:
-      FILE_STORAGE_PATH: /data/uploads
-      MAX_FILE_SIZE: 10737418240
-      FILE_CHUNK_SIZE: 1048576
       POSTGRES_DB: no_copy_
       POSTGRES_USER: postgres
       POSTGRES_PASSWORD: postgres
       POSTGRES_PORT: 5432
       POSTGRES_HOST: db
-      STORAGE_SERVICE_URL: http://storage:8081
     depends_on:
       - db
     ports:
-      - "80:8080"
+      - "8080:8080"
-    networks:
-      app-network:
-        aliases:
-          - app
-          - backend
-          - api
-    volumes:
-      - uploads_data:/data/uploads:rw
 
   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:
@@ -100,12 +44,10 @@ services:
       alloy:
         condition: service_started
     environment:
-      GF_AUTH_ANONYMOUS_ENABLED: "true"
+      GF_AUTH_ANONYMOUS_ENABLED: true
       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
@@ -114,96 +56,51 @@ services:
       interval: 10s
       timeout: 5s
       retries: 10
-    networks:
-      - app-network
 
   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'  # Удерживать 15 дней
-      - '--web.enable-lifecycle'
     healthcheck:
       test: [ "CMD", "wget", "--spider", "http://localhost:9090/-/healthy" ]
       interval: 10s
       timeout: 5s
       retries: 5
-    networks:
-      - app-network
 
   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
       timeout: 5s
       retries: 5
-    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
       - tempo_data:/var/tempo
     ports:
       - "3200:3200"
-    networks:
-      - app-network
 
   alloy:
     image: grafana/alloy:latest
     container_name: alloy
-    deploy:
-      resources:
-        limits:
-          cpus: '0.5'
-          memory: 256M
-        reservations:
-          memory: 128M
     user: root
     ports:
-      - "9080:9080"
+      - "9080:9080" # HTTP interface
-      - "4317:4317"
+      - "4317:4317" # OTLP gRPC
-      - "4318:4318"
+      - "4318:4318" # OTLP http
     volumes:
       - ./infrastructure/alloy/config.alloy:/etc/alloy/config.alloy:ro
       - /var/lib/docker/containers:/var/lib/docker/containers:ro
@@ -216,8 +113,6 @@ services:
       - --server.http.listen-addr=0.0.0.0:9080
       - --storage.path=/var/lib/alloy/data
       - /etc/alloy/config.alloy
-    networks:
-      - app-network
 
 volumes:
   pgdata:
@@ -226,11 +121,4 @@ volumes:
   loki_data:
   loki_chunks:
   loki_index:
-  loki_rules:
+  loki_rules:
-  uploads_data:
-  prometheus_data:
-
-networks:
-  app-network:
-    external: true
-    driver: bridge

infrastructure/jenkins/deploy-back-with-network.groovy

@@ -0,0 +1,218 @@
+pipeline {
+    agent any
+
+    parameters {
+        string(
+                name: 'BRANCH',
+                defaultValue: 'dev',
+                description: 'Ветка для деплоя'
+        )
+
+        string(
+                name: 'SERVER',
+                defaultValue: '92.242.61.23',
+                description: 'Сервер для деплоя'
+        )
+    }
+
+    stages {
+        stage('Git pull') {
+            steps {
+                script {
+                    checkout([
+                            $class: 'GitSCM',
+                            branches: [[name: params.BRANCH]],
+                            userRemoteConfigs: [[
+                                                        url: 'https://code.3err0.ru/backdev/no-copy.git',
+                                                        credentialsId: 'nx-jen'
+                                                ]]
+                    ])
+                }
+            }
+        }
+
+        stage('Stop old container') {
+            steps {
+                script {
+                    withCredentials([
+                            usernamePassword(
+                                    credentialsId: 'server-root-password',
+                                    usernameVariable: 'SSH_USER',
+                                    passwordVariable: 'SSH_PASS'
+                            )
+                    ]) {
+                        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"
+                            "
+                        """
+                    }
+                }
+            }
+        }
+
+        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"
+                        """
+                    }
+                }
+            }
+        }
+
+        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'
+                            "
+                        """
+                    }
+                }
+            }
+        }
+
+        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'
+                            "
+                        """
+                    }
+                }
+            }
+        }
+    }
+
+    post {
+        success {
+            echo "Deploy branch ${params.BRANCH} completed"
+            echo "App : http://$SERVER:80"
+        }
+        failure {
+            echo "Deploy failed"
+        }
+    }
+}

infrastructure/jenkins/deploy-front.groovy

@@ -1,186 +0,0 @@
-pipeline {
-    agent any
-
-    parameters {
-        string(
-                name: 'BRANCH',
-                defaultValue: 'main',
-                description: 'Ветка для деплоя'
-        )
-    }
-
-    stages {
-        stage('Git pull') {
-            steps {
-                script {
-                    checkout([
-                            $class: 'GitSCM',
-                            branches: [[name: params.BRANCH]],
-                            userRemoteConfigs: [[
-                                                        url: 'https://code.3err0.ru/frontdev/no-copy-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-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
-                            "
-                        """
-                    }
-                }
-            }
-        }
-
-        stage('Copy to 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 "
-                                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}/
-                        """
-                    }
-                }
-            }
-        }
-
-        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/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: docker-compose file not found'
-                                    exit 1
-                                fi
-                            "
-                        """
-                    }
-                }
-            }
-        }
-
-        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 "
-                                cd /opt/deployments/frontend/${params.BRANCH}
-                                
-                                # Проверяем и подключаем к сети app-network если нужно
-                                docker network inspect app-network 2>/dev/null || echo 'Warning: app-network not found'
-                                
-                                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
-                            "
-                        """
-                    }
-                }
-            }
-        }
-
-        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-frontend'; then
-                                    echo 'Container started'
-                                    
-                                    sleep 5
-                                    
-                                    HTTP_CODE=\$(curl -s -o /dev/null -w '%{http_code}' http://localhost:2998 || echo '000')
-                                    echo 'HTTP code: \$HTTP_CODE'
-                                    
-                                    echo 'Frontend available on http://92.242.61.23:2998'
-                                else
-                                    echo 'Exception: container did not start'
-                                    docker ps -a | grep frontend
-                                    exit 1
-                                fi
-                            "
-                        """
-                    }
-                }
-            }
-        }
-    }
-
-    post {
-        success {
-            echo "Front branch ${params.BRANCH} deployment completed"
-            echo "Frontend available on http://92.242.61.23:2998"
-        }
-        failure {
-            echo "Deployment failed"
-        }
-    }
-}

infrastructure/jenkins/deploy.groovy

@@ -1,226 +0,0 @@
-pipeline {
-    agent any
-
-    parameters {
-        string(
-                name: 'BRANCH',
-                defaultValue: 'dev',
-                description: 'Ветка для деплоя'
-        )
-
-        string(
-                name: 'SERVER',
-                defaultValue: '92.242.61.23',
-                description: 'Сервер для деплоя'
-        )
-    }
-
-    stages {
-        stage('Git pull') {
-            steps {
-                script {
-                    checkout([
-                            $class: 'GitSCM',
-                            branches: [[name: params.BRANCH]],
-                            userRemoteConfigs: [[
-                                                        url: 'https://code.3err0.ru/backdev/no-copy.git',
-                                                        credentialsId: 'nx-jen'
-                                                ]]
-                    ])
-                }
-            }
-        }
-
-        stage('Deploy with docker-compose') {
-            steps {
-                script {
-                    withCredentials([
-                            usernamePassword(
-                                    credentialsId: 'server-root-password',
-                                    usernameVariable: 'SSH_USER',
-                                    passwordVariable: 'SSH_PASS'
-                            )
-                    ]) {
-                        sh """
-                            echo "Deploying branch: ${params.BRANCH}"
-                            
-                            echo "Copying files to server..."
-                            sshpass -p '$SSH_PASS' ssh -o StrictHostKeyChecking=no $SSH_USER@$SERVER "mkdir -p /opt/deployments/${params.BRANCH}"
-                            sshpass -p '$SSH_PASS' scp -r -o StrictHostKeyChecking=no ./* $SSH_USER@$SERVER:/opt/deployments/${params.BRANCH}/
-                            
-                            sshpass -p '$SSH_PASS' ssh -o StrictHostKeyChecking=no $SSH_USER@$SERVER "
-                                cd /opt/deployments/${params.BRANCH}
-                                
-                                echo '========================================'
-                                echo 'Step 1: Checking current state...'
-                                echo '========================================'
-                                
-                                docker ps --filter 'name=postgres|app-backend|storage|grafana|prometheus|loki|tempo|alloy' --format 'table {{.Names}}\\t{{.Image}}\\t{{.Status}}'
-                                
-                                echo '========================================'
-                                echo 'Step 2: Setup environment for compatibility...'
-                                echo '========================================'
-                                
-                                docker network create app-network 2>/dev/null || echo 'Network app-network already exists'
-                                
-                                echo 'COMPOSE_COMPATIBILITY=true' > .env
-                                
-                                echo '========================================'
-                                echo 'Step 3: Force cleanup old application...'
-                                echo '========================================'
-                                
-                                docker-compose --compatibility down 2>/dev/null || echo 'No previous compose stack'
-                                
-                                docker images --filter 'reference=*app-backend*' -q | xargs -r docker rmi -f 2>/dev/null || echo 'No images to remove'
-                                
-                                echo '========================================'
-                                echo 'Step 4: Verify files and fix compose...'
-                                echo '========================================'
-                                
-                                if [ ! -f docker-compose.yaml ]; then
-                                    echo 'ERROR: docker-compose.yaml not found!'
-                                    ls -la
-                                    exit 1
-                                fi
-                                
-                                echo 'Checking docker-compose.yaml syntax...'
-                                docker-compose --compatibility config 2>&1 | head -20 || echo 'Config check output'
-                                
-                                echo '========================================'
-                                echo 'Step 5: Start infrastructure services...'
-                                echo '========================================'
-                                
-                                echo 'Starting PostgreSQL with resource limits...'
-                                docker-compose --compatibility up -d db
-                                
-                                echo 'Starting storage service...'
-                                docker-compose --compatibility up -d storage
-                                
-                                echo 'Waiting for PostgreSQL to be ready...'
-                                for i in {1..30}; do
-                                    if docker-compose --compatibility exec db pg_isready -U postgres 2>/dev/null; then
-                                        echo 'PostgreSQL is ready'
-                                        break
-                                    fi
-                                    echo 'Waiting... attempt ' \$i
-                                    sleep 2
-                                done
-                                
-                                echo '========================================'
-                                echo 'Step 6: Build application image...'
-                                echo '========================================'
-                                
-                                if [ ! -f Dockerfile ]; then
-                                    echo 'ERROR: Dockerfile not found!'
-                                    exit 1
-                                fi
-                                
-                                echo 'Building Docker image...'
-                                docker build --no-cache -t app-backend:latest . 2>&1 | tail -30
-                                
-                                echo 'Image created successfully'
-                                docker images app-backend:latest --format 'table {{.Repository}}\\t{{.Tag}}\\t{{.Size}}\\t{{.CreatedAt}}'
-                                
-                                echo '========================================'
-                                echo 'Step 7: Start application with resource limits...'
-                                echo '========================================'
-                                
-                                docker volume create uploads_data 2>/dev/null || echo 'Volume uploads_data already exists'
-                                
-                                echo 'Starting main application...'
-                                docker-compose --compatibility up -d app
-                                
-                                echo 'Waiting for application to start...'
-                                sleep 15
-                                
-                                echo '========================================'
-                                echo 'Step 8: Start monitoring stack...'
-                                echo '========================================'
-                                
-                                docker-compose --compatibility up -d grafana prometheus loki tempo alloy
-                                
-                                echo '========================================'
-                                echo 'Step 9: Verify deployment...'
-                                echo '========================================'
-                                
-                                echo 'All containers status:'
-                                docker-compose --compatibility ps
-                                
-                                echo ''
-                                echo 'Resource limits check:'
-                                echo 'App backend limits:'
-                                docker inspect app-backend --format='{{.HostConfig.Memory}} {{.HostConfig.CpuQuota}} {{.HostConfig.CpuPeriod}}' 2>/dev/null || echo 'Cannot inspect'
-                                
-                                echo ''
-                                echo 'PostgreSQL limits:'
-                                docker inspect postgres --format='{{.HostConfig.Memory}} {{.HostConfig.CpuQuota}} {{.HostConfig.CpuPeriod}}' 2>/dev/null || echo 'Cannot inspect'
-                                
-                                echo ''
-                                echo 'Container resource usage:'
-                                docker stats --no-stream --format 'table {{.Name}}\\t{{.CPUPerc}}\\t{{.MemUsage}}\\t{{.MemPerc}}' postgres app-backend storage 2>/dev/null || echo 'Stats not available'
-                                
-                                echo '========================================'
-                                echo 'Step 10: Health checks...'
-                                echo '========================================'
-                                
-                                echo 'Application health check...'
-                                for i in {1..10}; do
-                                    if curl -s -f http://localhost:80/health 2>/dev/null; then
-                                        echo '✓ Application health check PASSED'
-                                        break
-                                    elif [ \$i -eq 10 ]; then
-                                        echo '✗ Application health check FAILED'
-                                        echo 'Last logs:'
-                                        docker-compose --compatibility logs --tail=20 app
-                                    else
-                                        echo 'Waiting for application... attempt ' \$i
-                                        sleep 5
-                                    fi
-                                done
-                                
-                                echo 'Checking monitoring services...'
-                                if curl -s -f http://localhost:3000/api/health 2>/dev/null; then
-                                    echo '✓ Grafana is healthy'
-                                else
-                                    echo '⚠ Grafana may be starting'
-                                fi
-                                
-                                if curl -s -f http://localhost:9090/-/healthy 2>/dev/null; then
-                                    echo '✓ Prometheus is healthy'
-                                fi
-                                
-                                echo '========================================'
-                                echo 'Deployment Summary:'
-                                echo '========================================'
-                                echo 'Application URL: http://${params.SERVER}:80'
-                                echo 'Grafana: http://${params.SERVER}:3000 (admin/admin)'
-                                echo 'Prometheus: http://${params.SERVER}:9090'
-                                echo 'Loki: http://${params.SERVER}:3100'
-                                echo ''
-                                echo 'To view logs: docker-compose logs -f app'
-                                echo 'To view all containers: docker-compose ps'
-                                echo 'To stop: docker-compose down'
-                                echo '========================================'
-                            "
-                        """
-                    }
-                }
-            }
-        }
-    }
-
-    post {
-        success {
-            echo "Deployment successful"
-            echo "Application URL: http://${params.SERVER}:80"
-            echo "Grafana: http://${params.SERVER}:3000"
-            echo "Prometheus: http://${params.SERVER}:9090"
-        }
-        failure {
-            echo "Deployment failed for branch ${params.BRANCH}"
-        }
-        always {
-            echo "Deployment process finished"
-        }
-    }
-}

infrastructure/jenkins/dp-wtith-branch.groovy

@@ -1,183 +0,0 @@
-pipeline {
-    agent any
-
-    parameters {
-        string(
-                name: 'BRANCH',
-                defaultValue: 'main',
-                description: 'Ветка для деплоя'
-        )
-    }
-
-    stages {
-        stage('Git pull') {
-            steps {
-                script {
-                    checkout([
-                            $class: 'GitSCM',
-                            branches: [[name: params.BRANCH]],
-                            userRemoteConfigs: [[
-                                                        url: 'https://code.3err0.ru/frontdev/no-copy-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-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
-                            "
-                        """
-                    }
-                }
-            }
-        }
-
-        stage('Copy to 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 "
-                                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}/
-                        """
-                    }
-                }
-            }
-        }
-
-        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/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
-                            "
-                        """
-                    }
-                }
-            }
-        }
-
-        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 "
-                                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
-                            "
-                        """
-                    }
-                }
-            }
-        }
-
-        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-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
-                            "
-                        """
-                    }
-                }
-            }
-        }
-    }
-
-    post {
-        success {
-            echo "Front branch ${params.BRANCH} completed"
-            echo "Use on http://92.242.61.23:2998"
-        }
-        failure {
-            echo "Failed"
-        }
-    }
-}

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

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

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

@@ -1,4 +1,4 @@
-package ru.soune.nocopy.configuration;
+package ru.soune.no_copy.configuration;
 
 import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
 import org.springframework.context.annotation.Bean;

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

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

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

@@ -0,0 +1,47 @@
+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.service.AuthService;
+
+import java.util.Map;
+
+@RestController
+@RequestMapping("/api/auth")
+@RequiredArgsConstructor
+public class AuthController {
+
+    private final AuthService authService;
+
+    @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 ", "");
+
+        authService.logout(token);
+
+        return ResponseEntity.ok(Map.of("success", true));
+    }
+}

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

@@ -0,0 +1,28 @@
+package ru.soune.no_copy.controller;
+
+import lombok.RequiredArgsConstructor;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+import ru.soune.no_copy.dto.UserDTO;
+import ru.soune.no_copy.repository.UserRepository;
+
+import java.util.List;
+
+@RestController
+@RequestMapping("/api/user")
+@RequiredArgsConstructor
+public class UserController {
+
+    private final UserRepository userRepository;
+
+    @GetMapping("/all")
+    public ResponseEntity<List<UserDTO>> getAllUsers() {
+        List<UserDTO> allUsers = userRepository.findAll().stream()
+                .map(u -> new UserDTO(u.getFirstName(), u.getEmail(), u.getIsActive()))
+                .toList();
+
+        return ResponseEntity.ok(allUsers);
+    }
+}

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

@@ -0,0 +1,5 @@
+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/LoginRequest.java

@@ -1,15 +1,13 @@
-package ru.soune.nocopy.dto;
+package ru.soune.no_copy.dto;
 
 import jakarta.validation.constraints.Email;
 import jakarta.validation.constraints.NotBlank;
 import jakarta.validation.constraints.Size;
 import lombok.AllArgsConstructor;
 import lombok.Data;
-import lombok.NoArgsConstructor;
 
 @Data
 @AllArgsConstructor
-@NoArgsConstructor
 public class LoginRequest {
 
     @NotBlank(message = "error.not.blank") @Email(message = "error.not.email") @Size(max = 128)

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

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

@@ -0,0 +1,13 @@
+package ru.soune.no_copy.dto;
+
+import jakarta.validation.constraints.Email;
+import jakarta.validation.constraints.NotBlank;
+import jakarta.validation.constraints.Size;
+
+public record RegisterRequest(
+        @NotBlank(message = "error.name.length") @Size(min = 2, max = 64) String firstName,
+        @NotBlank(message = "error.name.length") @Size(min = 2, max = 64) String secondName,
+        @NotBlank(message = "error.name.length") @Size(min = 2, max = 64) String lastName,
+        @NotBlank(message = "error.not.blank") @Email(message = "error.not.email") @Size(max = 128) String email,
+        @NotBlank(message = "error.not.blank") @Size(min = 8) String password
+) {}

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

@@ -0,0 +1,12 @@
+package ru.soune.no_copy.dto;
+
+import lombok.AllArgsConstructor;
+import lombok.Data;
+
+@Data
+@AllArgsConstructor
+public class UserDTO {
+    private String fullName;
+    private String email;
+    private boolean isActive;
+}

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

@@ -1,49 +1,37 @@
-package ru.soune.nocopy.entity.auth;
+package ru.soune.no_copy.entity;
 
 import jakarta.persistence.*;
-import lombok.*;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
 import org.springframework.data.annotation.CreatedDate;
 import org.springframework.data.jpa.domain.support.AuditingEntityListener;
-import ru.soune.nocopy.entity.User;
 
 import java.time.LocalDateTime;
 
 @Entity
-@Table(name = "auth_tokens")
+@NoArgsConstructor
 @Getter
 @Setter
-@NoArgsConstructor
-@AllArgsConstructor
-@ToString
 @EntityListeners(AuditingEntityListener.class)
+@Table(name = "auth_tokens")
 public class AuthToken {
 
     @Id
     @GeneratedValue(strategy = GenerationType.IDENTITY)
-    private Long tokenId;
+    private Long id;
-
-    @ManyToOne(fetch = FetchType.LAZY)
-    @JoinColumn(name = "user_id", nullable = false)
-    @ToString.Exclude
-    private User user;
 
     @Column(nullable = false, unique = true, length = 64)
     private String token;
 
     @Column(name = "expires_at", nullable = false)
-    private LocalDateTime expiresAt = LocalDateTime.now().plusHours(1);
+    private LocalDateTime expiresAt = LocalDateTime.now().plusDays(30);
 
     @CreatedDate
     @Column(name = "created_at", updatable = false, nullable = false)
     private LocalDateTime createdAt;
 
-    @Column(name = "last_used_at")
+    @ManyToOne(fetch = FetchType.LAZY)
-    private LocalDateTime lastUsedAt;
+    @JoinColumn(name = "user_id", nullable = false)
-
+    private User user;
-    @Column(name = "is_active")
-    private Boolean isActive = true;
-
-    public boolean isValid() {
-        return Boolean.TRUE.equals(isActive) && expiresAt.isAfter(LocalDateTime.now());
-    }
 }

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

@@ -0,0 +1,58 @@
+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.LocalDateTime;
+import java.util.ArrayList;
+import java.util.List;
+
+@Entity
+@AllArgsConstructor
+@NoArgsConstructor
+@ToString
+@EqualsAndHashCode
+@Getter @Setter
+@EntityListeners(AuditingEntityListener.class)
+@Table(name = "users")
+public class User {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long userId;
+
+    @Size(max = 64)
+    @Column(name = "firstName", nullable = false, length = 64)
+    private String firstName;
+
+    @Size(max = 64)
+    @Column(name = "lastName", nullable = false, length = 64)
+    private String lastName;
+
+    @Size(max = 64)
+    @Column(name = "secondName", length = 64)
+    private String secondName;
+
+    @Size(max = 1024)
+    @Column(name = "email", nullable = false, length = 1024, unique = true)
+    private String email;
+
+    @Column(nullable = false)
+    @JsonIgnore
+    private String password;
+
+    @OneToMany(mappedBy = "user", cascade = CascadeType.ALL, orphanRemoval = true)
+    private List<AuthToken> tokens = new ArrayList<>();
+
+    @CreatedDate
+    @Column(name = "created_at", updatable = false, nullable = false)
+    private LocalDateTime createdAt;
+
+    @Column(name = "is_active")
+    private Boolean isActive = true;
+
+}

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

@@ -1,4 +1,4 @@
-package ru.soune.nocopy.exception;
+package ru.soune.no_copy.exception;
 
 public class NotValidationPasswordException extends RuntimeException {
     public NotValidationPasswordException(String message) {

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

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

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

@@ -1,4 +1,4 @@
-package ru.soune.nocopy.exception;
+package ru.soune.no_copy.exception;
 
 public class UserNotFoundException extends RuntimeException {
     public UserNotFoundException(String message) {

src/main/java/ru/soune/no_copy/handler/GlobalExceptionHandler.java

@@ -1,4 +1,4 @@
-package ru.soune.nocopy.handler;
+package ru.soune.no_copy.handler;
 
 import lombok.AllArgsConstructor;
 import org.springframework.context.support.DefaultMessageSourceResolvable;
@@ -8,7 +8,9 @@ import org.springframework.web.bind.MethodArgumentNotValidException;
 import org.springframework.web.bind.annotation.ExceptionHandler;
 import org.springframework.web.bind.annotation.ResponseStatus;
 import org.springframework.web.bind.annotation.RestControllerAdvice;
-import ru.soune.nocopy.exception.*;
+import ru.soune.no_copy.exception.NotValidationPasswordException;
+import ru.soune.no_copy.exception.UserAlreadyExistsException;
+import ru.soune.no_copy.exception.UserNotFoundException;
 
 import java.util.Map;
 
@@ -29,18 +31,9 @@ public class GlobalExceptionHandler {
                         "message" ,message));
     }
 
-    @ExceptionHandler(NotValidFieldException.class)
+    @ExceptionHandler(UserAlreadyExistsException.class)
-    @ResponseStatus(HttpStatus.OK)
+    @ResponseStatus(HttpStatus.CONFLICT)
-    public ResponseEntity<?> handleUserContainsException(NotValidFieldException ex) {
+    public ResponseEntity<?> handleUserContainsException(UserAlreadyExistsException ex) {
-
-        return ResponseEntity
-                .ok()
-                .body(ex.getBaseResponse());
-    }
-
-    @ExceptionHandler(UserNotFoundException.class)
-    @ResponseStatus(HttpStatus.NOT_FOUND)
-    public ResponseEntity<?> handleUserNotFoundException(UserNotFoundException ex) {
         return ResponseEntity.
                 badRequest()
                 .body(Map.of(
@@ -49,9 +42,9 @@ public class GlobalExceptionHandler {
                 ));
     }
 
-    @ExceptionHandler(ContentNotFoundException.class)
+    @ExceptionHandler(UserNotFoundException.class)
     @ResponseStatus(HttpStatus.NOT_FOUND)
-    public ResponseEntity<?> handleUserNotFoundException(ContentNotFoundException ex) {
+    public ResponseEntity<?> handleUserNotFoundException(UserNotFoundException ex) {
         return ResponseEntity.
                 badRequest()
                 .body(Map.of(
@@ -70,15 +63,4 @@ public class GlobalExceptionHandler {
                         "message" ,ex.getMessage()
                 ));
     }
-
-    @ExceptionHandler(TokenNotFoundException.class)
-    @ResponseStatus(HttpStatus.NOT_FOUND)
-    public ResponseEntity<?> handleNotFoundTokenException(TokenNotFoundException ex) {
-        return ResponseEntity.
-                badRequest()
-                .body(Map.of(
-                        "success", false,
-                        "message" ,ex.getMessage()
-                ));
-    }
 }

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

@@ -1,8 +1,8 @@
-package ru.soune.nocopy.repository;
+package ru.soune.no_copy.repository;
 
 import org.springframework.data.jpa.repository.JpaRepository;
 import org.springframework.stereotype.Repository;
-import ru.soune.nocopy.entity.auth.AuthToken;
+import ru.soune.no_copy.entity.AuthToken;
 
 import java.time.LocalDate;
 import java.util.Optional;

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

@@ -0,0 +1,12 @@
+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,22 +1,23 @@
-package ru.soune.nocopy.service;
+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.nocopy.dto.*;
+import ru.soune.no_copy.dto.LoginRequest;
-import ru.soune.nocopy.entity.auth.AuthToken;
+import ru.soune.no_copy.dto.RegisterRequest;
-import ru.soune.nocopy.entity.User;
+import ru.soune.no_copy.entity.AuthToken;
-import ru.soune.nocopy.exception.NotValidFieldException;
+import ru.soune.no_copy.entity.User;
-import ru.soune.nocopy.repository.AuthTokenRepository;
+import ru.soune.no_copy.exception.NotValidationPasswordException;
-import ru.soune.nocopy.repository.UserRepository;
+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.Arrays;
 import java.util.Base64;
-import java.util.Map;
+import java.util.Locale;
 import java.util.Optional;
 
 @Service
@@ -34,19 +35,18 @@ public class AuthService {
     private final SecureRandom secureRandom = new SecureRandom();
 
     @Transactional
-    public AuthToken register(RegRequest registerRequest) {
+    public AuthToken register(RegisterRequest registerRequest) {
+        if (userRepository.existsByEmail(registerRequest.email())) {
+            throw new UserAlreadyExistsException(messageSource.getMessage("error.user.exists", null,
+                    Locale.getDefault()));
+        }
+
         User user = new User();
-        user.setFullName(registerRequest.getFullName());
+        user.setFirstName(registerRequest.firstName());
-        user.setEmail(registerRequest.getEmail());
+        user.setSecondName(registerRequest.secondName());
-        user.setPassword(passwordEncoder.encode(registerRequest.getPassword()));
+        user.setLastName(registerRequest.lastName());
-
+        user.setEmail(registerRequest.email());
-        if (registerRequest.getCompanyName() != null) {
+        user.setPassword(passwordEncoder.encode(registerRequest.password()));
-            user.setCompany(registerRequest.getCompanyName());
-        }
-
-        if (registerRequest.getPhone() != null) {
-            user.setPhone(registerRequest.getPhone());
-        }
 
         User savedUser = userRepository.save(user);
 
@@ -60,47 +60,29 @@ public class AuthService {
     @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())) {
-            LoginAnswer loginAnswer = new LoginAnswer();
+            throw new NotValidationPasswordException("Invalid password");
-            loginAnswer.setFieldErrors(Arrays.asList(Map.of("password", request.getPassword())));
-
-            throw new NotValidFieldException("Invalid password", new BaseResponse(20003,
-                    MessageCode.AUTH_PASSWORD_NOT_MATCHES.getCode(),
-                    MessageCode.AUTH_PASSWORD_NOT_MATCHES.getDescription(), loginAnswer));
         }
 
-        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);
-    }
-
-    @Transactional
-    public AuthToken createTokenForUser(User user) {
         AuthToken authToken = new AuthToken();
         authToken.setToken(generateAuthToken());
         authToken.setUser(user);
-        authToken.setExpiresAt(LocalDateTime.now().plusHours(1));
-        authToken.setIsActive(true);
-
-        user.setLastLoginAt(LocalDateTime.now());
-        userRepository.save(user);
 
         return authTokenRepository.save(authToken);
     }
 
+    public void logout(String token) {
+        authTokenRepository.findByToken(token)
+                .ifPresent(authTokenRepository::delete);
+    }
+
     private String generateAuthToken() {
         byte[] bytes = new byte[32];
         secureRandom.nextBytes(bytes);

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

@@ -1,30 +0,0 @@
-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 {
-
-    @Bean
-    public Map<Integer, RequestHandler> handlers(
-            RegRequestHandler reg,
-            LoginRequestHandler login,
-            FileUploadHandler upload,
-            FileEntityHandler file,
-            LogoutRequestHandler logoutHandler
-    ) {
-        Map<Integer, RequestHandler> map = new HashMap<>();
-        map.put(20001, login);
-        map.put(20002, reg);
-        map.put(20004, upload);
-        map.put(20005, file);
-        map.put(20006, logoutHandler);
-
-        return map;
-    }
-}

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

@@ -1,41 +0,0 @@
-package ru.soune.nocopy.configuration;
-
-import com.fasterxml.jackson.databind.ObjectMapper;
-import com.fasterxml.jackson.databind.SerializationFeature;
-import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule;
-import com.fasterxml.jackson.datatype.jsr310.deser.LocalDateDeserializer;
-import com.fasterxml.jackson.datatype.jsr310.ser.LocalDateSerializer;
-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 java.time.LocalDate;
-import java.time.LocalDateTime;
-import java.time.format.DateTimeFormatter;
-
-@Configuration
-public class JacksonConfig {
-
-    @Bean
-    @Primary
-    public ObjectMapper objectMapper() {
-        ObjectMapper mapper = new ObjectMapper();
-
-        JavaTimeModule javaTimeModule = new JavaTimeModule();
-
-        javaTimeModule.addSerializer(LocalDate.class, new LocalDateSerializer(
-                DateTimeFormatter.ofPattern("dd-MM-yyyy")));
-
-        javaTimeModule.addDeserializer(LocalDate.class, new LocalDateDeserializer(
-                DateTimeFormatter.ofPattern("dd-MM-yyyy")));
-
-        javaTimeModule.addSerializer(LocalDateTime.class, new LocalDateTimeSerializer(
-                DateTimeFormatter.ofPattern("dd-MM-yyyy HH:mm:ss")));
-
-        mapper.registerModule(javaTimeModule);
-        mapper.disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS);
-
-        return mapper;
-    }
-}

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

@@ -1,35 +0,0 @@
-package ru.soune.nocopy.configuration;
-
-import lombok.Getter;
-import org.springframework.boot.context.properties.ConfigurationProperties;
-import org.springframework.stereotype.Component;
-
-import java.util.Map;
-
-@Component
-@ConfigurationProperties(prefix = "subscription")
-@Getter
-public class SubscriptionConfig {
-
-    private final Map<SubscriptionType, SubscriptionLimits> limits = Map.of(
-            SubscriptionType.START, new SubscriptionLimits(50, 5.0),
-            SubscriptionType.BASIC, new SubscriptionLimits(200, 20.0),
-            SubscriptionType.PRO, new SubscriptionLimits(1000, 100.0),
-            SubscriptionType.ENTERPRISE, new SubscriptionLimits(-1, 500.0)
-    );
-
-    @Getter
-    public static class SubscriptionLimits {
-        private final int monthlyFiles;
-        private final double storageGB;
-
-        public SubscriptionLimits(int monthlyFiles, double storageGB) {
-            this.monthlyFiles = monthlyFiles;
-            this.storageGB = storageGB;
-        }
-    }
-
-    public enum SubscriptionType {
-        START, BASIC, PRO, ENTERPRISE
-    }
-}

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

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

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

@@ -1,389 +0,0 @@
-package ru.soune.nocopy.controller;
-
-import lombok.RequiredArgsConstructor;
-import lombok.extern.slf4j.Slf4j;
-import org.springframework.core.io.Resource;
-import org.springframework.core.io.UrlResource;
-import org.springframework.http.HttpHeaders;
-import org.springframework.http.MediaType;
-import org.springframework.http.ResponseEntity;
-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.RegAnswer;
-import ru.soune.nocopy.dto.file.ChunkUploadResponse;
-import ru.soune.nocopy.dto.file.CompleteUploadResponse;
-import ru.soune.nocopy.dto.file.FileEntityResponse;
-import ru.soune.nocopy.dto.file.UploadProgress;
-import ru.soune.nocopy.entity.auth.AuthToken;
-import ru.soune.nocopy.entity.file.FileStatus;
-import ru.soune.nocopy.entity.file.UploadStatus;
-import ru.soune.nocopy.exception.*;
-import ru.soune.nocopy.handler.*;
-import ru.soune.nocopy.repository.AuthTokenRepository;
-import ru.soune.nocopy.service.file.FileEntityService;
-import ru.soune.nocopy.service.file.FileUploadService;
-
-import java.io.IOException;
-import java.nio.file.Files;
-import java.nio.file.Path;
-import java.nio.file.Paths;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-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 FileEntityService fileEntityService;
-
-    private final AuthTokenRepository authTokenRepository;
-
-    @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 (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("/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) {
-        try {
-            if (chunk == null || chunk.isEmpty()) {
-                return ResponseEntity.ok().body(new BaseResponse(20004, MessageCode.FILE_UPLOAD_ERROR.getCode(),
-                        "Chunk file null or empty", ChunkUploadResponse.builder()
-                        .uploadId(uploadId)
-                        .chunkNumber(chunkNumber)
-                        .build()));
-            }
-
-            if (uploadId == null || uploadId.isBlank()) {
-                return ResponseEntity.ok().body(new BaseResponse(20004, MessageCode.FILE_UPLOAD_ERROR.getCode(),
-                        "Upload ID is required", ChunkUploadResponse.builder()
-                        .uploadId(uploadId)
-                        .chunkNumber(chunkNumber)
-                        .build()));
-            }
-
-            if (chunkNumber == null || chunkNumber < 0) {
-                return ResponseEntity.ok().body(new BaseResponse(20004, MessageCode.FILE_UPLOAD_ERROR.getCode(),
-                        "Valid chunk number is required", ChunkUploadResponse.builder()
-                        .uploadId(uploadId)
-                        .chunkNumber(chunkNumber)
-                        .build()));
-            }
-
-            fileUploadService.uploadChunk(uploadId, chunkNumber, chunk);
-
-            ChunkUploadResponse responseBody = ChunkUploadResponse.builder()
-                    .uploadId(uploadId)
-                    .chunkNumber(chunkNumber)
-                    .chunkSize(chunk.getSize())
-                    .message("Chunk uploaded successfully")
-                    .build();
-
-            return ResponseEntity.ok().body(new BaseResponse(20004, MessageCode.SUCCESS.getCode(),
-                    "Chunk uploaded successfully", responseBody));
-        } catch (Exception e) {
-            log.error("Error uploading chunk", e);
-
-            ChunkUploadResponse responseBody = ChunkUploadResponse.builder()
-                    .uploadId(uploadId)
-                    .chunkNumber(chunkNumber)
-                    .build();
-
-            return ResponseEntity.ok().body(new BaseResponse(
-                    20004, MessageCode.FILE_UPLOAD_ERROR.getCode(),
-                    "Failed to upload chunk: " + e.getMessage(), responseBody));
-        }
-    }
-
-    @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/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) {
-                Map<String, Object> errorData = new HashMap<>();
-                errorData.put("token", tokenHeader);
-                errorData.put("fileId", fileId);
-                errorData.put("version", version);
-
-                return ResponseEntity.ok().body(new BaseResponse(20004,
-                        MessageCode.FILE_DOWNLOAD_ERROR_NOT_CORRECT_FIELD.getCode(),
-                        MessageCode.FILE_DOWNLOAD_ERROR_NOT_CORRECT_FIELD.getDescription(),
-                        errorData));
-            }
-
-            Long userId = getUserIdFromToken(tokenHeader);
-            FileEntityResponse entityResponse = fileEntityService.getById(fileId, version);
-
-            if (!entityResponse.getUserId().equals(userId)) {
-                Map<String, Object> errorData = new HashMap<>();
-                errorData.put("token", tokenHeader);
-
-                return ResponseEntity.ok().body(new BaseResponse(20004,
-                        MessageCode.FILE_DOWNLOAD_ERROR.getCode(),
-                        MessageCode.FILE_DOWNLOAD_ERROR.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_DOWNLOAD_ERROR.getCode(),
-                        MessageCode.FILE_DOWNLOAD_ERROR.getDescription(),
-                        errorData));
-            }
-
-            if (!entityResponse.isExistsOnDisk()) {
-                Map<String, Object> errorData = new HashMap<>();
-                errorData.put("onDisk", entityResponse.isExistsOnDisk());
-
-                return ResponseEntity.ok().body(new BaseResponse(20004,
-                        MessageCode.FILE_DOWNLOAD_ERROR.getCode(),
-                        MessageCode.FILE_DOWNLOAD_ERROR.getDescription(),
-                        errorData));
-            }
-
-            Path filePath = Paths.get(entityResponse.getFilePath());
-            Resource resource = new UrlResource(filePath.toUri());
-
-            if (!resource.exists()) {
-                Map<String, Object> errorData = new HashMap<>();
-                errorData.put("resource", resource.exists());
-
-                return ResponseEntity.ok().body(new BaseResponse(20004,
-                        MessageCode.FILE_DOWNLOAD_ERROR.getCode(),
-                        MessageCode.FILE_DOWNLOAD_ERROR.getDescription(),
-                        errorData));
-            }
-
-            String contentType = determineContentType(filePath);
-
-            return ResponseEntity.ok()
-                    .contentType(MediaType.parseMediaType(contentType))
-                    .header(HttpHeaders.CONTENT_DISPOSITION,
-                            "attachment; filename=\"" + entityResponse.getOriginalFileName() + "\"")
-                    .header(HttpHeaders.CONTENT_LENGTH, String.valueOf(entityResponse.getFileSize()))
-                    .body(resource);
-        } 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 | IOException e) {
-            Map<String, Object> errorData = new HashMap<>();
-            errorData.put("token", tokenHeader);
-            errorData.put("fileId", fileId);
-            errorData.put("version", version);
-
-            return ResponseEntity.ok().body(new BaseResponse(20004,
-                    MessageCode.FILE_DOWNLOAD_ERROR_NOT_CORRECT_FIELD.getCode(),
-                    MessageCode.FILE_DOWNLOAD_ERROR_NOT_CORRECT_FIELD.getDescription(),
-                    errorData));
-        }
-    }
-
-    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 String determineContentType(Path filePath) throws IOException {
-        String contentType = Files.probeContentType(filePath);
-        if (contentType == null) {
-            contentType = "application/octet-stream";
-        }
-        return contentType;
-    }
-
-    private boolean isPreviewSupported(String mimeType) {
-        if (mimeType == null) {
-            return false;
-        }
-
-        return mimeType.startsWith("image") ||
-                mimeType.startsWith("text") ||
-                mimeType.equals("pdf") ||
-                mimeType.startsWith("video") ||
-                mimeType.startsWith("audio");
-    }
-
-    private Long getUserIdFromToken(String tokenHeader) {
-        String token = tokenHeader.replace("Bearer ", "");
-        AuthToken authToken = authTokenRepository.findByToken(token)
-                .orElseThrow(() -> new NotFoundAuthToken("Token not found"));
-        return authToken.getUser().getId();
-    }
-}

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

@@ -1,14 +0,0 @@
-package ru.soune.nocopy.controller;
-
-import org.springframework.http.HttpStatus;
-import org.springframework.web.bind.annotation.*;
-
-@RestController
-@RequestMapping("check/api")
-public class HealtCheckController {
-
-    @GetMapping("/healt")
-    public HttpStatus healtCheck() {
-        return HttpStatus.OK;
-    }
-}

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

@@ -1,11 +0,0 @@
-package ru.soune.nocopy.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/nocopy/controller/UserController.java

@@ -1,111 +0,0 @@
-package ru.soune.nocopy.controller;
-
-import lombok.RequiredArgsConstructor;
-import org.springframework.http.ResponseEntity;
-import org.springframework.web.bind.annotation.*;
-import ru.soune.nocopy.dto.ChangePasswordRequest;
-import ru.soune.nocopy.dto.UserDTO;
-import ru.soune.nocopy.dto.UserRequest;
-import ru.soune.nocopy.entity.auth.AuthToken;
-import ru.soune.nocopy.entity.User;
-import ru.soune.nocopy.exception.InvalidUserEmail;
-import ru.soune.nocopy.exception.NotFoundAuthToken;
-import ru.soune.nocopy.mapper.UserMapper;
-import ru.soune.nocopy.repository.AuthTokenRepository;
-import ru.soune.nocopy.repository.UserRepository;
-import ru.soune.nocopy.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/nocopy/controller/VkAuthController.java

@@ -1,93 +0,0 @@
-package ru.soune.nocopy.controller;
-
-import com.fasterxml.jackson.databind.ObjectMapper;
-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.BaseResponse;
-import ru.soune.nocopy.dto.LoginAnswer;
-import ru.soune.nocopy.dto.MessageCode;
-import ru.soune.nocopy.entity.User;
-import ru.soune.nocopy.entity.auth.AuthToken;
-import ru.soune.nocopy.service.AuthService;
-import ru.soune.nocopy.service.VkOAuthService;
-import ru.soune.nocopy.service.auth.ExternalAuthUserService;
-
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-
-@RestController
-@RequestMapping("/api")
-@RequiredArgsConstructor
-@Slf4j
-public class VkAuthController {
-
-    private final VkOAuthService vkOAuthService;
-
-    private final AuthService authService;
-
-    private final ExternalAuthUserService externalAuthUserService;
-
-    @GetMapping("/v{version}/vk/authorization/{code}/{state}/{codeVerifier}/{deviceId}")
-    public BaseResponse vkAuth(@PathVariable("code") String code,
-                                              @PathVariable("state") String state,
-                                              @PathVariable("codeVerifier") String codeVerifier,
-                                              @PathVariable("deviceId") String deviceId) {
-        try {
-            Map<String, Object> authMap = vkOAuthService.authTokenMap(code, state, codeVerifier, deviceId);
-            ObjectMapper mapper = new ObjectMapper();
-
-            String bodyJson = (String) authMap.get("body");
-            Map<String, Object> body = mapper.readValue(bodyJson, Map.class);
-
-            String accessToken = (String) body.get("access_token");
-            long vkUserId = ((Number) body.get("user_id")).longValue();
-            Integer expiresIn = (Integer) body.get("expires_in");
-            String refreshToken = (String) body.get("refresh_token");
-
-            Map<String, Object> vkUserInfo = vkOAuthService.userVkInfo(accessToken);
-            log.info("vkUserInfo {}", vkUserInfo);
-
-            String userInfoBodyJson = (String) vkUserInfo.get("body");
-            Map<String, Object> userInfoBody = mapper.readValue(userInfoBodyJson, Map.class);
-            Map<String, Object> user = (Map<String, Object>) userInfoBody.get("user");
-
-            String firstName = (String) user.get("first_name");
-            String lastName = (String) user.get("last_name");
-            String fullName = firstName + " " + lastName;
-
-            User userEntity = externalAuthUserService.findOrCreateUserFromVK(Long.toString(vkUserId), fullName,
-                    null, accessToken, refreshToken, expiresIn);
-
-            AuthToken ourToken = authService.createTokenForUser(userEntity);
-
-            LoginAnswer loginAnswer = new LoginAnswer();
-            loginAnswer.setToken(ourToken.getToken());
-            loginAnswer.setFieldErrors(new ArrayList<>());
-
-            return new BaseResponse(20009, MessageCode.SUCCESS.getCode(),
-                    MessageCode.SUCCESS.getDescription(), loginAnswer);
-        } catch (Exception e) {
-            log.error("VK auth error: ", e);
-
-            LoginAnswer loginAnswer = new LoginAnswer();
-            loginAnswer.setToken(null);
-
-            List<Map<String, String>> errors = new ArrayList<>();
-            Map<String, String> error = new HashMap<>();
-            error.put("field", "vk_auth");
-            error.put("message", e.getMessage());
-            errors.add(error);
-
-            loginAnswer.setFieldErrors(errors);
-
-            return new BaseResponse(20009, MessageCode.SUCCESS.getCode(),
-                    MessageCode.SUCCESS.getDescription(), loginAnswer);
-        }
-    }
-}
-

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

@@ -1,16 +0,0 @@
-package ru.soune.nocopy.dto;
-
-import com.fasterxml.jackson.annotation.JsonProperty;
-import lombok.Data;
-
-@Data
-public class BaseRequest {
-    @JsonProperty("version")
-    Integer version;
-
-    @JsonProperty("msg_id")
-    Integer msgId;
-
-    @JsonProperty("message_body")
-    Object messageBody;
-}

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

@@ -1,21 +0,0 @@
-package ru.soune.nocopy.dto;
-
-import com.fasterxml.jackson.annotation.JsonProperty;
-import lombok.AllArgsConstructor;
-import lombok.Data;
-
-@Data
-@AllArgsConstructor
-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/ChangePasswordRequest.java

@@ -1,14 +0,0 @@
-package ru.soune.nocopy.dto;
-
-import lombok.AllArgsConstructor;
-import lombok.Data;
-import lombok.Getter;
-
-@Data
-@AllArgsConstructor
-@Getter
-public class ChangePasswordRequest {
-    private String email;
-    private String currentPassword;
-    private String newPassword;
-}

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

@@ -1,12 +0,0 @@
-package ru.soune.nocopy.dto;
-
-import lombok.AllArgsConstructor;
-import lombok.Data;
-import lombok.NoArgsConstructor;
-
-@Data
-@AllArgsConstructor
-@NoArgsConstructor
-public class LogOutAnswer {
-    private String email;
-}

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

@@ -1,17 +0,0 @@
-package ru.soune.nocopy.dto;
-
-import lombok.AllArgsConstructor;
-import lombok.Data;
-import lombok.NoArgsConstructor;
-
-import java.util.List;
-import java.util.Map;
-
-@Data
-@AllArgsConstructor
-@NoArgsConstructor
-public class LoginAnswer {
-    private String Token;
-
-    private List<Map<String, String>> fieldErrors;
-}

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

@@ -1,19 +0,0 @@
-package ru.soune.nocopy.dto;
-
-import jakarta.validation.constraints.Email;
-import jakarta.validation.constraints.NotBlank;
-import jakarta.validation.constraints.Size;
-import lombok.AllArgsConstructor;
-import lombok.Data;
-import lombok.NoArgsConstructor;
-
-@Data
-@AllArgsConstructor
-@NoArgsConstructor
-public class LogoutRequest {
-    @NotBlank(message = "error.not.blank") @Email(message = "error.not.email") @Size(max = 128)
-    private String email;
-
-    @NotBlank(message = "error.not.blank")
-    private String token;
-}

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

@@ -1,40 +0,0 @@
-package ru.soune.nocopy.dto;
-
-public enum MessageCode {
-    SUCCESS(0, "Operation successful"),
-    REG_EMAIL_EXISTS(1, "Email already registered"),
-    REG_EMAIL_OR_PHONE_EXISTS(1, "Email or phone already registered"),
-    INVALID_FIELD(2, "Invalid field"),
-    INVALID_TOKEN(2, "Invalid token"),
-    INVALID_ACTION(2, "Invalid action"),
-    FILE_UPLOAD_ERROR(2, "File upload error"),
-    FILE_DOWNLOAD_ERROR(2, "File download error"),
-    FILE_DOWNLOAD_ERROR_NOT_CORRECT_FIELD(2, "Not correct field"),
-    INVALID_JSON_BODY(2, "Invalid fields in JSON object"),
-    INCOMPLETE_UPLOAD(2, "Not load all chunks"),
-    MSG_ID_NOT_FOUND(4, "Message id not found"),
-    FILE_ENTITY_ERROR(2, "File entity error"),
-    ACCESS_DENIED(2, "Access denied"),
-    AUTH_EMAIL_NOT_FOUND(4, "Email not found"),
-    AUTH_EMAIL_OR_TOKEN_NOT_FOUND(4, "Email or Token not found "),
-    AUTH_TOKEN_MISMATCH(4, "Token mismatch"),
-    FILE_NOT_FOUND(4, "File not found"),
-    AUTH_PASSWORD_NOT_MATCHES(2, "Password does not match");
-
-    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/RegAnswer.java

@@ -1,17 +0,0 @@
-package ru.soune.nocopy.dto;
-
-import lombok.AllArgsConstructor;
-import lombok.Data;
-import lombok.NoArgsConstructor;
-
-import java.util.List;
-import java.util.Map;
-
-@Data
-@AllArgsConstructor
-@NoArgsConstructor
-public class RegAnswer {
-    private String Token;
-
-    private List<Map<String, String>> fieldErrors;
-}

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

@@ -1,25 +0,0 @@
-package ru.soune.nocopy.dto;
-
-import jakarta.validation.constraints.*;
-import lombok.Data;
-
-
-@Data
-public class RegRequest {
-    @NotEmpty(message = "Full name is required")
-    private String fullName;
-
-    private String companyName;
-
-    @Size(min = 11, max = 14, message = "Phone must be 11-14 digits")
-    private String phone;
-
-    @NotBlank(message = "Email is required")
-    @Email(message = "Invalid email format")
-    @Size(max = 128, message = "Email too long")
-    private String email;
-
-    @NotBlank(message = "Password is required")
-    @Size(min = 8, message = "Password must be at least 8 characters")
-    private String password;
-}

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

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

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

@@ -1,15 +0,0 @@
-package ru.soune.nocopy.dto;
-
-import jakarta.validation.constraints.Email;
-import jakarta.validation.constraints.NotBlank;
-
-public record UserContentRequest(
-        @NotBlank @Email String userEmail,
-        @NotBlank String fileName,
-        @NotBlank String originalFilename,
-        @NotBlank String fileType,
-        @NotBlank String fileExtension,
-        @NotBlank Long fileSize,
-        @NotBlank String filePath,
-        Integer protectionLevel
-) {}

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

@@ -1,17 +0,0 @@
-package ru.soune.nocopy.dto;
-
-import ru.soune.nocopy.entity.ContentStatus;
-import ru.soune.nocopy.entity.file.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/nocopy/dto/UserContentUpdateRequest.java

@@ -1,16 +0,0 @@
-package ru.soune.nocopy.dto;
-
-import jakarta.validation.constraints.Email;
-import jakarta.validation.constraints.NotBlank;
-
-public record UserContentUpdateRequest(
-        @NotBlank @Email String userEmail,
-        @NotBlank String fileName,
-        @NotBlank String originalFilename,
-        @NotBlank String fileType,
-        @NotBlank String fileExtension,
-        @NotBlank Long fileSize,
-        @NotBlank String filePath,
-        Integer protectionLevel,
-        Long id
-) {}

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

@@ -1,27 +0,0 @@
-package ru.soune.nocopy.dto;
-
-import lombok.AllArgsConstructor;
-import lombok.Builder;
-import lombok.Data;
-import lombok.NoArgsConstructor;
-import ru.soune.nocopy.entity.GenderType;
-import ru.soune.nocopy.entity.SubscriptionType;
-
-import java.time.LocalDate;
-import java.time.LocalDateTime;
-
-@Data
-@AllArgsConstructor
-@NoArgsConstructor
-@Builder
-public class UserDTO {
-    private String fullName;
-    private String company;
-    private String email;
-    private boolean active;
-    private String phone;
-    private GenderType genderType;
-    private LocalDate birthday;
-    private LocalDateTime createdAt;
-    private SubscriptionType subscriptionType;
-}

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

@@ -1,24 +0,0 @@
-package ru.soune.nocopy.dto;
-
-import com.fasterxml.jackson.annotation.JsonFormat;
-import jakarta.validation.constraints.Email;
-import jakarta.validation.constraints.Past;
-import jakarta.validation.constraints.Size;
-import lombok.Data;
-import ru.soune.nocopy.entity.GenderType;
-
-import java.time.LocalDate;
-
-@Data
-public class UserRequest {
-    @Size(min = 2)
-    private String fullName;
-    private String company;
-    @Email
-    private String email;
-    private String phone;
-    private GenderType genderType;
-    @Past
-    @JsonFormat(pattern = "dd-MM-yyyy")
-    private LocalDate birthday;
-}

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

@@ -1,17 +0,0 @@
-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/CanceledUploadResponse.java

@@ -1,15 +0,0 @@
-package ru.soune.nocopy.dto.file;
-
-import com.fasterxml.jackson.annotation.JsonProperty;
-import lombok.Builder;
-import lombok.Data;
-
-@Data
-@Builder
-public class CanceledUploadResponse {
-    @JsonProperty("upload_id")
-    private String uploadId;
-
-    @JsonProperty("message")
-    private String message;
-}

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

@@ -1,28 +0,0 @@
-package ru.soune.nocopy.dto.file;
-
-import com.fasterxml.jackson.annotation.JsonProperty;
-import lombok.AllArgsConstructor;
-import lombok.Builder;
-import lombok.Data;
-import lombok.NoArgsConstructor;
-
-import java.util.Map;
-
-@Data
-@Builder
-public class ChunkStatusResponse {
-    @JsonProperty("upload_id")
-    private String uploadId;
-
-    @JsonProperty("total_chunks")
-    private Integer totalChunks;
-
-    @JsonProperty("chunk_status")
-    private Map<String, Boolean> chunkStatus;
-
-    @JsonProperty("uploaded_chunks")
-    private Integer uploadedChunks;
-
-    @JsonProperty("missing_chunks")
-    private Integer missingChunks;
-}

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

@@ -1,25 +0,0 @@
-package ru.soune.nocopy.dto.file;
-
-import com.fasterxml.jackson.annotation.JsonProperty;
-import lombok.AllArgsConstructor;
-import lombok.Builder;
-import lombok.Data;
-import lombok.NoArgsConstructor;
-
-@Data
-@Builder
-@NoArgsConstructor
-@AllArgsConstructor
-public class ChunkUploadResponse {
-    @JsonProperty("upload_id")
-    private String uploadId;
-
-    @JsonProperty("chunk_number")
-    private Integer chunkNumber;
-
-    @JsonProperty("chunk_size")
-    private Long chunkSize;
-
-    @JsonProperty("message")
-    private String message;
-}

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

@@ -1,31 +0,0 @@
-package ru.soune.nocopy.dto.file;
-
-import com.fasterxml.jackson.annotation.JsonProperty;
-import lombok.AllArgsConstructor;
-import lombok.Builder;
-import lombok.Data;
-import lombok.NoArgsConstructor;
-
-@Data
-@Builder
-@NoArgsConstructor
-@AllArgsConstructor
-public class CompleteUploadResponse {
-    @JsonProperty("upload_id")
-    private String uploadId;
-
-    @JsonProperty("status")
-    private String status;
-
-    @JsonProperty("uploaded_chunks")
-    private Integer uploadedChunks;
-
-    @JsonProperty("total_chunks")
-    private Integer totalChunks;
-
-    @JsonProperty("message")
-    private String message;
-
-    @JsonProperty("file_path")
-    private String filePath;
-}

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

@@ -1,19 +0,0 @@
-package ru.soune.nocopy.dto.file;
-
-import com.fasterxml.jackson.annotation.JsonProperty;
-import lombok.AllArgsConstructor;
-import lombok.Builder;
-import lombok.Data;
-import lombok.NoArgsConstructor;
-
-@Data
-@Builder
-@AllArgsConstructor
-@NoArgsConstructor
-public class DeleteFileResponse {
-    @JsonProperty("file_id")
-    private String fileId;
-
-    @JsonProperty("message")
-    private String message;
-}

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

@@ -1,41 +0,0 @@
-package ru.soune.nocopy.dto.file;
-
-import lombok.AllArgsConstructor;
-import lombok.Builder;
-import lombok.Data;
-import lombok.NoArgsConstructor;
-
-@Data
-@Builder
-@NoArgsConstructor
-@AllArgsConstructor
-public class FileApiResponse<T> {
-
-    private boolean success;
-    private String message;
-    private T data;
-    private String error;
-
-    public static <T> FileApiResponse<T> success(T data) {
-        return FileApiResponse.<T>builder()
-                .success(true)
-                .message("Operation completed successfully")
-                .data(data)
-                .build();
-    }
-
-    public static <T> FileApiResponse<T> success(String message, T data) {
-        return FileApiResponse.<T>builder()
-                .success(true)
-                .message(message)
-                .data(data)
-                .build();
-    }
-
-    public static <T> FileApiResponse<T> error(String error) {
-        return FileApiResponse.<T>builder()
-                .success(false)
-                .error(error)
-                .build();
-    }
-}

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

@@ -1,34 +0,0 @@
-package ru.soune.nocopy.dto.file;
-
-import com.fasterxml.jackson.annotation.JsonProperty;
-import lombok.AllArgsConstructor;
-import lombok.Builder;
-import lombok.Data;
-import lombok.NoArgsConstructor;
-
-@Data
-@Builder
-@AllArgsConstructor
-@NoArgsConstructor
-public class FileEntityRequest {
-    @JsonProperty("action")
-    private String action;
-
-    @JsonProperty("file_id")
-    private String fileId;
-
-    @JsonProperty("upload_session_id")
-    private String uploadSessionId;
-
-    @JsonProperty("query")
-    private String query;
-
-    @JsonProperty("page")
-    private Integer page;
-
-    @JsonProperty("page_size")
-    private Integer pageSize;
-
-    @JsonProperty("token")
-    private String token;
-}

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

@@ -1,33 +0,0 @@
-package ru.soune.nocopy.dto.file;
-
-import lombok.AllArgsConstructor;
-import lombok.Builder;
-import lombok.Data;
-import lombok.NoArgsConstructor;
-import ru.soune.nocopy.entity.file.FileStatus;
-
-import java.time.LocalDateTime;
-
-@Data
-@Builder
-@NoArgsConstructor
-@AllArgsConstructor
-public class FileEntityResponse {
-
-    private String id;
-    private Long userId;
-    private String originalFileName;
-    private String storedFileName;
-    private String filePath;
-    private Long fileSize;
-    private String mimeType;
-    private String fileExtension;
-    private String checksum;
-    private String uploadSessionId;
-    private FileStatus status;
-    private LocalDateTime createdAt;
-    private LocalDateTime updatedAt;
-    private String formattedSize;
-    private String downloadUrl;
-    private boolean existsOnDisk;
-}

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

@@ -1,20 +0,0 @@
-package ru.soune.nocopy.dto.file;
-
-import com.fasterxml.jackson.annotation.JsonProperty;
-import lombok.Builder;
-import lombok.Data;
-
-import java.util.List;
-
-@Data
-@Builder
-public class FileExtensionResponse {
-    @JsonProperty("file_extension")
-    private List<String> extension;
-
-    @JsonProperty("count")
-    private Integer count;
-
-    @JsonProperty("max_file_size")
-    private Long maxFileSize;
-}

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

@@ -1,61 +0,0 @@
-package ru.soune.nocopy.dto.file;
-
-import com.fasterxml.jackson.annotation.JsonProperty;
-import lombok.AllArgsConstructor;
-import lombok.Builder;
-import lombok.Data;
-import lombok.NoArgsConstructor;
-
-@Data
-@Builder
-@NoArgsConstructor
-@AllArgsConstructor
-public class FileInfoUserResponse {
-    @JsonProperty("all_files_size")
-    private Long allFileSize;
-
-    @JsonProperty("all_files_quantity")
-    private Integer fileCount;
-
-    @JsonProperty("all_files_check")
-    private Integer filesCheck;
-
-    @JsonProperty("all_files_violation")
-    private Integer filesViolation;
-
-    @JsonProperty("images_size")
-    private Long imagesSize;
-
-    @JsonProperty("images_quantity")
-    private Integer imagesCount;
-
-    @JsonProperty("images_check")
-    private Integer imagesCheck;
-
-    @JsonProperty("images_violations")
-    private Integer imagesViolations;
-
-    @JsonProperty("videos_size")
-    private Long videosSize;
-
-    @JsonProperty("videos_quantity")
-    private Integer videosCount;
-
-    @JsonProperty("videos_check")
-    private Integer videosCheck;
-
-    @JsonProperty("videos_violations")
-    private Integer videosViolations;
-
-    @JsonProperty("audios_size")
-    private Long audiosSize;
-
-    @JsonProperty("audios_quantity")
-    private Integer audiosCount;
-
-    @JsonProperty("audios_check")
-    private Integer audiosCheck;
-
-    @JsonProperty("audios_violations")
-    private Integer audiosViolations;
-}

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

@@ -1,33 +0,0 @@
-package ru.soune.nocopy.dto.file;
-
-import com.fasterxml.jackson.annotation.JsonProperty;
-import lombok.AllArgsConstructor;
-import lombok.Builder;
-import lombok.Data;
-import lombok.NoArgsConstructor;
-
-import java.util.List;
-
-@Data
-@Builder
-@AllArgsConstructor
-@NoArgsConstructor
-public class FileListResponse {
-    @JsonProperty("files")
-    private List<FileEntityResponse> files;
-
-    @JsonProperty("total_count")
-    private Integer totalCount;
-
-    @JsonProperty("total_size")
-    private Long totalSize;
-
-    @JsonProperty("formatted_total_size")
-    private String formattedTotalSize;
-
-    @JsonProperty("page")
-    private Integer page;
-
-    @JsonProperty("page_size")
-    private Integer pageSize;
-}

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

@@ -1,22 +0,0 @@
-package ru.soune.nocopy.dto.file;
-
-import lombok.AllArgsConstructor;
-import lombok.Builder;
-import lombok.Data;
-import lombok.NoArgsConstructor;
-
-import java.util.List;
-
-@Data
-@Builder
-@NoArgsConstructor
-@AllArgsConstructor
-public class FileResponse {
-
-    private List<FileEntityResponse> files;
-    private int totalCount;
-    private long totalSize;
-    private String formattedTotalSize;
-    private int page;
-    private int pageSize;
-}

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

@@ -1,19 +0,0 @@
-package ru.soune.nocopy.dto.file;
-
-import com.fasterxml.jackson.annotation.JsonProperty;
-import lombok.Builder;
-import lombok.Data;
-import ru.soune.nocopy.entity.file.FileType;
-
-import java.util.List;
-
-@Data
-@Builder
-public class FileTypesResponse {
-    @JsonProperty("file_types")
-    private List<FileType> fileTypes;
-
-    @JsonProperty("count")
-    private Integer count;
-}
-

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

@@ -1,31 +0,0 @@
-package ru.soune.nocopy.dto.file;
-
-import com.fasterxml.jackson.annotation.JsonProperty;
-import lombok.Data;
-
-@Data
-public class FileUploadRequest {
-    @JsonProperty("upload_id")
-    private String uploadId;
-
-    @JsonProperty("file_name")
-    private String fileName;
-
-    @JsonProperty("file_type")
-    private String fileType;
-
-    @JsonProperty("extension")
-    private String extension;
-
-    @JsonProperty("file_size")
-    private Long fileSize;
-
-    @JsonProperty("chunk_number")
-    private Integer chunkNumber;
-
-    @JsonProperty("action")
-    private String action;
-
-    @JsonProperty("token")
-    private String token;
-}

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

@@ -1,30 +0,0 @@
-package ru.soune.nocopy.dto.file;
-
-import com.fasterxml.jackson.annotation.JsonProperty;
-import lombok.Builder;
-import lombok.Data;
-
-import java.util.List;
-import java.util.Map;
-
-@Data
-@Builder
-public class InitFileResponse {
-    @JsonProperty("upload_id")
-    private String uploadId;
-
-    @JsonProperty("file_name")
-    private String fileName;
-
-    @JsonProperty("total_chunks")
-    private Integer totalChunks;
-
-    @JsonProperty("chunk_size")
-    private Long chunkSize;
-
-    @JsonProperty("status")
-    private String status;
-
-    @JsonProperty("field_errors")
-    private List<Map<String, String>> fieldErrors;
-}

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

@@ -1,23 +0,0 @@
-package ru.soune.nocopy.dto.file;
-
-import jakarta.validation.constraints.NotBlank;
-import jakarta.validation.constraints.NotNull;
-import jakarta.validation.constraints.Positive;
-import lombok.Data;
-
-@Data
-public class InitUploadRequest {
-
-    @NotBlank(message = "File name is required")
-    private String fileName;
-
-    @NotBlank(message = "File type is required")
-    private String fileType;
-
-    @NotBlank(message = "File extension is required")
-    private String extension;
-
-    @NotNull(message = "File size is required")
-    @Positive(message = "File size must be positive")
-    private Long fileSize;
-}

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

@@ -1,18 +0,0 @@
-package ru.soune.nocopy.dto.file;
-
-import com.fasterxml.jackson.annotation.JsonProperty;
-import lombok.Builder;
-import lombok.Data;
-
-@Data
-@Builder
-public class RetryUploadResponse {
-    @JsonProperty("upload_id")
-    private String uploadId;
-
-    @JsonProperty("message")
-    private String message;
-
-    @JsonProperty("status")
-    private String status;
-}

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

@@ -1,22 +0,0 @@
-package ru.soune.nocopy.dto.file;
-
-import com.fasterxml.jackson.annotation.JsonProperty;
-import lombok.AllArgsConstructor;
-import lombok.Builder;
-import lombok.Data;
-import lombok.NoArgsConstructor;
-
-@Data
-@Builder
-@AllArgsConstructor
-@NoArgsConstructor
-public class StorageUsageResponse {
-    @JsonProperty("user_id")
-    private Long userId;
-
-    @JsonProperty("storage_used")
-    private Long storageUsed;
-
-    @JsonProperty("formatted_storage_used")
-    private String formattedStorageUsed;
-}

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

@@ -1,40 +0,0 @@
-package ru.soune.nocopy.dto.file;
-
-import com.fasterxml.jackson.annotation.JsonProperty;
-import lombok.AllArgsConstructor;
-import lombok.Builder;
-import lombok.Data;
-import lombok.NoArgsConstructor;
-
-@Builder
-@Data
-@AllArgsConstructor
-@NoArgsConstructor
-public class UploadProgress {
-    @JsonProperty("upload_id")
-    private String uploadId;
-
-    @JsonProperty("file_name")
-    private String fileName;
-
-    @JsonProperty("total_chunks")
-    private Integer totalChunks;
-
-    @JsonProperty("uploaded_chunks")
-    private Integer uploadedChunks;
-
-    @JsonProperty("status")
-    private String status;
-
-    @JsonProperty("progress_percentage")
-    private Integer progressPercentage;
-
-    @JsonProperty("file_path")
-    private String filePath;
-
-    @JsonProperty("remaining_chunks")
-    private Integer remainingChunks;
-
-    @JsonProperty("message")
-    private String message;
-}

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

@@ -1,39 +0,0 @@
-package ru.soune.nocopy.dto.file;
-
-
-import lombok.AllArgsConstructor;
-import lombok.Builder;
-import lombok.Data;
-import lombok.NoArgsConstructor;
-import ru.soune.nocopy.entity.file.FileUploadSession;
-import ru.soune.nocopy.entity.file.UploadStatus;
-
-@Data
-@Builder
-@NoArgsConstructor
-@AllArgsConstructor
-public class UploadProgressResponse {
-
-    private String uploadId;
-    private String fileName;
-    private Integer totalChunks;
-    private Integer uploadedChunks;
-    private UploadStatus status;
-    private Integer progressPercentage;
-    private String filePath;
-
-    public static UploadProgressResponse fromSession(FileUploadSession session) {
-        int progress = session.getTotalChunks() == 0 ? 0 :
-                (session.getChunksUploaded() * 100) / session.getTotalChunks();
-
-        return UploadProgressResponse.builder()
-                .uploadId(session.getUploadId())
-                .fileName(session.getFileName())
-                .totalChunks(session.getTotalChunks())
-                .uploadedChunks(session.getChunksUploaded())
-                .status(session.getStatus())
-                .progressPercentage(progress)
-                .filePath(session.getFilePath())
-                .build();
-    }
-}

src/main/java/ru/soune/nocopy/entity/BaseEntity.java

@@ -1,29 +0,0 @@
-package ru.soune.nocopy.entity;
-
-import jakarta.persistence.*;
-import lombok.Getter;
-import lombok.Setter;
-import org.springframework.data.annotation.CreatedDate;
-import org.springframework.data.annotation.LastModifiedDate;
-import org.springframework.data.jpa.domain.support.AuditingEntityListener;
-
-import java.time.LocalDateTime;
-
-@MappedSuperclass
-@EntityListeners(AuditingEntityListener.class)
-@Getter
-@Setter
-public abstract class BaseEntity {
-
-    @Id
-    @GeneratedValue(strategy = GenerationType.IDENTITY)
-    private Long id;
-
-    @CreatedDate
-    @Column(name = "created_at", updatable = false, nullable = false)
-    private LocalDateTime createdAt;
-
-    @LastModifiedDate
-    @Column(name = "updated_at")
-    private LocalDateTime updatedAt;
-}

src/main/java/ru/soune/nocopy/entity/ContentStatus.java

@@ -1,20 +0,0 @@
-package ru.soune.nocopy.entity;
-
-import lombok.Getter;
-
-@Getter
-public enum ContentStatus {
-    PROCESSING("processing"),
-    COMPLETED("completed"),
-    ERROR("error");
-
-    private final String code;
-
-    ContentStatus(String code) {
-        this.code = code;
-    }
-
-    public String getCode() {
-        return code;
-    }
-}

src/main/java/ru/soune/nocopy/entity/GenderType.java

@@ -1,5 +0,0 @@
-package ru.soune.nocopy.entity;
-
-public enum GenderType {
-    MALE, FEMALE
-}

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

@@ -1,49 +0,0 @@
-package ru.soune.nocopy.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/nocopy/entity/SubscriptionType.java

@@ -1,8 +0,0 @@
-package ru.soune.nocopy.entity;
-
-import lombok.Getter;
-
-@Getter
-public enum SubscriptionType {
-    START, BASIC, PRO, ENTERPRISE, DEMO;
-}

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

@@ -1,107 +0,0 @@
-package ru.soune.nocopy.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 ru.soune.nocopy.entity.auth.AuthToken;
-import ru.soune.nocopy.entity.auth.ExternalAuthProvider;
-
-import java.time.LocalDate;
-import java.time.LocalDateTime;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Optional;
-
-@Entity
-@Table(name = "users")
-@Getter
-@Setter
-@NoArgsConstructor
-@AllArgsConstructor
-@ToString
-@Builder
-@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 = 255)
-    @Column(name = "email", nullable = false, length = 255, 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)
-    @Column(unique = true)
-    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<>();
-
-    @OneToMany(mappedBy = "user", cascade = CascadeType.ALL, fetch = FetchType.LAZY)
-    @ToString.Exclude
-    private List<ExternalAuthProvider> externalAuthProviders = new ArrayList<>();
-
-    public Optional<ExternalAuthProvider> getProvider(ExternalAuthProvider.ProviderType providerType) {
-        return externalAuthProviders.stream()
-                .filter(p -> p.getProviderType() == providerType)
-                .findFirst();
-    }
-}

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

@@ -1,44 +0,0 @@
-package ru.soune.nocopy.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/nocopy/entity/UserContent.java

@@ -1,80 +0,0 @@
-package ru.soune.nocopy.entity;
-
-import jakarta.persistence.*;
-import lombok.*;
-import org.springframework.data.annotation.CreatedDate;
-import org.springframework.data.jpa.domain.support.AuditingEntityListener;
-import ru.soune.nocopy.entity.file.FileType;
-
-import java.time.LocalDateTime;
-
-@Entity
-@Table(name = "user_content")
-@Getter
-@Setter
-@NoArgsConstructor
-@AllArgsConstructor
-@ToString
-@EntityListeners(AuditingEntityListener.class)
-public class UserContent {
-
-    @Id
-    @GeneratedValue(strategy = GenerationType.IDENTITY)
-    private Long contentId;
-
-    @ManyToOne(fetch = FetchType.LAZY)
-    @JoinColumn(name = "user_id", nullable = false)
-    @ToString.Exclude
-    private User user;
-
-    @Column(name = "filename", nullable = false, length = 255)
-    private String filename;
-
-    @Column(name = "original_filename", nullable = false, length = 255)
-    private String originalFilename;
-
-    @Enumerated(EnumType.STRING)
-    @Column(name = "file_type", nullable = false, length = 20)
-    private FileType fileType;
-
-    @Column(name = "file_extension", nullable = false, length = 10)
-    private String fileExtension;
-
-    @Column(name = "file_size", nullable = false)
-    private Long fileSize;
-
-    @Column(name = "file_path", nullable = false, columnDefinition = "TEXT")
-    private String filePath;
-
-    @Column(name = "protection_level")
-    private Integer protectionLevel = 0;
-
-    @Column(name = "geometric_resistant")
-    private Boolean geometricResistant = false;
-
-    @Column(name = "watermark_applied")
-    private Boolean watermarkApplied = false;
-
-    @Column(name = "protection_hash", length = 64)
-    private String protectionHash;
-
-    @Column(name = "watermark_id", length = 50)
-    private String watermarkId;
-
-    @Enumerated(EnumType.STRING)
-    @Column(name = "status", nullable = false, length = 20)
-    private ContentStatus status = ContentStatus.PROCESSING;
-
-    @CreatedDate
-    @Column(name = "upload_date", nullable = false, updatable = false)
-    private LocalDateTime uploadDate;
-
-    public Double getFileSizeInGB() {
-        return fileSize != null ? fileSize / (1024.0 * 1024.0 * 1024.0) : 0.0;
-    }
-
-    public Boolean isProtected() {
-        return protectionLevel != null && protectionLevel > 0;
-    }
-}
-

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

@@ -1,56 +0,0 @@
-package ru.soune.nocopy.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/nocopy/entity/auth/ExternalAuthProvider.java

@@ -1,89 +0,0 @@
-package ru.soune.nocopy.entity.auth;
-
-import jakarta.persistence.*;
-import lombok.*;
-import org.springframework.data.annotation.CreatedDate;
-import org.springframework.data.jpa.domain.support.AuditingEntityListener;
-import ru.soune.nocopy.entity.User;
-
-import java.time.LocalDateTime;
-
-@Entity
-@Table(name = "external_auth_providers",
-        uniqueConstraints = @UniqueConstraint(
-                columnNames = {"provider_type", "provider_user_id"}
-        ),
-        indexes = {
-                @Index(name = "idx_provider_type_user_id",
-                        columnList = "provider_type, provider_user_id"),
-                @Index(name = "idx_user_id_provider_type",
-                        columnList = "user_id, provider_type")
-        })
-@Getter @Setter
-@NoArgsConstructor
-@AllArgsConstructor
-@Builder
-@EntityListeners(AuditingEntityListener.class)
-public class ExternalAuthProvider {
-
-    public enum ProviderType {
-        VK, YANDEX
-    }
-
-    @Id
-    @GeneratedValue(strategy = GenerationType.IDENTITY)
-    private Long id;
-
-    @ManyToOne(fetch = FetchType.LAZY)
-    @JoinColumn(name = "user_id", nullable = false, foreignKey = @ForeignKey(name = "fk_extauth_user"))
-    @ToString.Exclude
-    private User user;
-
-    @Enumerated(EnumType.STRING)
-    @Column(name = "provider_type", nullable = false, length = 20)
-    private ProviderType providerType;
-
-    @Column(name = "provider_user_id", nullable = false, length = 255)
-    private String providerUserId;
-
-    @Column(name = "access_token", length = 2048)
-    private String accessToken;
-
-    @Column(name = "refresh_token", length = 2048)
-    private String refreshToken;
-
-    @Column(name = "token_expires_at")
-    private LocalDateTime tokenExpiresAt;
-
-    @Column(name = "email", length = 255)
-    private String email;
-
-    @Column(name = "phone", length = 20)
-    private String phoneNumber;
-
-    @CreatedDate
-    @Column(name = "linked_at", updatable = false)
-    private LocalDateTime linkedAt;
-
-    @Column(name = "last_used_at")
-    private LocalDateTime lastUsedAt;
-
-    @Column(name = "is_active")
-    @Builder.Default
-    private Boolean isActive = true;
-
-    @PrePersist
-    public void prePersist() {
-        if (this.linkedAt == null) {
-            this.linkedAt = LocalDateTime.now();
-        }
-        if (this.lastUsedAt == null) {
-            this.lastUsedAt = LocalDateTime.now();
-        }
-    }
-
-    @PreUpdate
-    public void preUpdate() {
-        this.lastUsedAt = LocalDateTime.now();
-    }
-}

src/main/java/ru/soune/nocopy/entity/file/FileEntity.java

@@ -1,78 +0,0 @@
-package ru.soune.nocopy.entity.file;
-
-import jakarta.persistence.*;
-import lombok.*;
-import org.springframework.data.annotation.CreatedDate;
-import org.springframework.data.annotation.LastModifiedDate;
-import org.springframework.data.jpa.domain.support.AuditingEntityListener;
-
-import java.time.LocalDateTime;
-
-@Data
-@Builder
-@NoArgsConstructor
-@AllArgsConstructor
-@Entity
-@Table(name = "file_entities")
-@EntityListeners(AuditingEntityListener.class)
-public class FileEntity {
-
-    @Id
-    @GeneratedValue(strategy = GenerationType.UUID)
-    private String id;
-
-    @Column(name = "user_id", nullable = false)
-    private Long userId;
-
-    @Column(name = "original_file_name", nullable = false)
-    private String originalFileName;
-
-    @Column(name = "stored_file_name", nullable = false)
-    private String storedFileName;
-
-    @Column(name = "file_path", nullable = false, unique = true)
-    private String filePath;
-
-    @Column(name = "file_size", nullable = false)
-    private Long fileSize;
-
-    @Column(name = "mime_type")
-    private String mimeType;
-
-    @Column(name = "file_extension")
-    private String fileExtension;
-
-    @Column(name = "checksum")
-    private String checksum;
-
-    @Column(name = "upload_session_id")
-    private String uploadSessionId;
-
-    @Enumerated(EnumType.STRING)
-    @Column(name = "status")
-    private FileStatus status;
-
-    @CreatedDate
-    @Column(name = "created_at", updatable = false)
-    private LocalDateTime createdAt;
-
-    @LastModifiedDate
-    @Column(name = "updated_at")
-    private LocalDateTime updatedAt;
-
-    @PrePersist
-    public void prePersist() {
-        if (this.status == null) {
-            this.status = FileStatus.ACTIVE;
-        }
-        if (this.createdAt == null) {
-            this.createdAt = LocalDateTime.now();
-        }
-        this.updatedAt = LocalDateTime.now();
-    }
-
-    @PreUpdate
-    public void preUpdate() {
-        this.updatedAt = LocalDateTime.now();
-    }
-}

src/main/java/ru/soune/nocopy/entity/file/FileStatus.java

@@ -1,10 +0,0 @@
-package ru.soune.nocopy.entity.file;
-
-public enum FileStatus {
-    ACTIVE,
-    DELETED,
-    PROCESSING,
-    VIOLATION,
-    CHECKED,
-    ERROR
-}

src/main/java/ru/soune/nocopy/entity/file/FileType.java

@@ -1,45 +0,0 @@
-package ru.soune.nocopy.entity.file;
-
-import lombok.Getter;
-
-import java.util.Arrays;
-import java.util.List;
-
-@Getter
-public enum FileType {
-    IMAGE("image", Arrays.asList("jpg", "jpeg", "png", "gif", "bmp", "webp")),
-    VIDEO("video", Arrays.asList("mp4", "avi", "mov", "wmv", "flv", "mkv", "webm", "m4v", "mpg", "mpeg",
-            "3gp", "3g2", "f4v", "m2ts", "mts", "vob", "ogv", "divx")),
-    AUDIO("audio", Arrays.asList("mp3", "wav", "flac")),
-    DOCUMENT("document", Arrays.asList(
-            "pdf", "txt", "rtf",
-            "doc", "docx", "xls", "xlsx", "ppt", "pptx", "pps", "ppsx", "dot", "dotx", "xlt", "xltx", "pot", "potx",
-            "odt", "ods", "odp", "odg", "odf", "odb", "odc", "odi", "odm", "ott", "ots", "otp", "otg", "oth",
-            "sxw", "sxc", "sxi", "sxd", "sxg", "stc", "sti", "stw", "sxm",
-            "pages", "numbers", "key",
-            "csv", "tsv", "xml", "html", "htm", "tex", "md", "markdown",
-            "epub", "mobi", "azw", "azw3", "fb2",
-            "wps", "wpt", "et", "dps", "vsd", "vsdx",
-            "java", "py", "cpp", "c", "h", "js", "css", "php", "sql", "json", "yaml", "yml", "sh", "bat",
-            "one", "note"));
-
-    private final String displayName;
-    private final List<String> allowedExtensions;
-
-    FileType(String displayName, List<String> allowedExtensions) {
-        this.displayName = displayName;
-        this.allowedExtensions = allowedExtensions;
-    }
-
-    public String getDisplayName() {
-        return displayName;
-    }
-
-    public List<String> getAllowedExtensions() {
-        return allowedExtensions;
-    }
-
-    public boolean supportsExtension(String extension) {
-        return allowedExtensions.contains(extension.toLowerCase());
-    }
-}

src/main/java/ru/soune/nocopy/entity/file/FileUploadSession.java

@@ -1,100 +0,0 @@
-package ru.soune.nocopy.entity.file;
-
-import jakarta.persistence.*;
-import lombok.*;
-import org.springframework.data.annotation.CreatedDate;
-
-import java.time.LocalDateTime;
-import java.util.HashMap;
-import java.util.Map;
-
-@Data
-@Builder
-@NoArgsConstructor
-@AllArgsConstructor
-@Entity
-@Table(name = "file_upload_sessions")
-public class FileUploadSession {
-
-    @Id
-    @GeneratedValue(strategy = GenerationType.UUID)
-    @Column(name = "upload_id")
-    private String uploadId;
-
-    @Column(name = "user_id", nullable = false)
-    private Long userId;
-
-    @Column(name = "file_name", nullable = false)
-    private String fileName;
-
-    @Column(name = "file_type")
-    private String fileType;
-
-    @Column(name = "file_size")
-    private Long fileSize;
-
-    @Column(name = "chunk_size")
-    private Long chunkSize;
-
-    @Column(name = "total_chunks")
-    private Integer totalChunks;
-
-    @Column(name = "chunks_uploaded")
-    private Integer chunksUploaded;
-
-    @Column(name = "status")
-    @Enumerated(EnumType.STRING)
-    private UploadStatus status;
-
-    @Column(name = "file_path")
-    private String filePath;
-
-    @Column(name = "checksum")
-    private String checksum;
-
-    @CreatedDate
-    @Column(name = "created_at", updatable = false, nullable = false)
-    private LocalDateTime createdAt;
-
-    @Column(name = "expires_at")
-    private LocalDateTime expiresAt;
-
-    @Version
-    private Long version;
-
-    @Column(name = "last_error")
-    private String lastError;
-
-    @Column(name = "extension")
-    private String extension;
-
-    @Column(name = "retry_count")
-    private Integer retryCount = 0;
-
-    @Column(name = "completed_at")
-    private LocalDateTime completedAt;
-
-    @ElementCollection
-    @CollectionTable(
-            name = "uploaded_chunks",
-            joinColumns = @JoinColumn(name = "upload_id")
-    )
-    @MapKeyColumn(name = "chunk_number")
-    @Column(name = "chunk_path")
-    private Map<Integer, String> chunkPaths = new HashMap<>();
-
-    @PrePersist
-    public void prePersist() {
-        this.createdAt = LocalDateTime.now();
-        this.expiresAt = LocalDateTime.now().plusMinutes(1);
-        if (this.chunksUploaded == null) {
-            this.chunksUploaded = 0;
-        }
-        if (this.status == null) {
-            this.status = UploadStatus.INITIATED;
-        }
-        if (this.retryCount == null) {
-            this.retryCount = 0;
-        }
-    }
-}

src/main/java/ru/soune/nocopy/entity/file/UploadStatus.java

@@ -1,9 +0,0 @@
-package ru.soune.nocopy.entity.file;
-
-public enum UploadStatus {
-    INITIATED,
-    UPLOADING,
-    COMPLETED,
-    FAILED,
-    CANCELLED
-}

src/main/java/ru/soune/nocopy/exception/ChunkSizeExceededException.java

@@ -1,7 +0,0 @@
-package ru.soune.nocopy.exception;
-
-public class ChunkSizeExceededException extends RuntimeException {
-    public ChunkSizeExceededException(long actualSize, long maxSize) {
-        super(String.format("Chunk size not valid: " + actualSize));
-    }
-}

src/main/java/ru/soune/nocopy/exception/ContentNotFoundException.java

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

src/main/java/ru/soune/nocopy/exception/FileEntityNotFoundException.java

@@ -1,11 +0,0 @@
-package ru.soune.nocopy.exception;
-
-public class FileEntityNotFoundException extends RuntimeException {
-    public FileEntityNotFoundException(String fileId) {
-        super("FileEntity not found with ID: " + fileId);
-    }
-
-    public FileEntityNotFoundException(String message, Throwable cause) {
-        super(message, cause);
-    }
-}

src/main/java/ru/soune/nocopy/exception/FileIntegrityException.java

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

src/main/java/ru/soune/nocopy/exception/FileUploadException.java

@@ -1,11 +0,0 @@
-package ru.soune.nocopy.exception;
-
-public class FileUploadException extends RuntimeException {
-    public FileUploadException(String message) {
-        super(message);
-    }
-
-    public FileUploadException(String message, Throwable cause) {
-        super(message, cause);
-    }
-}

src/main/java/ru/soune/nocopy/exception/InvalidPasswordException.java

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

src/main/java/ru/soune/nocopy/exception/InvalidUserEmail.java

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

src/main/java/ru/soune/nocopy/exception/NotFoundAuthToken.java

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

src/main/java/ru/soune/nocopy/exception/NotValidFieldException.java

@@ -1,18 +0,0 @@
-package ru.soune.nocopy.exception;
-
-import lombok.Getter;
-import ru.soune.nocopy.dto.BaseResponse;
-
-@Getter
-public class NotValidFieldException extends RuntimeException {
-
-    private final String message;
-
-    private final BaseResponse baseResponse;
-
-    public NotValidFieldException(String message, BaseResponse baseResponse) {
-        super(message);
-        this.message = message;
-        this.baseResponse = baseResponse;
-    }
-}

src/main/java/ru/soune/nocopy/exception/TokenNotFoundException.java

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

src/main/java/ru/soune/nocopy/exception/UploadSessionNotFoundException.java

@@ -1,7 +0,0 @@
-package ru.soune.nocopy.exception;
-
-public class UploadSessionNotFoundException extends RuntimeException {
-    public UploadSessionNotFoundException(String uploadId) {
-        super("Upload session not found: " + uploadId);
-    }
-}

src/main/java/ru/soune/nocopy/exception/ValidationException.java

@@ -1,16 +0,0 @@
-package ru.soune.nocopy.exception;
-
-import lombok.Getter;
-import org.springframework.validation.BindingResult;
-
-@Getter
-public class ValidationException extends RuntimeException {
-    private final BindingResult bindingResult;
-    private final Integer msgId;
-
-    public ValidationException(BindingResult bindingResult, Integer msgId) {
-        super("Validation failed");
-        this.bindingResult = bindingResult;
-        this.msgId = msgId;
-    }
-}

src/main/java/ru/soune/nocopy/handler/FileEntityHandler.java

@@ -1,328 +0,0 @@
-package ru.soune.nocopy.handler;
-
-import com.fasterxml.jackson.databind.ObjectMapper;
-import lombok.RequiredArgsConstructor;
-import lombok.extern.slf4j.Slf4j;
-import org.springframework.stereotype.Component;
-import ru.soune.nocopy.dto.*;
-import ru.soune.nocopy.dto.file.*;
-import ru.soune.nocopy.entity.auth.AuthToken;
-import ru.soune.nocopy.entity.file.FileEntity;
-import ru.soune.nocopy.entity.file.FileStatus;
-import ru.soune.nocopy.exception.FileEntityNotFoundException;
-import ru.soune.nocopy.exception.NotFoundAuthToken;
-import ru.soune.nocopy.repository.AuthTokenRepository;
-import ru.soune.nocopy.repository.FileEntityRepository;
-import ru.soune.nocopy.service.file.FileEntityService;
-import ru.soune.nocopy.service.file.FileStatsService;
-
-import java.util.Arrays;
-import java.util.List;
-
-@Slf4j
-@Component
-@RequiredArgsConstructor
-public class FileEntityHandler implements RequestHandler {
-
-    private final FileEntityService fileEntityService;
-
-    private final FileStatsService fileStatsService;
-
-    private final AuthTokenRepository authTokenRepository;
-
-    private final ObjectMapper objectMapper;
-
-    private final FileEntityRepository fileEntityRepository;
-
-    @Override
-    public BaseResponse handle(BaseRequest request) {
-        try {
-            FileEntityRequest fileRequest = objectMapper.convertValue(
-                    request.getMessageBody(), FileEntityRequest.class);
-
-            String action = fileRequest.getAction();
-
-            switch (action) {
-                case "file_info":
-                    return handleGetFileInfo(request, fileRequest);
-                case "user_files_info":
-                    return handleGetFilesUserInfo(request, fileRequest);
-                case "file_by_session":
-                    return handleGetFileBySession(request, fileRequest);
-                case "user_files":
-                    return handleGetUserFiles(request, fileRequest);
-                case "search_files":
-                    return handleSearchFiles(request, fileRequest);
-                case "storage_usage":
-                    return handleGetStorageUsage(request, fileRequest);
-                case "delete_file":
-                    return handleDeleteFile(request, fileRequest);
-                default:
-                    ActionResponse response = ActionResponse.builder()
-                            .action(action)
-                            .availableActions(Arrays.asList(
-                                    "file_info", "file_by_session", "user_files",
-                                    "search_files", "storage_usage", "delete_file"))
-                            .build();
-
-                    return new BaseResponse(request.getMsgId(),
-                            MessageCode.INVALID_ACTION.getCode(),
-                            "Invalid action: " + action,
-                            response);
-            }
-        } catch (Exception e) {
-            log.error("Error in FileEntityHandler", e);
-            return new BaseResponse(request.getMsgId(),
-                    MessageCode.FILE_UPLOAD_ERROR.getCode(),
-                    "Handler error: " + e.getMessage(),
-                    null);
-        }
-    }
-
-    private BaseResponse handleGetFilesUserInfo(BaseRequest request, FileEntityRequest fileRequest) {
-        Long userId = getUserIdFromToken(fileRequest.getToken());
-        FileInfoUserResponse userFileStats = fileStatsService.getUserFileStats(userId);
-
-        return new BaseResponse(request.getMsgId(),
-                MessageCode.SUCCESS.getCode(),
-                MessageCode.SUCCESS.getDescription(),
-                userFileStats);
-    }
-
-    private BaseResponse handleGetFileInfo(BaseRequest request, FileEntityRequest fileRequest) {
-        try {
-            Long userId = getUserIdFromToken(fileRequest.getToken());
-            FileEntityResponse fileInfo = fileEntityService.getById(fileRequest.getFileId(), request.getVersion());
-
-            if (!fileInfo.getUserId().equals(userId)) {
-                return new BaseResponse(request.getMsgId(),
-                        MessageCode.ACCESS_DENIED.getCode(),
-                        "Access denied",
-                        null);
-            }
-
-            return new BaseResponse(request.getMsgId(),
-                    MessageCode.SUCCESS.getCode(),
-                    MessageCode.SUCCESS.getDescription(),
-                    fileInfo);
-
-        } catch (NotFoundAuthToken e) {
-            return new BaseResponse(request.getMsgId(),
-                    MessageCode.INVALID_TOKEN.getCode(),
-                    "Authentication required",
-                    null);
-        } catch (Exception e) {
-            log.error("Error getting file info", e);
-            return new BaseResponse(request.getMsgId(),
-                    MessageCode.FILE_UPLOAD_ERROR.getCode(),
-                    "Failed to get file info: " + e.getMessage(),
-                    null);
-        }
-    }
-
-    private BaseResponse handleGetFileBySession(BaseRequest request, FileEntityRequest fileRequest) {
-        try {
-            Long userId = getUserIdFromToken(fileRequest.getToken());
-            FileEntityResponse fileInfo = fileEntityService.getByUploadSessionId(fileRequest.getUploadSessionId(),
-                    request.getVersion());
-
-            if (!fileInfo.getUserId().equals(userId)) {
-                return new BaseResponse(request.getMsgId(),
-                        MessageCode.ACCESS_DENIED.getCode(),
-                        "Access denied",
-                        null);
-            }
-
-            return new BaseResponse(request.getMsgId(),
-                    MessageCode.SUCCESS.getCode(),
-                    MessageCode.SUCCESS.getDescription(),
-                    fileInfo);
-
-        } catch (NotFoundAuthToken e) {
-            return new BaseResponse(request.getMsgId(),
-                    MessageCode.INVALID_TOKEN.getCode(),
-                    "Authentication required",
-                    null);
-        } catch (Exception e) {
-            log.error("Error getting file by session", e);
-            return new BaseResponse(request.getMsgId(),
-                    MessageCode.FILE_UPLOAD_ERROR.getCode(),
-                    "Failed to get file: " + e.getMessage(),
-                    null);
-        }
-    }
-
-    private BaseResponse handleGetUserFiles(BaseRequest request, FileEntityRequest fileRequest) {
-        try {
-            Long userId = getUserIdFromToken(fileRequest.getToken());
-            int page = fileRequest.getPage() != null ? fileRequest.getPage() : 1;
-            int pageSize = fileRequest.getPageSize() != null ? fileRequest.getPageSize() : 20;
-
-            FileResponse files = fileEntityService.getUserFiles(userId, page, pageSize, request.getVersion());
-
-            return new BaseResponse(request.getMsgId(),
-                    MessageCode.SUCCESS.getCode(),
-                    MessageCode.SUCCESS.getDescription(),
-                    files);
-
-        } catch (NotFoundAuthToken e) {
-            return new BaseResponse(request.getMsgId(),
-                    MessageCode.INVALID_TOKEN.getCode(),
-                    "Authentication required",
-                    null);
-        } catch (Exception e) {
-            log.error("Error getting user files", e);
-            return new BaseResponse(request.getMsgId(),
-                    MessageCode.FILE_UPLOAD_ERROR.getCode(),
-                    "Failed to get files: " + e.getMessage(),
-                    null);
-        }
-    }
-
-    private BaseResponse handleSearchFiles(BaseRequest request, FileEntityRequest fileRequest) {
-        try {
-            Long userId = getUserIdFromToken(fileRequest.getToken());
-            int page = fileRequest.getPage() != null ? fileRequest.getPage() : 1;
-            int pageSize = fileRequest.getPageSize() != null ? fileRequest.getPageSize() : 20;
-
-            if (fileRequest.getQuery() == null || fileRequest.getQuery().isBlank()) {
-                return handleGetUserFiles(request, fileRequest);
-            }
-
-            FileResponse allFiles = fileEntityService.getUserFiles(userId, 1, 1000, request.getVersion());
-
-            var filteredFiles = allFiles.getFiles().stream()
-                    .filter(f -> (f.getOriginalFileName() + f.getFileExtension()).toLowerCase()
-                            .contains(fileRequest.getQuery().toLowerCase()))
-                    .toList();
-
-            int start = (page - 1) * pageSize;
-            int end = Math.min(start + pageSize, filteredFiles.size());
-            List<FileEntityResponse> fileEntityResponses = filteredFiles.subList(start, Math.min(end, filteredFiles.size()));
-            long sumSize = fileEntityResponses.stream()
-                    .mapToLong(FileEntityResponse::getFileSize)
-                    .sum();
-
-            FileListResponse response = FileListResponse.builder()
-                    .files(fileEntityResponses)
-                    .totalCount(filteredFiles.size())
-                    .totalSize(sumSize)
-                    .formattedTotalSize(fileEntityService.formatFileSize(sumSize))
-                    .page(page)
-                    .pageSize(pageSize)
-                    .build();
-
-            return new BaseResponse(request.getMsgId(),
-                    MessageCode.SUCCESS.getCode(),
-                    MessageCode.SUCCESS.getDescription(),
-                    response);
-        } catch (NotFoundAuthToken e) {
-            return new BaseResponse(request.getMsgId(), MessageCode.INVALID_TOKEN.getCode(),
-                    "Authentication required", null);
-        } catch (Exception e) {
-            log.error("Error searching files", e);
-            return new BaseResponse(request.getMsgId(), MessageCode.FILE_UPLOAD_ERROR.getCode(),
-                    "Failed to search files: " + e.getMessage(), null);
-        }
-    }
-
-    private BaseResponse handleGetStorageUsage(BaseRequest request, FileEntityRequest fileRequest) {
-        try {
-            Long userId = getUserIdFromToken(fileRequest.getToken());
-            long usage = fileEntityService.getUserStorageUsed(userId);
-
-            StorageUsageResponse response = StorageUsageResponse.builder()
-                    .userId(userId)
-                    .storageUsed(usage)
-                    .formattedStorageUsed(formatFileSize(usage))
-                    .build();
-
-            return new BaseResponse(request.getMsgId(),
-                    MessageCode.SUCCESS.getCode(),
-                    MessageCode.SUCCESS.getDescription(),
-                    response);
-
-        } catch (NotFoundAuthToken e) {
-            return new BaseResponse(request.getMsgId(),
-                    MessageCode.INVALID_TOKEN.getCode(),
-                    "Authentication required",
-                    null);
-        } catch (Exception e) {
-            log.error("Error getting storage usage", e);
-            return new BaseResponse(request.getMsgId(),
-                    MessageCode.FILE_UPLOAD_ERROR.getCode(),
-                    "Failed to get storage usage: " + e.getMessage(),
-                    null);
-        }
-    }
-
-    private BaseResponse handleDeleteFile(BaseRequest request, FileEntityRequest fileRequest) {
-        try {
-            Long userId = getUserIdFromToken(fileRequest.getToken());
-            String fileId = fileRequest.getFileId();
-            FileEntityResponse fileInfo = fileEntityService.getById(fileId, request.getVersion());
-            DeleteFileResponse response;
-
-            if (!fileInfo.getUserId().equals(userId)) {
-                return new BaseResponse(request.getMsgId(),
-                        MessageCode.ACCESS_DENIED.getCode(),
-                        "Access denied",
-                        null);
-            }
-
-            FileEntity fileEntity = fileEntityRepository.findById(fileId)
-                    .orElseThrow(() -> new FileEntityNotFoundException(fileId));
-
-            if (fileEntity.getStatus().equals(FileStatus.DELETED)) {
-                fileEntityService.deleteFromDisk(fileEntity);
-                response = DeleteFileResponse.builder()
-                        .fileId(fileRequest.getFileId())
-                        .message("File deleted from disk")
-                        .build();
-            } else {
-                fileEntityService.markAsDeleted(fileEntity);
-                response = DeleteFileResponse.builder()
-                        .fileId(fileRequest.getFileId())
-                        .message("File marked as deleted")
-                        .build();
-            }
-
-            return new BaseResponse(request.getMsgId(),
-                    MessageCode.SUCCESS.getCode(),
-                    "File marked as deleted",
-                    response);
-        } catch (NotFoundAuthToken e) {
-            return new BaseResponse(request.getMsgId(),
-                    MessageCode.INVALID_TOKEN.getCode(),
-                    "Authentication required",
-                    null);
-        } catch (Exception e) {
-            log.error("Error deleting file", e);
-            return new BaseResponse(request.getMsgId(),
-                    MessageCode.FILE_UPLOAD_ERROR.getCode(),
-                    "Failed to delete file: " + e.getMessage(),
-                    null);
-        }
-    }
-
-    private Long getUserIdFromToken(String token) {
-        if (token == null || token.isBlank()) {
-            throw new NotFoundAuthToken("Token is required");
-        }
-
-        if (token.startsWith("Bearer ")) {
-            token = token.replace("Bearer ", "");
-        }
-
-        AuthToken authToken = authTokenRepository.findByToken(token)
-                .orElseThrow(() -> new NotFoundAuthToken("Token not found"));
-        return authToken.getUser().getId();
-    }
-
-    private String formatFileSize(long size) {
-        if (size < 1024) return size + " B";
-        int exp = (int) (Math.log(size) / Math.log(1024));
-        String pre = "KMGTPE".charAt(exp-1) + "";
-        return String.format("%.1f %sB", size / Math.pow(1024, exp), pre);
-    }
-}