fix type GF_AUTH

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

@@ -13,18 +13,12 @@ services:
     volumes:
       - pgdata:/var/lib/postgresql/data
     container_name: postgres
-    networks:
-      app-network:
-        aliases:
-          - database
 
   app:
-    build: .
-    container_name: app-backend
+#    image: popovtsev/ncp
+    build:  .
+    container_name: no_copy_app
     environment:
-      FILE_STORAGE_PATH: /data/uploads
-      MAX_FILE_SIZE: 1073741824
-      FILE_CHUNK_SIZE: 5242880
       POSTGRES_DB: no_copy_
       POSTGRES_USER: postgres
       POSTGRES_PASSWORD: postgres
@@ -33,15 +27,7 @@ services:
     depends_on:
       - db
     ports:
-      - "80:8080"
-    networks:
-      app-network:
-        aliases:
-          - app
-          - backend
-          - api
-    volumes:
-      - ./uploads:/data/uploads:rw
+      - "8080:8080"
 
   grafana:
     image: grafana/grafana:10.3.1
@@ -58,7 +44,7 @@ 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"
@@ -70,8 +56,6 @@ services:
       interval: 10s
       timeout: 5s
       retries: 10
-    networks:
-      - app-network
 
   prometheus:
     image: prom/prometheus:latest
@@ -85,8 +69,6 @@ services:
       interval: 10s
       timeout: 5s
       retries: 5
-    networks:
-      - app-network
 
   loki:
     image: grafana/loki:2.9.2
@@ -100,8 +82,6 @@ services:
       interval: 10s
       timeout: 5s
       retries: 5
-    networks:
-      - app-network
 
   tempo:
     image: grafana/tempo:2.4.1
@@ -112,17 +92,15 @@ services:
       - tempo_data:/var/tempo
     ports:
       - "3200:3200"
-    networks:
-      - app-network
 
   alloy:
     image: grafana/alloy:latest
     container_name: alloy
     user: root
     ports:
-      - "9080:9080"
-      - "4317:4317"
-      - "4318:4318"
+      - "9080:9080" # HTTP interface
+      - "4317:4317" # OTLP gRPC
+      - "4318:4318" # OTLP http
     volumes:
       - ./infrastructure/alloy/config.alloy:/etc/alloy/config.alloy:ro
       - /var/lib/docker/containers:/var/lib/docker/containers:ro
@@ -135,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:
@@ -145,10 +121,4 @@ volumes:
   loki_data:
   loki_chunks:
   loki_index:
-  loki_rules:
-#  uploads_volume:
-
-networks:
-  app-network:
-    external: true
-    driver: bridge
+  loki_rules:

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,180 +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 $SSH_USER@$SERVER "mkdir -p /opt/deployments/${params.BRANCH}"
-                            sshpass -p '$SSH_PASS' scp -r ./* $SSH_USER@$SERVER:/opt/deployments/${params.BRANCH}/
-                            
-                            sshpass -p '$SSH_PASS' ssh $SSH_USER@$SERVER "
-                                cd /opt/deployments/${params.BRANCH}
-                                
-                                echo 'Step 1: Checking current state...'
-                                
-                                # Смотрим что запущено
-                                docker ps --filter 'name=postgres|app-backend' --format 'table {{.Names}}\\t{{.Image}}\\t{{.Status}}\\t{{.Ports}}'
-                                
-                                echo 'Step 2: Force cleanup old application...'
-                                
-                                # Принудительно удаляем старый контейнер и образ
-                                docker stop app-backend 2>/dev/null || echo 'App not running'
-                                docker rm app-backend 2>/dev/null || echo 'App not found'
-                                docker rmi app-backend:latest 2>/dev/null || echo 'Image not found'
-                                
-                                # Удаляем все образы app-backend
-                                docker images --filter 'reference=app-backend*' -q | xargs -r docker rmi 2>/dev/null || echo 'No images to remove'
-                                
-                                echo 'Step 3: Verify copied files...'
-                                echo 'Files in directory:'
-                                ls -la
-                                echo ''
-                                echo 'Checking Java sources:'
-                                find . -name '*.java' | head -2
-                                
-                                echo 'Step 4: Check if PostgreSQL is running...'
-                                if ! docker ps | grep -q postgres; then
-                                    echo 'Starting PostgreSQL...'
-                                    docker-compose up -d db
-                                    sleep 10
-                                else
-                                    echo 'PostgreSQL already running'
-                                fi
-                                
-                                echo 'Step 5: Build application with forced rebuild...'
-                                echo 'Checking Dockerfile exists:'
-                                ls -la Dockerfile 2>/dev/null || echo 'Dockerfile not found, creating simple one'
-                                
-                                # Если нет Dockerfile, создаем простой
-                                if [ ! -f Dockerfile ]; then
-                                    echo 'Creating simple Dockerfile...'
-                                    cat > Dockerfile << 'EOF'
-FROM eclipse-temurin:21-jre
-WORKDIR /app
-COPY . /app/
-CMD ["java", "-jar", "app.jar"]
-EOF
-                                fi
-                                
-                                # Собираем с подробным выводом
-                                echo 'Building Docker image...'
-                                docker build --no-cache --progress=plain -t app-backend:latest . 2>&1 | tail -50
-                                
-                                echo 'Step 6: Verify new image...'
-                                echo 'Current app-backend images:'
-                                docker images | grep app-backend
-                                
-                                echo 'Image creation time:'
-                                docker inspect app-backend:latest --format='{{.Created}}' 2>/dev/null || echo 'Cannot inspect image'
-                                
-                                echo 'Step 7: Starting application with alias...'
-                                docker run -d \\
-                                  --name app-backend \\
-                                  --network app-network \\
-                                  --network-alias app \\
-                                  -p 80:8080 \\
-                                  -e POSTGRES_DB=no_copy_ \\
-                                  -e POSTGRES_USER=postgres \\
-                                  -e POSTGRES_PASSWORD=postgres \\
-                                  -e POSTGRES_PORT=5432 \\
-                                  -e POSTGRES_HOST=db \\
-                                  --restart unless-stopped \\
-                                  app-backend:latest
-                                
-                                echo 'Step 8: Checking deployment...'
-                                sleep 10
-                                
-                                echo 'Containers status:'
-                                docker ps --filter 'name=postgres|app-backend' --format 'table {{.Names}}\\t{{.Image}}\\t{{.Status}}\\t{{.CreatedAt}}'
-                                
-                                echo 'Checking image inside container:'
-                                docker exec app-backend ls -la /app/ 2>/dev/null || echo 'Cannot check container files'
-                                
-                                echo 'Application logs (last 10 lines):'
-                                docker logs --tail=10 app-backend 2>/dev/null || echo 'Logs not available yet'
-                                
-                                echo 'Step 9: Health check...'
-                                if docker ps | grep -q app-backend; then
-                                    echo 'Container is running'
-                                    echo 'Testing application health...'
-                                    for i in {1..5}; do
-                                        if curl -s -f http://localhost:80/health > /dev/null 2>&1; then
-                                            echo 'Health check passed'
-                                            echo 'Deployment successful'
-                                            echo 'Application URL: http://${params.SERVER}:80'
-                                            exit 0
-                                        fi
-                                        echo 'Waiting for application to start... attempt ' \$i
-                                        sleep 5
-                                    done
-                                    
-                                    echo 'Health check failed, but container is running'
-                                    echo 'Application might be starting slowly'
-                                    echo 'Application URL: http://${params.SERVER}:80'
-                                else
-                                    echo 'Application failed to start'
-                                    docker logs app-backend
-                                    exit 1
-                                fi
-                            "
-                        """
-                    }
-                }
-            }
-        }
-    }
-
-    post {
-        success {
-            echo "Deployment successful"
-            echo "Application URL: http://${params.SERVER}:80"
-        }
-        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,4 +1,4 @@
-package ru.soune.nocopy;
+package ru.soune.no_copy;
 
 import org.springframework.boot.SpringApplication;
 import org.springframework.boot.autoconfigure.SpringBootApplication;

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,30 +1,25 @@
-package ru.soune.nocopy.entity;
+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 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;
-
-    @ManyToOne(fetch = FetchType.LAZY)
-    @JoinColumn(name = "user_id", nullable = false)
-    @ToString.Exclude
-    private User user;
+    private Long id;
 
     @Column(nullable = false, unique = true, length = 64)
     private String token;
@@ -36,13 +31,7 @@ public class AuthToken {
     @Column(name = "created_at", updatable = false, nullable = false)
     private LocalDateTime createdAt;
 
-    @Column(name = "last_used_at")
-    private LocalDateTime lastUsedAt;
-
-    @Column(name = "is_active")
-    private Boolean isActive = true;
-
-    public boolean isValid() {
-        return Boolean.TRUE.equals(isActive) && expiresAt.isAfter(LocalDateTime.now());
-    }
+    @ManyToOne(fetch = FetchType.LAZY)
+    @JoinColumn(name = "user_id", nullable = false)
+    private User user;
 }

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)
-    @ResponseStatus(HttpStatus.OK)
-    public ResponseEntity<?> handleUserContainsException(NotValidFieldException ex) {
-
-        return ResponseEntity
-                .ok()
-                .body(ex.getBaseResponse());
-    }
-
-    @ExceptionHandler(UserNotFoundException.class)
-    @ResponseStatus(HttpStatus.NOT_FOUND)
-    public ResponseEntity<?> handleUserNotFoundException(UserNotFoundException ex) {
+    @ExceptionHandler(UserAlreadyExistsException.class)
+    @ResponseStatus(HttpStatus.CONFLICT)
+    public ResponseEntity<?> handleUserContainsException(UserAlreadyExistsException 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.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

@@ -1,13 +1,12 @@
-package ru.soune.nocopy.repository;
+package ru.soune.no_copy.repository;
 
-import jakarta.validation.constraints.Size;
 import org.springframework.data.jpa.repository.JpaRepository;
-import ru.soune.nocopy.entity.User;
+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);
-    boolean existsByPhone(@Size(min = 11, max = 14) String phone);
 }

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.nocopy.entity.AuthToken;
-import ru.soune.nocopy.entity.User;
-import ru.soune.nocopy.exception.NotValidFieldException;
-import ru.soune.nocopy.repository.AuthTokenRepository;
-import ru.soune.nocopy.repository.UserRepository;
+import ru.soune.no_copy.dto.LoginRequest;
+import ru.soune.no_copy.dto.RegisterRequest;
+import ru.soune.no_copy.entity.AuthToken;
+import ru.soune.no_copy.entity.User;
+import ru.soune.no_copy.exception.NotValidationPasswordException;
+import ru.soune.no_copy.exception.UserAlreadyExistsException;
+import ru.soune.no_copy.exception.UserNotFoundException;
+import ru.soune.no_copy.repository.AuthTokenRepository;
+import ru.soune.no_copy.repository.UserRepository;
 
 import java.security.SecureRandom;
-import java.time.LocalDateTime;
-import java.util.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.setEmail(registerRequest.getEmail());
-        user.setPassword(passwordEncoder.encode(registerRequest.getPassword()));
-
-        if (registerRequest.getCompanyName() != null) {
-            user.setCompany(registerRequest.getCompanyName());
-        }
-
-        if (registerRequest.getPhone() != null) {
-            user.setPhone(registerRequest.getPhone());
-        }
+        user.setFirstName(registerRequest.firstName());
+        user.setSecondName(registerRequest.secondName());
+        user.setLastName(registerRequest.lastName());
+        user.setEmail(registerRequest.email());
+        user.setPassword(passwordEncoder.encode(registerRequest.password()));
 
         User savedUser = userRepository.save(user);
 
@@ -60,28 +60,24 @@ 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();
-            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));
+            throw new NotValidationPasswordException("Invalid password");
         }
 
-        user.setLastLoginAt(LocalDateTime.now());
-        User savedUser = userRepository.save(user);
-
         AuthToken authToken = new AuthToken();
         authToken.setToken(generateAuthToken());
-        authToken.setUser(savedUser);
+        authToken.setUser(user);
 
         return authTokenRepository.save(authToken);
     }
 
-    @Transactional
     public void logout(String token) {
         authTokenRepository.findByToken(token)
                 .ifPresent(authTokenRepository::delete);

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,403 +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.AuthToken;
-import ru.soune.nocopy.entity.file.UploadStatus;
-import ru.soune.nocopy.exception.NotFoundAuthToken;
-import ru.soune.nocopy.exception.NotValidFieldException;
-import ru.soune.nocopy.exception.ValidationException;
-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("upload_id") String uploadId,
-            @RequestParam("chunk_number") Integer chunkNumber,
-            @RequestParam("chunk") MultipartFile chunk) {
-
-        log.info("Uploading chunk {} for session {}, file size: {} bytes, version: {}",
-                chunkNumber, uploadId, chunk.getSize(), version);
-
-        if (chunk.isEmpty()) {
-            return ResponseEntity.ok().body(new BaseResponse(20004, MessageCode.FILE_UPLOAD_ERROR.getCode(),
-                    "Chunk file is empty", null));
-        }
-
-        if (uploadId == null || uploadId.isBlank()) {
-            return ResponseEntity.ok().body(new BaseResponse(20004, MessageCode.FILE_UPLOAD_ERROR.getCode(),
-                    "Upload ID is required", null));
-        }
-
-        if (chunkNumber == null || chunkNumber < 0) {
-            return ResponseEntity.ok().body(new BaseResponse(20004, MessageCode.FILE_UPLOAD_ERROR.getCode(),
-                    "Valid chunk number is required", null));
-        }
-
-        try {
-            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<Resource> downloadFile(
-            @PathVariable String fileId,
-            @PathVariable Integer version,
-            @RequestHeader("Authorization") String tokenHeader) {
-
-        try {
-            Long userId = getUserIdFromToken(tokenHeader);
-            FileEntityResponse fileInfo = fileEntityService.getById(fileId, version);
-
-            if (!fileInfo.getUserId().equals(userId)) {
-                return ResponseEntity.status(403).build();
-            }
-
-            if (!fileInfo.isExistsOnDisk()) {
-                return ResponseEntity.status(404)
-                        .body(null);
-            }
-
-            Path filePath = Paths.get(fileInfo.getFilePath());
-            Resource resource = new UrlResource(filePath.toUri());
-
-            if (!resource.exists()) {
-                return ResponseEntity.status(404).build();
-            }
-
-            String contentType = determineContentType(filePath);
-
-            return ResponseEntity.ok()
-                    .contentType(MediaType.parseMediaType(contentType))
-                    .header(HttpHeaders.CONTENT_DISPOSITION,
-                            "attachment; filename=\"" + fileInfo.getOriginalFileName() + "\"")
-                    .header(HttpHeaders.CONTENT_LENGTH, String.valueOf(fileInfo.getFileSize()))
-                    .body(resource);
-
-        } catch (NotFoundAuthToken e) {
-            return ResponseEntity.status(401).build();
-        } catch (Exception e) {
-            log.error("Error downloading file", e);
-            return ResponseEntity.status(500).build();
-        }
-    }
-
-    @GetMapping("/v{version}/files/info/{fileId}")
-    public ResponseEntity<FileEntityResponse> getFileInfo(
-            @PathVariable String fileId,
-            @PathVariable Integer version,
-            @RequestHeader("Authorization") String tokenHeader) {
-
-        try {
-            Long userId = getUserIdFromToken(tokenHeader);
-            FileEntityResponse fileInfo = fileEntityService.getById(fileId, version);
-
-            if (!fileInfo.getUserId().equals(userId)) {
-                return ResponseEntity.status(403).build();
-            }
-
-            return ResponseEntity.ok(fileInfo);
-
-        } catch (NotFoundAuthToken e) {
-            return ResponseEntity.status(401).build();
-        } catch (Exception e) {
-            log.error("Error getting file info", e);
-            return ResponseEntity.status(500).build();
-        }
-    }
-
-    @GetMapping("/v{version}/files/preview/{fileId}")
-    public ResponseEntity<Resource> previewFile(
-            @PathVariable String fileId,
-            @PathVariable Integer version,
-            @RequestHeader("Authorization") String tokenHeader) {
-
-        try {
-            Long userId = getUserIdFromToken(tokenHeader);
-            FileEntityResponse fileInfo = fileEntityService.getById(fileId, version);
-
-            if (!fileInfo.getUserId().equals(userId)) {
-                return ResponseEntity.status(403).build();
-            }
-
-            if (!isPreviewSupported(fileInfo.getMimeType())) {
-                return ResponseEntity.status(415)
-                        .body(null);
-            }
-
-            Path filePath = Paths.get(fileInfo.getFilePath());
-            Resource resource = new UrlResource(filePath.toUri());
-
-            if (!resource.exists()) {
-                return ResponseEntity.status(404).build();
-            }
-
-            String contentType = determineContentType(filePath);
-
-            return ResponseEntity.ok()
-                    .contentType(MediaType.parseMediaType(contentType))
-                    .header(HttpHeaders.CONTENT_DISPOSITION,
-                            "inline; filename=\"" + fileInfo.getOriginalFileName() + "\"")
-                    .body(resource);
-
-        } catch (NotFoundAuthToken e) {
-            return ResponseEntity.status(401).build();
-        } catch (Exception e) {
-            log.error("Error previewing file", e);
-            return ResponseEntity.status(500).build();
-        }
-    }
-
-
-    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("application/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.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/dto/AuthResponse.java

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

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,38 +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"),
-    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/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,93 +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 java.time.LocalDate;
-import java.time.LocalDateTime;
-import java.util.ArrayList;
-import java.util.List;
-
-@Entity
-@Table(name = "users")
-@Getter
-@Setter
-@NoArgsConstructor
-@AllArgsConstructor
-@ToString
-@EntityListeners(AuditingEntityListener.class)
-public class User {
-
-    @Id
-    @GeneratedValue(strategy = GenerationType.IDENTITY)
-    private Long Id;
-
-    @Column(name = "full_name", nullable = false)
-    private String fullName;
-
-    @Size(max = 1024)
-    @Column(name = "email", nullable = false, length = 1024, unique = true)
-    private String email;
-
-    @Column(name = "company")
-    private String company;
-
-    @Column(nullable = false)
-    @Size(min = 6)
-    @JsonIgnore
-    private String password;
-
-    @Size(min = 11, max = 14)
-    @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<>();
-}

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/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,8 +0,0 @@
-package ru.soune.nocopy.entity.file;
-
-public enum FileStatus {
-    ACTIVE,
-    DELETED,
-    PROCESSING,
-    ERROR
-}

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

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

src/main/java/ru/soune/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().plusHours(24);
-        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 exceeded: %d > %d", actualSize, maxSize));
-    }
-}

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,293 +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.AuthToken;
-import ru.soune.nocopy.exception.NotFoundAuthToken;
-import ru.soune.nocopy.repository.AuthTokenRepository;
-import ru.soune.nocopy.service.file.FileEntityService;
-
-import java.util.Arrays;
-
-@Slf4j
-@Component
-@RequiredArgsConstructor
-public class FileEntityHandler implements RequestHandler {
-
-    private final FileEntityService fileEntityService;
-    private final AuthTokenRepository authTokenRepository;
-    private final ObjectMapper objectMapper;
-
-    @Override
-    public BaseResponse handle(BaseRequest request) {
-        try {
-            FileEntityRequest fileRequest = objectMapper.convertValue(
-                    request.getMessageBody(), FileEntityRequest.class);
-
-            String action = fileRequest.getAction();
-
-            switch (action) {
-                case "get_file_info":
-                    return handleGetFileInfo(request, fileRequest);
-                case "get_file_by_session":
-                    return handleGetFileBySession(request, fileRequest);
-                case "get_user_files":
-                    return handleGetUserFiles(request, fileRequest);
-                case "search_files":
-                    return handleSearchFiles(request, fileRequest);
-                case "get_storage_usage":
-                    return handleGetStorageUsage(request, fileRequest);
-                case "delete_file":
-                    return handleDeleteFile(request, fileRequest);
-                default:
-                    ActionResponse response = ActionResponse.builder()
-                            .action(action)
-                            .availableActions(Arrays.asList(
-                                    "get_file_info", "get_file_by_session", "get_user_files",
-                                    "search_files", "get_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 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().toLowerCase().contains(fileRequest.getQuery().toLowerCase()))
-                    .toList();
-
-            int start = (page - 1) * pageSize;
-            int end = Math.min(start + pageSize, filteredFiles.size());
-
-            FileListResponse response = FileListResponse.builder()
-                    .files(filteredFiles.subList(start, Math.min(end, filteredFiles.size())))
-                    .totalCount(filteredFiles.size())
-                    .totalSize(allFiles.getTotalSize())
-                    .formattedTotalSize(allFiles.getFormattedTotalSize())
-                    .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());
-            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);
-            }
-
-            fileEntityService.markAsDeleted(fileRequest.getFileId());
-
-            DeleteFileResponse 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);
-    }
-}

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

@@ -1,243 +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 org.springframework.validation.BeanPropertyBindingResult;
-import org.springframework.validation.BindingResult;
-import ru.soune.nocopy.dto.*;
-import ru.soune.nocopy.dto.file.*;
-import ru.soune.nocopy.entity.AuthToken;
-import ru.soune.nocopy.entity.file.FileType;
-import ru.soune.nocopy.entity.file.FileUploadSession;
-import ru.soune.nocopy.exception.*;
-import ru.soune.nocopy.handler.validator.FileUploadRequestValidator;
-import ru.soune.nocopy.repository.AuthTokenRepository;
-import ru.soune.nocopy.repository.FileUploadSessionRepository;
-import ru.soune.nocopy.service.file.FileUploadService;
-
-import java.util.Arrays;
-import java.util.HashMap;
-import java.util.Map;
-import java.util.Optional;
-
-@Slf4j
-@Component
-@RequiredArgsConstructor
-public class FileUploadHandler implements RequestHandler {
-    private final FileUploadService fileUploadService;
-    private final AuthTokenRepository authTokenRepository;
-    private final FileUploadSessionRepository fileUploadSessionRepository;
-    private final ObjectMapper objectMapper;
-    private final FileUploadRequestValidator fileUploadRequestValidator;
-
-    @Override
-    public BaseResponse handle(BaseRequest request) {
-        try {
-            FileUploadRequest fileRequest = objectMapper.convertValue(
-                    request.getMessageBody(), FileUploadRequest.class);
-
-            String action = fileRequest.getAction();
-
-            switch (action) {
-                case "init":
-                    return handleInitUpload(request, fileRequest);
-                case "file_types":
-                    return handleGetFileTypes(request);
-                case "chunks":
-                    return handleGetChunkStatus(request, fileRequest);
-                case "cancel":
-                    return handleCancelUpload(request, fileRequest);
-                case "progress":
-                    return handleGetProgress(request, fileRequest);
-                case "retry":
-                    return handleRetryUpload(request, fileRequest);
-                default:
-                    ActionResponse response = ActionResponse.builder()
-                            .action(action)
-                            .availableActions(Arrays.asList("init", "file_types", "chunks", "cancel", "progress", "retry"))
-                            .build();
-
-                    return new BaseResponse(request.getMsgId(), MessageCode.INVALID_ACTION.getCode(),
-                            "Invalid action: " + action, response);
-            }
-        } catch (Exception e) {
-            log.error("Error in FileUploadHandler", e);
-            return new BaseResponse(request.getMsgId(), MessageCode.FILE_UPLOAD_ERROR.getCode(),
-                    "Handler error: " + e.getMessage(), null);
-        }
-    }
-
-    private BaseResponse handleInitUpload(BaseRequest request, FileUploadRequest fileRequest) {
-        try {
-            String token = fileRequest.getToken();
-
-            Optional<AuthToken> tokenOptional = authTokenRepository.findByToken(token);
-
-            AuthToken authToken = tokenOptional.orElseThrow(() -> new NotFoundAuthToken("Token not found"));
-
-            BindingResult bindingResult = new BeanPropertyBindingResult(fileRequest, "fileRequest");
-            fileUploadRequestValidator.validate(fileRequest, bindingResult);
-
-            if (bindingResult.hasErrors()) {
-                throw new ValidationException(bindingResult, request.getMsgId());
-            }
-
-            FileUploadSession session = fileUploadService.initUpload(
-                    authToken.getUser().getId(),
-                    fileRequest.getFileName(),
-                    fileRequest.getFileType(),
-                    fileRequest.getExtension(),
-                    fileRequest.getFileSize());
-
-            InitFileResponse fileResponse = InitFileResponse.builder()
-                    .uploadId(session.getUploadId())
-                    .fileName(session.getFileName())
-                    .totalChunks(session.getTotalChunks())
-                    .chunkSize(session.getChunkSize())
-                    .status(session.getStatus().toString())
-                    .build();
-
-            return new BaseResponse(request.getMsgId(), MessageCode.SUCCESS.getCode(),
-                    MessageCode.SUCCESS.getDescription(), fileResponse);
-
-        } catch (NotFoundAuthToken e) {
-            InitFileResponse initFileResponse = InitFileResponse.builder()
-                    .build();
-
-            throw new NotValidFieldException("Invalid or expired token: " + fileRequest.getToken(),
-                    new BaseResponse(request.getMsgId(), MessageCode.INVALID_TOKEN.getCode(),
-                            MessageCode.INVALID_TOKEN.getDescription(), initFileResponse));
-        }
-    }
-
-    private BaseResponse handleGetProgress(BaseRequest request, FileUploadRequest fileRequest) {
-        try {
-            ru.soune.nocopy.dto.file.UploadProgressResponse progress =
-                    fileUploadService.getUploadProgress(fileRequest.getUploadId());
-
-            UploadProgressResponse responseDto = UploadProgressResponse.builder()
-                    .uploadId(progress.getUploadId())
-                    .fileName(progress.getFileName())
-                    .totalChunks(progress.getTotalChunks())
-                    .uploadedChunks(progress.getUploadedChunks())
-                    .status(progress.getStatus())
-                    .progressPercentage(progress.getProgressPercentage())
-                    .filePath(progress.getFilePath())
-                    .build();
-
-            return new BaseResponse(request.getMsgId(), MessageCode.SUCCESS.getCode(),
-                    MessageCode.SUCCESS.getDescription(), responseDto);
-
-        } catch (UploadSessionNotFoundException e) {
-            return new BaseResponse(request.getMsgId(), MessageCode.FILE_NOT_FOUND.getCode(),
-                    MessageCode.FILE_NOT_FOUND.getDescription(), null);
-        } catch (Exception e) {
-            log.error("Error getting progress", e);
-            return new BaseResponse(request.getMsgId(), MessageCode.FILE_UPLOAD_ERROR.getCode(),
-                    MessageCode.FILE_UPLOAD_ERROR.getDescription(), null);
-        }
-    }
-
-    private BaseResponse handleCancelUpload(BaseRequest request, FileUploadRequest fileRequest) {
-        try {
-            fileUploadService.cancelUpload(fileRequest.getUploadId());
-
-            CanceledUploadResponse response = CanceledUploadResponse.builder()
-                    .uploadId(fileRequest.getUploadId())
-                    .message("Upload cancelled successfully")
-                    .build();
-
-            return new BaseResponse(request.getMsgId(), MessageCode.SUCCESS.getCode(),
-                    "Upload cancelled successfully", response);
-
-        } catch (UploadSessionNotFoundException e) {
-            return new BaseResponse(request.getMsgId(), MessageCode.FILE_NOT_FOUND.getCode(),
-                    "Upload session not found", null);
-        } catch (FileUploadException e) {
-            return new BaseResponse(request.getMsgId(), MessageCode.FILE_UPLOAD_ERROR.getCode(), e.getMessage(), null);
-        } catch (Exception e) {
-            log.error("Error cancelling upload", e);
-            return new BaseResponse(request.getMsgId(), MessageCode.FILE_UPLOAD_ERROR.getCode(),
-                    "Failed to cancel upload", null);
-        }
-    }
-
-    private BaseResponse handleRetryUpload(BaseRequest request, FileUploadRequest fileRequest) {
-        try {
-            fileUploadService.retryFailedUpload(fileRequest.getUploadId());
-            ru.soune.nocopy.dto.file.UploadProgressResponse progress =
-                    fileUploadService.getUploadProgress(fileRequest.getUploadId());
-
-            RetryUploadResponse response = RetryUploadResponse.builder()
-                    .uploadId(progress.getUploadId())
-                    .message("Upload retry initiated")
-                    .status(progress.getStatus().toString())
-                    .build();
-
-            return new BaseResponse(request.getMsgId(), MessageCode.SUCCESS.getCode(), "Upload retry initiated",
-                    response);
-
-        } catch (UploadSessionNotFoundException e) {
-            return new BaseResponse(request.getMsgId(), MessageCode.FILE_NOT_FOUND.getCode(),
-                    "Upload session not found", null);
-        } catch (FileUploadException e) {
-            return new BaseResponse(request.getMsgId(), MessageCode.FILE_UPLOAD_ERROR.getCode(), e.getMessage(),
-                    null);
-        } catch (Exception e) {
-            log.error("Error retrying upload", e);
-            return new BaseResponse(request.getMsgId(), MessageCode.FILE_UPLOAD_ERROR.getCode(),
-                    "Failed to retry upload", null);
-        }
-    }
-
-    private BaseResponse handleGetChunkStatus(BaseRequest request, FileUploadRequest fileRequest) {
-        try {
-            FileUploadSession session = fileUploadSessionRepository.findById(fileRequest.getUploadId())
-                    .orElseThrow(() -> new UploadSessionNotFoundException(fileRequest.getUploadId()));
-
-            Map<String, Boolean> chunkStatus = new HashMap<>();
-            for (int i = 0; i < session.getTotalChunks(); i++) {
-                chunkStatus.put("chunk_" + i, session.getChunkPaths().containsKey(i));
-            }
-
-            ChunkStatusResponse response = ChunkStatusResponse.builder()
-                    .uploadId(fileRequest.getUploadId())
-                    .totalChunks(session.getTotalChunks())
-                    .uploadedChunks(session.getChunksUploaded())
-                    .missingChunks(session.getTotalChunks() - session.getChunksUploaded())
-                    .chunkStatus(chunkStatus)
-                    .build();
-
-            return new BaseResponse(request.getMsgId(), MessageCode.SUCCESS.getCode(),
-                    MessageCode.SUCCESS.getDescription(), response);
-
-        } catch (UploadSessionNotFoundException e) {
-            return new BaseResponse(request.getMsgId(), MessageCode.FILE_NOT_FOUND.getCode(),
-                    "Upload session not found", null);
-        } catch (Exception e) {
-            log.error("Error getting chunk status", e);
-            return new BaseResponse(request.getMsgId(),
-                    MessageCode.FILE_UPLOAD_ERROR.getCode(), "Failed to get chunk status",
-                    null);
-        }
-    }
-
-    private BaseResponse handleGetFileTypes(BaseRequest request) {
-        try {
-            FileTypesResponse response = FileTypesResponse.builder()
-                    .fileTypes(Arrays.asList(FileType.values()))
-                    .count(FileType.values().length)
-                    .build();
-
-            return new BaseResponse(request.getMsgId(), MessageCode.SUCCESS.getCode(),
-                    MessageCode.SUCCESS.getDescription(), response);
-
-        } catch (Exception e) {
-            log.error("Error getting file types", e);
-            return new BaseResponse(request.getMsgId(), MessageCode.FILE_UPLOAD_ERROR.getCode(),
-                    "Failed to get file types", null);
-        }
-    }
-}

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

@@ -1,7 +0,0 @@
-package ru.soune.nocopy.handler;
-
-import org.springframework.stereotype.Component;
-
-@Component
-public class JwtTokenProvider {
-}

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

@@ -1,44 +0,0 @@
-package ru.soune.nocopy.handler;
-
-import com.fasterxml.jackson.databind.ObjectMapper;
-import lombok.RequiredArgsConstructor;
-import org.springframework.stereotype.Component;
-import ru.soune.nocopy.dto.*;
-import ru.soune.nocopy.entity.AuthToken;
-import ru.soune.nocopy.exception.NotValidFieldException;
-import ru.soune.nocopy.repository.UserRepository;
-import ru.soune.nocopy.service.AuthService;
-
-import java.util.Arrays;
-import java.util.Map;
-
-@Component
-@RequiredArgsConstructor
-public class LoginRequestHandler implements RequestHandler {
-
-    private final UserRepository userRepository;
-    private final AuthService authService;
-    private final ObjectMapper objectMapper;
-
-    @Override
-    public BaseResponse handle(BaseRequest request) {
-        LoginRequest loginRequest = objectMapper.convertValue(request.getMessageBody(), LoginRequest.class);
-
-        if (!userRepository.existsByEmail(loginRequest.getEmail())) {
-            LoginAnswer loginAnswer = new LoginAnswer();
-            loginAnswer.setFieldErrors(Arrays.asList(Map.of("email", loginRequest.getEmail())));
-
-            throw new NotValidFieldException("User with email not found: " + loginRequest.getEmail(),
-                    new BaseResponse(request.getMsgId(), MessageCode.AUTH_EMAIL_NOT_FOUND.getCode(),
-                            MessageCode.AUTH_EMAIL_NOT_FOUND.getDescription(), loginAnswer));
-        }
-
-        AuthToken authToken = authService.login(loginRequest);
-
-        LoginAnswer loginAnswer = new LoginAnswer();
-        loginAnswer.setToken(authToken.getToken());
-
-        return new BaseResponse(request.getMsgId(), MessageCode.SUCCESS.getCode(),
-                MessageCode.SUCCESS.getDescription(), loginAnswer);
-    }
-}

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

@@ -1,56 +0,0 @@
-package ru.soune.nocopy.handler;
-
-import com.fasterxml.jackson.databind.ObjectMapper;
-import lombok.RequiredArgsConstructor;
-import org.springframework.stereotype.Component;
-import ru.soune.nocopy.dto.*;
-import ru.soune.nocopy.entity.AuthToken;
-import ru.soune.nocopy.entity.User;
-import ru.soune.nocopy.exception.NotValidFieldException;
-import ru.soune.nocopy.repository.AuthTokenRepository;
-import ru.soune.nocopy.repository.UserRepository;
-import ru.soune.nocopy.service.AuthService;
-
-import java.util.Objects;
-import java.util.Optional;
-
-@Component
-@RequiredArgsConstructor
-public class LogoutRequestHandler implements RequestHandler {
-
-    private final AuthService authService;
-
-    private final AuthTokenRepository authTokenRepository;
-
-    private final ObjectMapper objectMapper;
-
-    private final UserRepository userRepository;
-
-    @Override
-    public BaseResponse handle(BaseRequest request) {
-        LogoutRequest logoutRequest = objectMapper.convertValue(request.getMessageBody(), LogoutRequest.class);
-
-        Optional<AuthToken> opToken = authTokenRepository.findByToken(logoutRequest.getToken());
-        Optional<User> user = userRepository.findByEmail(logoutRequest.getEmail());
-
-        if (opToken.isEmpty() || user.isEmpty()) {
-            throw new NotValidFieldException("User with email or token not found",
-                    new BaseResponse(request.getMsgId(), MessageCode.AUTH_EMAIL_OR_TOKEN_NOT_FOUND.getCode(),
-                            MessageCode.AUTH_EMAIL_OR_TOKEN_NOT_FOUND.getDescription(),
-                            new LogoutRequest(logoutRequest.getEmail(), logoutRequest.getToken())));
-        }
-
-        if (!Objects.equals(opToken.get().getUser().getId(), user.get().getId())) {
-            throw new NotValidFieldException("User token mismatch with user",
-                    new BaseResponse(request.getMsgId(), MessageCode.AUTH_TOKEN_MISMATCH.getCode(),
-                            MessageCode.AUTH_TOKEN_MISMATCH.getDescription(),
-                            new LogoutRequest(logoutRequest.getEmail(), logoutRequest.getToken())));
-        }
-
-
-        authService.logout(logoutRequest.getToken());
-
-        return new BaseResponse(request.getMsgId(), MessageCode.SUCCESS.getCode(), MessageCode.SUCCESS.getDescription(),
-                new LogOutAnswer(logoutRequest.getEmail()));
-    }
-}