Изменения в FileType.java

docker-compose.yaml

@@ -22,6 +22,9 @@ services:
     build: .
     container_name: app-backend
     environment:
+      FILE_STORAGE_PATH: /data/uploads
+      MAX_FILE_SIZE: 1073741824
+      FILE_CHUNK_SIZE: 5242880
       POSTGRES_DB: no_copy_
       POSTGRES_USER: postgres
       POSTGRES_PASSWORD: postgres
@@ -37,6 +40,8 @@ services:
           - app
           - backend
           - api
+    volumes:
+      - ./uploads:/data/uploads:rw
 
   grafana:
     image: grafana/grafana:10.3.1
@@ -141,6 +146,7 @@ volumes:
   loki_chunks:
   loki_index:
   loki_rules:
+#  uploads_volume:
 
 networks:
   app-network:

infrastructure/jenkins/deploy.groovy

@@ -54,26 +54,15 @@ pipeline {
                                 echo 'Step 1: Checking current state...'
                                 
                                 # Смотрим что запущено
-                                docker ps --filter 'name=postgres|app-backend' --format 'table {{.Names}}\\t{{.Image}}\\t{{.Status}}\\t{{.Ports}}'
+                                docker ps --filter 'name=postgres|app-backend' --format 'table {{.Names}}\\t{{.Status}}\\t{{.Ports}}'
                                 
-                                echo 'Step 2: Force cleanup old application...'
+                                echo 'Step 2: Stopping only application (keeping DB)...'
                                 
-                                # Принудительно удаляем старый контейнер и образ
+                                # Останавливаем только приложение, БД оставляем работать
                                 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
@@ -82,37 +71,13 @@ pipeline {
                                     echo 'PostgreSQL already running'
                                 fi
                                 
-                                echo 'Step 5: Build application with forced rebuild...'
+                                echo 'Step 3: Building new application image...'
-                                echo 'Checking Dockerfile exists:'
+                                docker build --no-cache -t app-backend:latest .
-                                ls -la Dockerfile 2>/dev/null || echo 'Dockerfile not found, creating simple one'
                                 
-                                # Если нет Dockerfile, создаем простой
+                                echo 'Step 4: Starting application...'
-                                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 \\
@@ -122,35 +87,17 @@ EOF
                                   --restart unless-stopped \\
                                   app-backend:latest
                                 
-                                echo 'Step 8: Checking deployment...'
+                                echo 'Step 5: Checking deployment...'
                                 sleep 10
                                 
                                 echo 'Containers status:'
-                                docker ps --filter 'name=postgres|app-backend' --format 'table {{.Names}}\\t{{.Image}}\\t{{.Status}}\\t{{.CreatedAt}}'
+                                docker ps --filter 'name=postgres|app-backend' --format 'table {{.Names}}\\t{{.Status}}\\t{{.Ports}}'
                                 
-                                echo 'Checking image inside container:'
+                                echo 'Application logs (last 5 lines):'
-                                docker exec app-backend ls -la /app/ 2>/dev/null || echo 'Cannot check container files'
+                                docker logs --tail=5 app-backend 2>/dev/null || echo 'Logs not available yet'
                                 
-                                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 'Deployment successful'
-                                    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'

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

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

@@ -15,7 +15,6 @@ import ru.soune.nocopy.dto.RegAnswer;
 import ru.soune.nocopy.exception.NotValidFieldException;
 import ru.soune.nocopy.exception.ValidationException;
 import ru.soune.nocopy.handler.LoginRequestHandler;
-import ru.soune.nocopy.handler.LogoutRequestHandler;
 import ru.soune.nocopy.handler.RegRequestHandler;
 import ru.soune.nocopy.handler.RequestHandler;
 
@@ -37,11 +36,9 @@ public class ApiController {
     public void init() {
         RegRequestHandler regHandler = applicationContext.getBean(RegRequestHandler.class);
         LoginRequestHandler loginHandler = applicationContext.getBean(LoginRequestHandler.class);
-        LogoutRequestHandler logoutHandler = applicationContext.getBean(LogoutRequestHandler.class);
 
-        handlers.put(20001, loginHandler);
         handlers.put(20002, regHandler);
-        handlers.put(20006, logoutHandler);
+        handlers.put(20001, loginHandler);
     }
 
     @PostMapping("/v{version}/data")

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

@@ -0,0 +1,37 @@
+package ru.soune.nocopy.controller;
+
+import lombok.RequiredArgsConstructor;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+import ru.soune.nocopy.entity.AuthToken;
+import ru.soune.nocopy.exception.TokenNotFoundException;
+import ru.soune.nocopy.repository.AuthTokenRepository;
+import ru.soune.nocopy.service.AuthService;
+
+import java.util.Map;
+import java.util.Optional;
+
+@RestController
+@RequestMapping("v1/api/auth")
+@RequiredArgsConstructor
+public class AuthController {
+
+    private final AuthService authService;
+
+    private final AuthTokenRepository authTokenRepository;
+
+    @PostMapping("/logout")
+    public ResponseEntity<?> logout(@RequestHeader("Authorization") String tokenHeader) {
+        String token = tokenHeader.replace("Bearer ", "");
+
+        Optional<AuthToken> opToken = authTokenRepository.findByToken(token);
+
+        if (opToken.isEmpty()) {
+            throw new TokenNotFoundException("Token not found");
+        }
+
+        authService.logout(token);
+
+        return ResponseEntity.ok(Map.of("success", true));
+    }
+}

src/main/java/ru/soune/nocopy/controller/file/FileUploadController.java

@@ -0,0 +1,224 @@
+package ru.soune.nocopy.controller.file;
+
+import jakarta.validation.Valid;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+import org.springframework.web.multipart.MultipartFile;
+import ru.soune.nocopy.dto.file.FileApiResponse;
+import ru.soune.nocopy.dto.file.InitUploadRequest;
+import ru.soune.nocopy.dto.file.UploadProgressResponse;
+import ru.soune.nocopy.entity.AuthToken;
+import ru.soune.nocopy.entity.file.FileType;
+import ru.soune.nocopy.entity.file.FileUploadSession;
+import ru.soune.nocopy.entity.file.UploadStatus;
+import ru.soune.nocopy.exception.FileUploadException;
+import ru.soune.nocopy.exception.NotFoundAuthToken;
+import ru.soune.nocopy.exception.UploadSessionNotFoundException;
+import ru.soune.nocopy.repository.AuthTokenRepository;
+import ru.soune.nocopy.repository.FileUploadSessionRepository;
+import ru.soune.nocopy.service.file.FileUploadService;
+
+import java.util.*;
+
+@Slf4j
+@RestController
+@RequestMapping("/api/files")
+@RequiredArgsConstructor
+public class FileUploadController {
+
+    private final FileUploadService fileUploadService;
+
+    private final AuthTokenRepository authTokenRepository;
+
+    private final FileUploadSessionRepository fileUploadSessionRepository;
+
+    //TODO ADD TEMPLATE JSON, RESPONSE OK,ADD MESSAGE CODE
+    @PostMapping("/init")
+    public ResponseEntity<FileApiResponse<FileUploadSession>> initUpload(@Valid @RequestBody InitUploadRequest request,
+                                                                         @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"));
+
+        try {
+            FileUploadSession session = fileUploadService.initUpload(authToken.getUser().getId(), request.getFileName(),
+                    request.getFileType(), request.getExtension(), request.getFileSize());
+
+            return ResponseEntity.ok(FileApiResponse.success(session));
+        } catch (Exception e) {
+            log.error("Error initializing upload", e);
+            return ResponseEntity.badRequest()
+                    .body(FileApiResponse.error(e.getMessage()));
+        }
+    }
+
+    @GetMapping("/file-types")
+    public ResponseEntity<List<FileType>> getFileTypes() {
+        return ResponseEntity.ok(Arrays.asList(FileType.values()));
+    }
+
+
+    @PostMapping("/chunk")
+    public ResponseEntity<FileApiResponse<UploadProgressResponse>> uploadChunk(
+            @RequestParam("uploadId") String uploadId,
+            @RequestParam("chunkNumber") Integer chunkNumber,
+            @RequestParam("chunk") MultipartFile chunk) {
+
+        log.info("Uploading chunk {} for session {}, file size: {} bytes",
+                chunkNumber, uploadId, chunk.getSize());
+
+        if (chunk.isEmpty()) {
+            return ResponseEntity.badRequest()
+                    .body(FileApiResponse.error("Chunk file is empty"));
+        }
+
+        if (uploadId == null || uploadId.isBlank()) {
+            return ResponseEntity.badRequest()
+                    .body(FileApiResponse.error("Upload ID is required"));
+        }
+
+        try {
+            UploadProgressResponse progress = fileUploadService.uploadChunk(
+                    uploadId, chunkNumber, chunk);
+
+            return ResponseEntity.ok(FileApiResponse.success(progress));
+
+        } catch (Exception e) {
+            log.error("Error uploading chunk", e);
+            return ResponseEntity.badRequest()
+                    .body(FileApiResponse.error(e.getMessage()));
+        }
+    }
+
+    @GetMapping("/progress/{uploadId}")
+    public ResponseEntity<FileApiResponse<UploadProgressResponse>> getProgress(
+            @PathVariable String uploadId) {
+
+        try {
+            UploadProgressResponse progress = fileUploadService.getUploadProgress(uploadId);
+            return ResponseEntity.ok(FileApiResponse.success(progress));
+
+        } catch (UploadSessionNotFoundException e) {
+            return ResponseEntity.status(HttpStatus.NOT_FOUND)
+                    .body(FileApiResponse.error("Upload session not found"));
+        } catch (Exception e) {
+            log.error("Error getting progress", e);
+            return ResponseEntity.badRequest()
+                    .body(FileApiResponse.error("Failed to get progress"));
+        }
+    }
+
+    @PostMapping("/{uploadId}/complete")
+    public ResponseEntity<FileApiResponse<UploadProgressResponse>> completeUpload(
+            @PathVariable String uploadId) {
+
+        log.info("Manual completion requested for session: {}", uploadId);
+
+        try {
+            UploadProgressResponse progress = fileUploadService.getUploadProgress(uploadId);
+
+            if (progress.getStatus() == UploadStatus.COMPLETED) {
+                return ResponseEntity.ok(FileApiResponse.success(
+                        "Upload already completed", progress));
+            }
+
+            if (progress.getUploadedChunks() < progress.getTotalChunks()) {
+                return ResponseEntity.badRequest()
+                        .body(FileApiResponse.error(
+                                String.format("Not all chunks uploaded: %d/%d",
+                                        progress.getUploadedChunks(), progress.getTotalChunks())));
+            }
+
+            return ResponseEntity.ok(FileApiResponse.success(
+                    "File assembly in progress", progress));
+
+        } catch (UploadSessionNotFoundException e) {
+            return ResponseEntity.status(HttpStatus.NOT_FOUND)
+                    .body(FileApiResponse.error("Upload session not found"));
+        } catch (Exception e) {
+            log.error("Error completing upload", e);
+            return ResponseEntity.internalServerError()
+                    .body(FileApiResponse.error("Failed to complete upload"));
+        }
+    }
+
+    @PostMapping("/{uploadId}/cancel")
+    public ResponseEntity<FileApiResponse<Void>> cancelUpload(
+            @PathVariable String uploadId) {
+
+        log.info("Cancelling upload session: {}", uploadId);
+
+        try {
+            fileUploadService.cancelUpload(uploadId);
+            return ResponseEntity.ok(FileApiResponse.success(
+                    "Upload cancelled successfully", null));
+
+        } catch (UploadSessionNotFoundException e) {
+            return ResponseEntity.status(HttpStatus.NOT_FOUND)
+                    .body(FileApiResponse.error("Upload session not found"));
+        } catch (FileUploadException e) {
+            return ResponseEntity.badRequest()
+                    .body(FileApiResponse.error(e.getMessage()));
+        } catch (Exception e) {
+            log.error("Error cancelling upload", e);
+            return ResponseEntity.internalServerError()
+                    .body(FileApiResponse.error("Failed to cancel upload"));
+        }
+    }
+
+    @PostMapping("/{uploadId}/retry")
+    public ResponseEntity<FileApiResponse<UploadProgressResponse>> retryUpload(
+            @PathVariable String uploadId) {
+
+        log.info("Retry requested for failed upload: {}", uploadId);
+
+        try {
+            fileUploadService.retryFailedUpload(uploadId);
+            UploadProgressResponse progress = fileUploadService.getUploadProgress(uploadId);
+
+            return ResponseEntity.ok(FileApiResponse.success(
+                    "Upload retry initiated", progress));
+
+        } catch (UploadSessionNotFoundException e) {
+            return ResponseEntity.status(HttpStatus.NOT_FOUND)
+                    .body(FileApiResponse.error("Upload session not found"));
+        } catch (FileUploadException e) {
+            return ResponseEntity.badRequest()
+                    .body(FileApiResponse.error(e.getMessage()));
+        } catch (Exception e) {
+            log.error("Error retrying upload", e);
+            return ResponseEntity.internalServerError()
+                    .body(FileApiResponse.error("Failed to retry upload"));
+        }
+    }
+
+    @GetMapping("/{uploadId}/chunks")
+    public ResponseEntity<FileApiResponse<Map<Integer, Boolean>>> getChunkStatus(
+            @PathVariable String uploadId) {
+
+        try {
+            FileUploadSession session = fileUploadSessionRepository.findById(uploadId)
+                    .orElseThrow(() -> new UploadSessionNotFoundException(uploadId));
+
+            Map<Integer, Boolean> chunkStatus = new HashMap<>();
+            for (int i = 0; i < session.getTotalChunks(); i++) {
+                chunkStatus.put(i, session.getChunkPaths().containsKey(i));
+            }
+
+            return ResponseEntity.ok(FileApiResponse.success(chunkStatus));
+
+        } catch (UploadSessionNotFoundException e) {
+            return ResponseEntity.status(HttpStatus.NOT_FOUND)
+                    .body(FileApiResponse.error("Upload session not found"));
+        } catch (Exception e) {
+            log.error("Error getting chunk status", e);
+            return ResponseEntity.internalServerError()
+                    .body(FileApiResponse.error("Failed to get chunk status"));
+        }
+    }
+}

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

@@ -4,9 +4,14 @@ import lombok.AllArgsConstructor;
 import lombok.Data;
 import lombok.NoArgsConstructor;
 
+import java.util.List;
+import java.util.Map;
+
 @Data
 @AllArgsConstructor
 @NoArgsConstructor
 public class LogOutAnswer {
-    private String email;
+    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

@@ -9,8 +9,6 @@ public enum MessageCode {
     MSG_ID_NOT_FOUND(4, "Message id not found"),
 
     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"),
     AUTH_PASSWORD_NOT_MATCHES(2, "Password does not match");
 
     private final Integer code;

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

@@ -1,7 +1,7 @@
 package ru.soune.nocopy.dto;
 
 import ru.soune.nocopy.entity.ContentStatus;
-import ru.soune.nocopy.entity.FileType;
+import ru.soune.nocopy.entity.file.FileType;
 
 import java.time.LocalDateTime;
 

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

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

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

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

@@ -4,6 +4,7 @@ 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;
 

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

@@ -1,4 +1,4 @@
-package ru.soune.nocopy.entity;
+package ru.soune.nocopy.entity.file;
 
 import lombok.Getter;
 

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

@@ -0,0 +1,92 @@
+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 = "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);
+        this.chunksUploaded = 0;
+        if (this.status == null) {
+            this.status = UploadStatus.INITIATED;
+        }
+    }
+}

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

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

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

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

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

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

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

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

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()));
-    }
-}

src/main/java/ru/soune/nocopy/repository/FileUploadSessionRepository.java

@@ -0,0 +1,30 @@
+package ru.soune.nocopy.repository;
+
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.jpa.repository.Query;
+import org.springframework.data.repository.query.Param;
+import org.springframework.stereotype.Repository;
+import ru.soune.nocopy.entity.file.FileUploadSession;
+import ru.soune.nocopy.entity.file.UploadStatus;
+
+import java.time.LocalDateTime;
+import java.util.List;
+import java.util.Set;
+
+@Repository
+public interface FileUploadSessionRepository extends JpaRepository<FileUploadSession, String> {
+
+    List<FileUploadSession> findByUserId(Long userId);
+
+    List<FileUploadSession> findByStatus(UploadStatus status);
+
+    @Query("SELECT s FROM FileUploadSession s WHERE s.status IN :statuses AND s.createdAt < :threshold")
+    List<FileUploadSession> findByStatusInAndCreatedAtBefore(
+            @Param("statuses") Set<UploadStatus> statuses,
+            @Param("threshold") LocalDateTime threshold);
+
+    @Query("SELECT s FROM FileUploadSession s WHERE s.expiresAt < :now AND s.status IN :statuses")
+    List<FileUploadSession> findExpiredSessions(
+            @Param("now") LocalDateTime now,
+            @Param("statuses") Set<UploadStatus> statuses);
+}

src/main/java/ru/soune/nocopy/repository/UserContentRepository.java

@@ -2,7 +2,7 @@ package ru.soune.nocopy.repository;
 
 import org.springframework.data.domain.Pageable;
 import org.springframework.data.jpa.repository.JpaRepository;
-import ru.soune.nocopy.entity.FileType;
+import ru.soune.nocopy.entity.file.FileType;
 import ru.soune.nocopy.entity.UserContent;
 
 import java.util.List;

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

@@ -5,7 +5,7 @@ import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 import ru.soune.nocopy.dto.UserContentRequest;
 import ru.soune.nocopy.dto.UserContentUpdateRequest;
-import ru.soune.nocopy.entity.FileType;
+import ru.soune.nocopy.entity.file.FileType;
 import ru.soune.nocopy.entity.User;
 import ru.soune.nocopy.entity.UserContent;
 import ru.soune.nocopy.exception.ContentNotFoundException;

src/main/java/ru/soune/nocopy/service/file/FileCleanupService.java

@@ -0,0 +1,80 @@
+package ru.soune.nocopy.service.file;
+
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.scheduling.annotation.Scheduled;
+import org.springframework.stereotype.Component;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+
+import java.io.IOException;
+import java.nio.file.*;
+import java.nio.file.attribute.BasicFileAttributes;
+import java.time.Instant;
+import java.time.LocalDateTime;
+import java.time.ZoneId;
+
+@Slf4j
+@Component
+@RequiredArgsConstructor
+public class FileCleanupService {
+
+    @Value("${file.storage.base-path}")
+    private String basePath;
+
+    @Value("${file.storage.temp-ttl-hours}")
+    private int tempTtlHours;
+
+    @Scheduled(cron = "0 0 3 * * *")
+    public void cleanupExpiredFiles() {
+        log.info("Starting cleanup of expired temporary files");
+
+        Path tempDir = Paths.get(basePath, "temp");
+        if (!Files.exists(tempDir)) {
+            return;
+        }
+
+        try {
+            Files.walkFileTree(tempDir, new SimpleFileVisitor<Path>() {
+                @Override
+                public FileVisitResult visitFile(Path file, BasicFileAttributes attrs)
+                        throws IOException {
+
+                    LocalDateTime fileTime = LocalDateTime.ofInstant(
+                            Instant.ofEpochMilli(attrs.lastModifiedTime().toMillis()),
+                            ZoneId.systemDefault()
+                    );
+
+                    LocalDateTime cutoffTime = LocalDateTime.now()
+                            .minusHours(tempTtlHours);
+
+                    if (fileTime.isBefore(cutoffTime)) {
+                        Files.delete(file);
+                        log.debug("Deleted expired file: {}", file);
+                    }
+
+                    return FileVisitResult.CONTINUE;
+                }
+
+                @Override
+                public FileVisitResult postVisitDirectory(Path dir, IOException exc)
+                        throws IOException {
+
+                    if (exc == null) {
+                        if (Files.list(dir).count() == 0 &&
+                                !dir.equals(tempDir)) {
+                            Files.delete(dir);
+                            log.debug("Deleted empty directory: {}", dir);
+                        }
+                    }
+
+                    return FileVisitResult.CONTINUE;
+                }
+            });
+
+            log.info("Cleanup completed successfully");
+
+        } catch (IOException e) {
+            log.error("Error during cleanup", e);
+        }
+    }
+}

src/main/java/ru/soune/nocopy/service/file/FileUploadService.java

@@ -0,0 +1,23 @@
+package ru.soune.nocopy.service.file;
+
+import org.springframework.web.multipart.MultipartFile;
+import ru.soune.nocopy.dto.file.UploadProgressResponse;
+import ru.soune.nocopy.entity.file.FileUploadSession;
+
+import java.io.IOException;
+
+public interface FileUploadService {
+    FileUploadSession initUpload(Long userId, String fileName,
+                                 String fileType, String extension, long fileSize);
+
+    UploadProgressResponse uploadChunk(String uploadId, Integer chunkNumber,
+                                       MultipartFile chunkFile) throws IOException;
+
+    UploadProgressResponse getUploadProgress(String uploadId);
+
+    void cleanupExpiredSessions();
+
+    public void retryFailedUpload(String uploadId);
+
+    public void cancelUpload(String uploadId);
+}

src/main/java/ru/soune/nocopy/service/file/FileUploadServiceImpl.java

@@ -0,0 +1,667 @@
+package ru.soune.nocopy.service.file;
+
+import jakarta.annotation.PostConstruct;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.scheduling.annotation.Async;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+import org.springframework.web.multipart.MultipartFile;
+import ru.soune.nocopy.dto.file.UploadProgressResponse;
+import ru.soune.nocopy.entity.file.FileUploadSession;
+import ru.soune.nocopy.entity.file.UploadStatus;
+import ru.soune.nocopy.exception.ChunkSizeExceededException;
+import ru.soune.nocopy.exception.FileUploadException;
+import ru.soune.nocopy.exception.UploadSessionNotFoundException;
+import ru.soune.nocopy.repository.FileUploadSessionRepository;
+
+import java.io.*;
+import java.nio.file.*;
+import java.nio.file.attribute.PosixFilePermission;
+import java.security.MessageDigest;
+import java.security.NoSuchAlgorithmException;
+import java.time.LocalDateTime;
+import java.util.Comparator;
+import java.util.HashSet;
+import java.util.Set;
+import java.util.UUID;
+import java.util.concurrent.CompletableFuture;
+import java.util.stream.Stream;
+
+@Slf4j
+@Service
+@RequiredArgsConstructor
+public class FileUploadServiceImpl implements FileUploadService {
+
+    private final FileUploadSessionRepository sessionRepository;
+
+    @Value("${file.storage.base-path}")
+    private String basePath;
+
+    @Value("${file.storage.chunk-size}")
+    private int chunkSize;
+
+    @Value("${file.storage.max-file-size}")
+    private long maxFileSize;
+
+    @Value("${file.storage.max-retry-attempts:3}")
+    private int maxRetryAttempts;
+
+    @Value("${file.storage.chunk-timeout-ms:300000}") // 5 минут
+    private long chunkTimeoutMs;
+
+    @Value("${file.storage.session-expiry-hours:24}")
+    private int sessionExpiryHours;
+
+    private Path storageRoot;
+
+    @PostConstruct
+    public void init() {
+        try {
+            storageRoot = Paths.get(basePath).toAbsolutePath().normalize();
+            log.info("Initializing file storage at: {}", storageRoot);
+
+            createDirectoryIfNotExists(storageRoot);
+            createDirectoryIfNotExists(storageRoot.resolve("temp"));
+            createDirectoryIfNotExists(storageRoot.resolve("uploads"));
+
+            if (!System.getProperty("os.name").toLowerCase().contains("win")) {
+                setDirectoryPermissions(storageRoot);
+            }
+
+            log.info("File storage initialized successfully");
+
+        } catch (IOException e) {
+            log.error("Failed to initialize file storage at: {}", basePath, e);
+            throw new RuntimeException("Storage initialization failed", e);
+        }
+    }
+
+    @Override
+    @Transactional
+    public FileUploadSession initUpload(Long userId, String fileName,
+                                        String fileType, String extension, long fileSize) {
+        log.info("Initializing upload for user {}: {} ({} bytes, type: {})",
+                userId, fileName, fileSize, fileType);
+
+        if (fileSize > maxFileSize) {
+            throw new FileUploadException(
+                    String.format("File size %d exceeds maximum allowed size %d",
+                            fileSize, maxFileSize));
+        }
+
+        if (fileSize <= 0) {
+            throw new FileUploadException("File size must be positive");
+        }
+
+        int totalChunks = (int) Math.ceil((double) fileSize / chunkSize);
+        log.debug("File will be split into {} chunks (chunk size: {} bytes)",
+                totalChunks, chunkSize);
+
+        FileUploadSession session = FileUploadSession.builder()
+                .userId(userId)
+                .extension(extension)
+                .fileName(fileName)
+                .fileType(fileType)
+                .fileSize(fileSize)
+                .totalChunks(totalChunks)
+                .chunksUploaded(0)
+                .status(UploadStatus.INITIATED)
+                .expiresAt(LocalDateTime.now().plusHours(sessionExpiryHours))
+                .retryCount(0)
+                .build();
+
+        FileUploadSession savedSession = sessionRepository.save(session);
+        log.info("Upload session created: {} for file: {}",
+                savedSession.getUploadId(), fileName);
+
+        return savedSession;
+    }
+
+    @Override
+    @Transactional
+    public UploadProgressResponse uploadChunk(String uploadId, Integer chunkNumber,
+                                              MultipartFile chunkFile) {
+
+        log.info("Processing chunk {} for session {}, size: {} bytes",
+                chunkNumber, uploadId, chunkFile.getSize());
+
+        FileUploadSession session = sessionRepository.findById(uploadId)
+                .orElseThrow(() -> new UploadSessionNotFoundException(uploadId));
+
+        validateSession(session);
+
+        if (session.getExpiresAt().isBefore(LocalDateTime.now())) {
+            handleExpiredSession(session);
+            throw new FileUploadException("Upload session expired");
+        }
+
+        if (chunkNumber < 0 || chunkNumber >= session.getTotalChunks()) {
+            throw new FileUploadException(
+                    String.format("Invalid chunk number %d. Expected 0-%d",
+                            chunkNumber, session.getTotalChunks() - 1));
+        }
+
+        if (chunkFile.getSize() > chunkSize) {
+            throw new ChunkSizeExceededException(chunkFile.getSize(), chunkSize);
+        }
+
+        return processChunk(session, chunkNumber, chunkFile);
+    }
+
+    private void validateSession(FileUploadSession session) {
+        UploadStatus status = session.getStatus();
+
+        if (status == UploadStatus.FAILED) {
+            if (session.getRetryCount() >= maxRetryAttempts) {
+                throw new FileUploadException(
+                        "Upload failed after maximum retry attempts");
+            }
+            session.setStatus(UploadStatus.UPLOADING);
+            session.setRetryCount(session.getRetryCount() + 1);
+            sessionRepository.save(session);
+            log.info("Retrying failed upload session: {}, attempt: {}",
+                    session.getUploadId(), session.getRetryCount());
+        }
+
+        if (status == UploadStatus.COMPLETED) {
+            throw new FileUploadException("Upload already completed");
+        }
+
+        if (status == UploadStatus.CANCELLED) {
+            throw new FileUploadException("Upload was cancelled");
+        }
+
+        if (status == UploadStatus.INITIATED) {
+            session.setStatus(UploadStatus.UPLOADING);
+            sessionRepository.save(session);
+        }
+    }
+
+    private void handleExpiredSession(FileUploadSession session) {
+        session.setStatus(UploadStatus.FAILED);
+        session.setLastError("Upload session expired");
+        sessionRepository.save(session);
+
+        CompletableFuture.runAsync(() -> cleanupSessionFiles(session));
+    }
+
+    private UploadProgressResponse processChunk(FileUploadSession session,
+                                                Integer chunkNumber,
+                                                MultipartFile chunkFile) {
+        String chunkPath = null;
+
+        try {
+            if (session.getChunkPaths().containsKey(chunkNumber)) {
+                return handleExistingChunk(session, chunkNumber, chunkFile);
+            }
+
+            chunkPath = saveChunkWithIntegrityCheck(session, chunkNumber, chunkFile);
+
+            session.getChunkPaths().put(chunkNumber, chunkPath);
+            session.setChunksUploaded(session.getChunksUploaded() + 1);
+            session.setStatus(UploadStatus.UPLOADING);
+
+            log.debug("Chunk {} saved successfully. Uploaded: {}/{}",
+                    chunkNumber, session.getChunksUploaded(), session.getTotalChunks());
+
+            if (session.getChunksUploaded().equals(session.getTotalChunks())) {
+                log.info("All chunks uploaded for session {}. Starting assembly...",
+                        session.getUploadId());
+                sessionRepository.save(session);
+                assembleFileAsync(session);
+            } else {
+                sessionRepository.save(session);
+            }
+
+            return UploadProgressResponse.fromSession(session);
+
+        } catch (Exception e) {
+            if (chunkPath != null) {
+                cleanupFailedChunk(chunkPath);
+            }
+
+            log.error("Failed to process chunk {} for session {}: {}",
+                    chunkNumber, session.getUploadId(), e.getMessage(), e);
+
+            session.setStatus(UploadStatus.FAILED);
+            session.setLastError(e.getMessage());
+            sessionRepository.save(session);
+
+            throw new FileUploadException("Failed to upload chunk: " + e.getMessage(), e);
+        }
+    }
+
+    private UploadProgressResponse handleExistingChunk(FileUploadSession session,
+                                                       Integer chunkNumber,
+                                                       MultipartFile chunkFile) throws IOException {
+        String existingPath = session.getChunkPaths().get(chunkNumber);
+        Path chunkPath = Paths.get(existingPath);
+
+        if (!Files.exists(chunkPath)) {
+            log.warn("Chunk file missing, re-uploading: {}", chunkPath);
+            session.getChunkPaths().remove(chunkNumber);
+            session.setChunksUploaded(session.getChunksUploaded() - 1);
+            sessionRepository.save(session);
+            return processChunk(session, chunkNumber, chunkFile);
+        }
+
+        long existingSize = Files.size(chunkPath);
+        if (existingSize != chunkFile.getSize()) {
+            log.warn("Chunk size mismatch, re-uploading: {} != {}",
+                    existingSize, chunkFile.getSize());
+            Files.deleteIfExists(chunkPath);
+            session.getChunkPaths().remove(chunkNumber);
+            session.setChunksUploaded(session.getChunksUploaded() - 1);
+            sessionRepository.save(session);
+            return processChunk(session, chunkNumber, chunkFile);
+        }
+
+        log.debug("Chunk {} already uploaded and valid", chunkNumber);
+        return UploadProgressResponse.fromSession(session);
+    }
+
+    private String saveChunkWithIntegrityCheck(FileUploadSession session,
+                                               Integer chunkNumber,
+                                               MultipartFile chunkFile) throws IOException {
+
+        Long userId = session.getUserId();
+        String uploadId = session.getUploadId();
+
+        Path chunkDir = getChunkDirectory(userId, uploadId);
+        Files.createDirectories(chunkDir);
+
+        String tempFileName = String.format("chunk_%04d.%s.tmp",
+                chunkNumber, UUID.randomUUID());
+        String finalFileName = String.format("chunk_%04d.tmp", chunkNumber);
+
+        Path tempPath = chunkDir.resolve(tempFileName);
+        Path finalPath = chunkDir.resolve(finalFileName);
+
+        try {
+            chunkFile.transferTo(tempPath.toFile());
+
+            long savedSize = Files.size(tempPath);
+            long uploadedSize = chunkFile.getSize();
+
+            if (uploadedSize > 0 && savedSize != uploadedSize) {
+                throw new IOException(
+                        String.format("Size mismatch: saved %d, uploaded %d",
+                                savedSize, uploadedSize));
+            }
+
+            Files.move(tempPath, finalPath, StandardCopyOption.ATOMIC_MOVE);
+
+            log.debug("Chunk {} saved successfully: {} bytes",
+                    chunkNumber, savedSize);
+
+            return finalPath.toString();
+
+        } finally {
+            Files.deleteIfExists(tempPath);
+        }
+    }
+
+    private void cleanupFailedChunk(String chunkPath) {
+        try {
+            Files.deleteIfExists(Paths.get(chunkPath));
+            log.debug("Cleaned up failed chunk: {}", chunkPath);
+        } catch (IOException e) {
+            log.warn("Failed to cleanup chunk: {}", chunkPath, e);
+        }
+    }
+
+    @Async("fileUploadTaskExecutor")
+    @Transactional
+    public void assembleFileAsync(FileUploadSession session) {
+        try {
+            assembleFile(session);
+            log.info("File assembly completed successfully for session: {}",
+                    session.getUploadId());
+
+        } catch (Exception e) {
+            log.error("Failed to assemble file for session {}: {}",
+                    session.getUploadId(), e.getMessage(), e);
+
+            handleAssemblyFailure(session, e);
+        }
+    }
+
+    private void assembleFile(FileUploadSession session) throws IOException {
+        log.info("Starting file assembly for session: {} ({})",
+                session.getUploadId(), session.getFileName());
+
+        Path finalFilePath = null;
+
+        try {
+            finalFilePath = prepareFinalFile(session);
+
+            validateAllChunksExist(session);
+
+            mergeChunksToFile(session, finalFilePath);
+
+            validateFinalFile(session, finalFilePath);
+
+            updateSessionOnSuccess(session, finalFilePath);
+
+            cleanupSessionFiles(session);
+
+            log.info("File assembly completed: {} -> {} ({} bytes)",
+                    session.getFileName(), finalFilePath, session.getFileSize());
+
+        } catch (Exception e) {
+            if (finalFilePath != null) {
+                Files.deleteIfExists(finalFilePath);
+            }
+            throw e;
+        }
+    }
+
+    private Path prepareFinalFile(FileUploadSession session) throws IOException {
+        Path userUploadsDir = storageRoot.resolve("uploads")
+                .resolve(String.valueOf(session.getUserId()))
+                .resolve(extractCategory(session.getFileType()));
+
+        Files.createDirectories(userUploadsDir);
+
+        String safeFileName = generateUniqueFileName(session.getFileName(), session.getExtension());
+        Path finalPath = userUploadsDir.resolve(safeFileName);
+
+        if (Files.exists(finalPath)) {
+            throw new IOException("File already exists: " + finalPath);
+        }
+
+        return finalPath;
+    }
+
+    private String generateUniqueFileName(String originalName, String extension) {
+        int dotIndex = originalName.lastIndexOf('.');
+        log.info("dotIndex: {}", dotIndex);
+        log.info("originalName: {}", originalName);
+        String nameWithoutExtension;
+
+        if (dotIndex > 0) {
+            nameWithoutExtension = originalName.substring(0, dotIndex)
+                    .replaceAll("[^a-zA-Z0-9\\-_]", "_");
+        } else {
+            nameWithoutExtension = originalName.replaceAll("[^a-zA-Z0-9\\-_]", "_");
+        }
+
+        String timestamp = String.valueOf(System.currentTimeMillis());
+        String uuid = UUID.randomUUID().toString().substring(0, 8);
+
+        return String.format("%s_%s_%s.%s",
+                nameWithoutExtension, timestamp, uuid, extension);
+    }
+
+    private void validateAllChunksExist(FileUploadSession session) throws IOException {
+        Path chunkDir = getChunkDirectory(session.getUserId(), session.getUploadId());
+
+        for (int i = 0; i < session.getTotalChunks(); i++) {
+            Path chunkPath = chunkDir.resolve(String.format("chunk_%04d.tmp", i));
+            if (!Files.exists(chunkPath)) {
+                throw new IOException("Missing chunk: " + chunkPath.getFileName());
+            }
+
+            if (Files.size(chunkPath) == 0) {
+                throw new IOException("Empty chunk: " + chunkPath.getFileName());
+            }
+        }
+    }
+
+    private void mergeChunksToFile(FileUploadSession session, Path finalPath)
+            throws IOException {
+
+        Path chunkDir = getChunkDirectory(session.getUserId(), session.getUploadId());
+        byte[] buffer = new byte[8192];
+
+        try (BufferedOutputStream outputStream = new BufferedOutputStream(
+                Files.newOutputStream(finalPath, StandardOpenOption.CREATE_NEW))) {
+
+            long totalWritten = 0;
+
+            for (int i = 0; i < session.getTotalChunks(); i++) {
+                Path chunkPath = chunkDir.resolve(String.format("chunk_%04d.tmp", i));
+
+                try (BufferedInputStream inputStream = new BufferedInputStream(
+                        Files.newInputStream(chunkPath))) {
+
+                    int bytesRead;
+                    while ((bytesRead = inputStream.read(buffer)) != -1) {
+                        outputStream.write(buffer, 0, bytesRead);
+                        totalWritten += bytesRead;
+                    }
+                }
+
+                if (log.isDebugEnabled()) {
+                    log.debug("Processed chunk {}: {} bytes (total: {})",
+                            i, Files.size(chunkPath), totalWritten);
+                }
+            }
+
+            outputStream.flush();
+            log.info("Total bytes written to final file: {}", totalWritten);
+        }
+    }
+
+    private void validateFinalFile(FileUploadSession session, Path finalPath)
+            throws IOException {
+
+        long actualSize = Files.size(finalPath);
+
+        if (actualSize != session.getFileSize()) {
+            throw new IOException(
+                    String.format("File size mismatch: expected %d, got %d",
+                            session.getFileSize(), actualSize));
+        }
+
+        String checksum = calculateChecksum(finalPath);
+        log.debug("Final file checksum: {}", checksum);
+    }
+
+    private void updateSessionOnSuccess(FileUploadSession session, Path finalPath) {
+        session.setFilePath(finalPath.toString());
+        session.setChecksum(calculateChecksum(finalPath));
+        session.setStatus(UploadStatus.COMPLETED);
+        session.setCompletedAt(LocalDateTime.now());
+        sessionRepository.save(session);
+    }
+
+    private void cleanupSessionFiles(FileUploadSession session) {
+        try {
+            Path chunkDir = getChunkDirectory(session.getUserId(), session.getUploadId());
+            if (Files.exists(chunkDir)) {
+                deleteDirectoryRecursively(chunkDir);
+                log.info("Cleaned up temp directory for session: {}",
+                        session.getUploadId());
+            }
+        } catch (IOException e) {
+            log.warn("Failed to cleanup temp files for session {}: {}",
+                    session.getUploadId(), e.getMessage());
+        }
+    }
+
+    private void deleteDirectoryRecursively(Path directory) throws IOException {
+        try (Stream<Path> walk = Files.walk(directory)) {
+            walk.sorted(Comparator.reverseOrder())
+                    .forEach(path -> {
+                        try {
+                            Files.deleteIfExists(path);
+                        } catch (IOException e) {
+                            log.warn("Failed to delete: {}", path, e);
+                        }
+                    });
+        }
+    }
+
+    private void handleAssemblyFailure(FileUploadSession session, Exception e) {
+        session.setStatus(UploadStatus.FAILED);
+        session.setLastError(e.getMessage());
+        sessionRepository.save(session);
+
+        log.error("File assembly failed for session {}: {}",
+                session.getUploadId(), e.getMessage());
+    }
+
+    @Override
+    @Transactional
+    public void cancelUpload(String uploadId) {
+        FileUploadSession session = sessionRepository.findById(uploadId)
+                .orElseThrow(() -> new UploadSessionNotFoundException(uploadId));
+
+        if (session.getStatus() == UploadStatus.COMPLETED) {
+            throw new FileUploadException("Cannot cancel completed upload");
+        }
+
+        session.setStatus(UploadStatus.CANCELLED);
+        sessionRepository.save(session);
+
+        CompletableFuture.runAsync(() -> cleanupSessionFiles(session));
+
+        log.info("Upload cancelled: {}", uploadId);
+    }
+
+    @Override
+    @Transactional
+    public void retryFailedUpload(String uploadId) {
+        FileUploadSession session = sessionRepository.findById(uploadId)
+                .orElseThrow(() -> new UploadSessionNotFoundException(uploadId));
+
+        if (session.getStatus() != UploadStatus.FAILED) {
+            throw new FileUploadException("Only failed uploads can be retried");
+        }
+
+        if (session.getRetryCount() >= maxRetryAttempts) {
+            throw new FileUploadException("Max retry attempts exceeded");
+        }
+
+        session.setStatus(UploadStatus.UPLOADING);
+        session.setRetryCount(session.getRetryCount() + 1);
+        session.setLastError(null);
+        sessionRepository.save(session);
+
+        if (session.getChunksUploaded().equals(session.getTotalChunks())) {
+            log.info("Retrying file assembly for session: {}", uploadId);
+            assembleFileAsync(session);
+        }
+
+        log.info("Upload retry initiated for session: {} (attempt {})",
+                uploadId, session.getRetryCount());
+    }
+
+    @Override
+    public UploadProgressResponse getUploadProgress(String uploadId) {
+        FileUploadSession session = sessionRepository.findById(uploadId)
+                .orElseThrow(() -> new UploadSessionNotFoundException(uploadId));
+
+        return UploadProgressResponse.fromSession(session);
+    }
+
+    @Override
+    @Transactional
+    public void cleanupExpiredSessions() {
+        log.info("Starting cleanup of expired upload sessions");
+
+        LocalDateTime expiryThreshold = LocalDateTime.now().minusHours(sessionExpiryHours);
+
+        try {
+            var expiredSessions = sessionRepository.findByStatusInAndCreatedAtBefore(
+                    Set.of(UploadStatus.INITIATED, UploadStatus.UPLOADING, UploadStatus.FAILED),
+                    expiryThreshold
+            );
+
+            int cleanedCount = 0;
+            for (FileUploadSession session : expiredSessions) {
+                session.setStatus(UploadStatus.FAILED);
+                session.setLastError("Session expired during cleanup");
+                sessionRepository.save(session);
+
+                CompletableFuture.runAsync(() -> cleanupSessionFiles(session));
+                cleanedCount++;
+            }
+
+            log.info("Cleaned up {} expired upload sessions", cleanedCount);
+
+        } catch (Exception e) {
+            log.error("Error during session cleanup", e);
+        }
+    }
+
+    private Path getChunkDirectory(Long userId, String uploadId) {
+        return storageRoot.resolve("temp")
+                .resolve("user")
+                .resolve(String.valueOf(userId))
+                .resolve(uploadId);
+    }
+
+    private String extractCategory(String fileType) {
+        if (fileType == null) {
+            return "other";
+        }
+
+        String lowerType = fileType.toLowerCase();
+        if (lowerType.startsWith("image")) {
+            return "images";
+        } else if (lowerType.startsWith("video")) {
+            return "videos";
+        } else if (lowerType.startsWith("audio")) {
+            return "audio";
+        } else if (lowerType.contains("document")) {
+            return "documents";
+        } else {
+            return "other";
+        }
+    }
+
+    private String calculateChecksum(Path filePath) {
+        try {
+            MessageDigest md = MessageDigest.getInstance("SHA-256");
+            byte[] buffer = new byte[8192];
+
+            try (InputStream inputStream = Files.newInputStream(filePath)) {
+                int bytesRead;
+                while ((bytesRead = inputStream.read(buffer)) != -1) {
+                    md.update(buffer, 0, bytesRead);
+                }
+            }
+
+            byte[] digest = md.digest();
+            StringBuilder sb = new StringBuilder();
+            for (byte b : digest) {
+                sb.append(String.format("%02x", b));
+            }
+
+            return sb.toString();
+
+        } catch (NoSuchAlgorithmException | IOException e) {
+            log.warn("Failed to calculate checksum for file: {}", filePath, e);
+            return "N/A";
+        }
+    }
+
+    private void createDirectoryIfNotExists(Path directory) throws IOException {
+        if (!Files.exists(directory)) {
+            Files.createDirectories(directory);
+            log.debug("Created directory: {}", directory);
+        }
+    }
+
+    private void setDirectoryPermissions(Path directory) throws IOException {
+        try {
+            Set<PosixFilePermission> permissions = new HashSet<>();
+            permissions.add(PosixFilePermission.OWNER_READ);
+            permissions.add(PosixFilePermission.OWNER_WRITE);
+            permissions.add(PosixFilePermission.OWNER_EXECUTE);
+            permissions.add(PosixFilePermission.GROUP_READ);
+            permissions.add(PosixFilePermission.GROUP_EXECUTE);
+            permissions.add(PosixFilePermission.OTHERS_READ);
+
+            Files.setPosixFilePermissions(directory, permissions);
+            log.debug("Set permissions for directory: {}", directory);
+
+        } catch (UnsupportedOperationException e) {
+            log.debug("Posix permissions not supported on this system");
+        }
+    }
+}

src/main/resources/application.yaml

@@ -9,10 +9,37 @@ spring:
     hibernate:
       ddl-auto: update
     show-sql: true
+    properties:
+      hibernate:
+        dialect: org.hibernate.dialect.PostgreSQLDialect
+        format_sql: true
+
+  servlet:
+    multipart:
+      max-file-size: 10MB
+      max-request-size: 100MB
+      enabled: true
+      resolve-lazily: false
+
+file:
+  storage:
+    base-path: ${FILE_STORAGE_PATH:/data/uploads}
+    chunk-size: ${FILE_CHUNK_SIZE:5242880}  # 5MB
+    max-file-size: ${MAX_FILE_SIZE:10737418240}  # 10GB
+    max-retry-attempts: ${MAX_RETRY_ATTEMPTS:3}
+    chunk-timeout-ms: ${CHUNK_TIMEOUT_MS:300000}  # 5 минут
+    temp-ttl-hours: ${TEMP_TTL_HOURS:72}  # 3 дня
+    session-expiry-hours: ${SESSION_EXPIRY_HOURS:24}
 
 server:
   port: ${SERVER_PORT:8080}
 
 logging:
   level:
-    root: INFO
+    com.example.fileupload: DEBUG
+    org.springframework.web: DEBUG
+    org.hibernate.SQL: DEBUG
+  file:
+    name: logs/application.log
+  pattern:
+    console: "%d{yyyy-MM-dd HH:mm:ss} [%thread] %-5level %logger{36} - %msg%n"