fix path

build.gradle

@@ -29,19 +29,13 @@ dependencies {
 	implementation 'org.springframework.boot:spring-boot-starter-web'
 	implementation 'org.springframework.security:spring-security-crypto:6.5.3'
 	implementation 'org.mapstruct:mapstruct:1.5.5.Final'
-	implementation 'commons-validator:commons-validator:1.7'
-
 	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'

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

@@ -1,105 +0,0 @@
-package ru.soune.nocopy.controller;
-
-import jakarta.annotation.PostConstruct;
-import lombok.RequiredArgsConstructor;
-import lombok.extern.slf4j.Slf4j;
-import org.springframework.context.ApplicationContext;
-import org.springframework.http.ResponseEntity;
-import org.springframework.validation.BindingResult;
-import org.springframework.validation.FieldError;
-import org.springframework.web.bind.annotation.*;
-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.exception.NotValidFieldException;
-import ru.soune.nocopy.exception.ValidationException;
-import ru.soune.nocopy.handler.LoginRequestHandler;
-import ru.soune.nocopy.handler.RegRequestHandler;
-import ru.soune.nocopy.handler.RequestHandler;
-
-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 ApplicationContext applicationContext;
-
-    private Map<Integer, RequestHandler> handlers = new HashMap<>();
-
-    @PostConstruct
-    public void init() {
-        RegRequestHandler regHandler = applicationContext.getBean(RegRequestHandler.class);
-        LoginRequestHandler loginHandler = applicationContext.getBean(LoginRequestHandler.class);
-
-        handlers.put(20002, regHandler);
-        handlers.put(20001, loginHandler);
-    }
-
-    @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);
-        }
-    }
-
-    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;
-    }
-}

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

@@ -1,8 +1,13 @@
 package ru.soune.nocopy.controller;
 
+import jakarta.validation.Valid;
 import lombok.RequiredArgsConstructor;
 import org.springframework.http.ResponseEntity;
 import org.springframework.web.bind.annotation.*;
+import ru.soune.nocopy.dto.AuthResponse;
+import ru.soune.nocopy.dto.LoginRequest;
+import ru.soune.nocopy.dto.LoginResponse;
+import ru.soune.nocopy.dto.RegisterRequest;
 import ru.soune.nocopy.entity.AuthToken;
 import ru.soune.nocopy.exception.TokenNotFoundException;
 import ru.soune.nocopy.repository.AuthTokenRepository;
@@ -20,6 +25,22 @@ public class AuthController {
 
     private final AuthTokenRepository authTokenRepository;
 
+    @PostMapping("/register")
+    public ResponseEntity<AuthResponse> register(@Valid @RequestBody RegisterRequest registerRequest) {
+        AuthToken authToken = authService.register(registerRequest);
+
+        return ResponseEntity.ok(new AuthResponse(true, "success.user.register", authToken.getToken(),
+                authToken.getExpiresAt()));
+    }
+
+    @PostMapping("/login")
+    public ResponseEntity<LoginResponse> login(@Valid @RequestBody LoginRequest request) {
+        AuthToken login = authService.login(request);
+
+        return ResponseEntity.ok(new LoginResponse(true, login.getUser().getEmail(),
+                login.getToken(),login.getExpiresAt().toString()));
+    }
+
     @PostMapping("/logout")
     public ResponseEntity<?> logout(@RequestHeader("Authorization") String tokenHeader) {
         String token = tokenHeader.replace("Bearer ", "");

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

@@ -4,7 +4,7 @@ import org.springframework.http.HttpStatus;
 import org.springframework.web.bind.annotation.*;
 
 @RestController
-@RequestMapping("check/api")
+@RequestMapping("/api")
 public class HealtCheckController {
 
     @GetMapping("/healt")

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

@@ -0,0 +1,172 @@
+package ru.soune.nocopy.controller.file;
+
+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.web.bind.annotation.*;
+import ru.soune.nocopy.dto.file.FileEntityResponse;
+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.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+
+@Slf4j
+@RestController
+@RequestMapping("/api/files")
+@RequiredArgsConstructor
+public class FileDownloadController {
+
+    private final FileEntityService fileEntityService;
+    private final AuthTokenRepository authTokenRepository;
+
+    /**
+     * Скачать файл по ID FileEntity
+     */
+    @GetMapping("/download/{fileId}")
+    public ResponseEntity<Resource> downloadFile(
+            @PathVariable String fileId,
+            @RequestHeader("Authorization") String tokenHeader) {
+
+        try {
+            Long userId = getUserIdFromToken(tokenHeader);
+            FileEntityResponse fileInfo = fileEntityService.getById(fileId);
+
+            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("/preview/{fileId}")
+    public ResponseEntity<Resource> previewFile(
+            @PathVariable String fileId,
+            @RequestHeader("Authorization") String tokenHeader) {
+
+        try {
+            Long userId = getUserIdFromToken(tokenHeader);
+            FileEntityResponse fileInfo = fileEntityService.getById(fileId);
+
+            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();
+        }
+    }
+
+    /**
+     * Получить информацию о файле для фронтенда
+     */
+    @GetMapping("/info/{fileId}")
+    public ResponseEntity<FileEntityResponse> getFileInfo(
+            @PathVariable String fileId,
+            @RequestHeader("Authorization") String tokenHeader) {
+
+        try {
+            Long userId = getUserIdFromToken(tokenHeader);
+            FileEntityResponse fileInfo = fileEntityService.getById(fileId);
+
+            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();
+        }
+    }
+
+    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/file/FileEntityController.java

@@ -0,0 +1,210 @@
+package ru.soune.nocopy.controller.file;
+
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+import ru.soune.nocopy.dto.file.FileApiResponse;
+import ru.soune.nocopy.dto.file.FileEntityResponse;
+import ru.soune.nocopy.dto.file.FileListResponse;
+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;
+
+@Slf4j
+@RestController
+@RequestMapping("/api/file-entities")
+@RequiredArgsConstructor
+public class FileEntityController {
+
+    private final FileEntityService fileEntityService;
+    private final AuthTokenRepository authTokenRepository;
+
+    /**
+     * Получить информацию о файле по ID
+     */
+    @GetMapping("/{fileId}")
+    public ResponseEntity<FileApiResponse<FileEntityResponse>> getFileInfo(
+            @PathVariable String fileId,
+            @RequestHeader("Authorization") String tokenHeader) {
+
+        try {
+            Long userId = getUserIdFromToken(tokenHeader);
+            FileEntityResponse fileInfo = fileEntityService.getById(fileId);
+
+            if (!fileInfo.getUserId().equals(userId)) {
+                return ResponseEntity.status(403)
+                        .body(FileApiResponse.error("Access denied"));
+            }
+
+            return ResponseEntity.ok(FileApiResponse.success(fileInfo));
+
+        } catch (NotFoundAuthToken e) {
+            return ResponseEntity.status(401)
+                    .body(FileApiResponse.error("Authentication required"));
+        } catch (Exception e) {
+            log.error("Error getting file info", e);
+            return ResponseEntity.badRequest()
+                    .body(FileApiResponse.error("Failed to get file info: " + e.getMessage()));
+        }
+    }
+
+    /**
+     * Получить информацию о файле по ID сессии загрузки
+     */
+    @GetMapping("/by-session/{uploadSessionId}")
+    public ResponseEntity<FileApiResponse<FileEntityResponse>> getFileByUploadSession(
+            @PathVariable String uploadSessionId,
+            @RequestHeader("Authorization") String tokenHeader) {
+
+        try {
+            Long userId = getUserIdFromToken(tokenHeader);
+            FileEntityResponse fileInfo = fileEntityService.getByUploadSessionId(uploadSessionId);
+
+            if (!fileInfo.getUserId().equals(userId)) {
+                return ResponseEntity.status(403)
+                        .body(FileApiResponse.error("Access denied"));
+            }
+
+            return ResponseEntity.ok(FileApiResponse.success(fileInfo));
+
+        } catch (NotFoundAuthToken e) {
+            return ResponseEntity.status(401)
+                    .body(FileApiResponse.error("Authentication required"));
+        } catch (Exception e) {
+            log.error("Error getting file by session", e);
+            return ResponseEntity.badRequest()
+                    .body(FileApiResponse.error("Failed to get file: " + e.getMessage()));
+        }
+    }
+
+    /**
+     * Получить все файлы пользователя
+     */
+    @GetMapping("/my-files")
+    public ResponseEntity<FileApiResponse<FileListResponse>> getUserFiles(
+            @RequestHeader("Authorization") String tokenHeader,
+            @RequestParam(defaultValue = "1") int page,
+            @RequestParam(defaultValue = "20") int pageSize) {
+
+        try {
+            Long userId = getUserIdFromToken(tokenHeader);
+            FileListResponse files = fileEntityService.getUserFiles(userId, page, pageSize);
+
+            return ResponseEntity.ok(FileApiResponse.success(files));
+
+        } catch (NotFoundAuthToken e) {
+            return ResponseEntity.status(401)
+                    .body(FileApiResponse.error("Authentication required"));
+        } catch (Exception e) {
+            log.error("Error getting user files", e);
+            return ResponseEntity.badRequest()
+                    .body(FileApiResponse.error("Failed to get files: " + e.getMessage()));
+        }
+    }
+
+    /**
+     * Поиск файлов пользователя
+     */
+    @GetMapping("/search")
+    public ResponseEntity<FileApiResponse<FileListResponse>> searchFiles(
+            @RequestParam String query,
+            @RequestHeader("Authorization") String tokenHeader,
+            @RequestParam(defaultValue = "1") int page,
+            @RequestParam(defaultValue = "20") int pageSize) {
+
+        try {
+            Long userId = getUserIdFromToken(tokenHeader);
+            FileListResponse allFiles = fileEntityService.getUserFiles(userId, 1, 1000);
+
+            var filteredFiles = allFiles.getFiles().stream()
+                    .filter(f -> f.getOriginalFileName().toLowerCase().contains(query.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 ResponseEntity.ok(FileApiResponse.success(response));
+
+        } catch (NotFoundAuthToken e) {
+            return ResponseEntity.status(401)
+                    .body(FileApiResponse.error("Authentication required"));
+        } catch (Exception e) {
+            log.error("Error searching files", e);
+            return ResponseEntity.badRequest()
+                    .body(FileApiResponse.error("Failed to search files: " + e.getMessage()));
+        }
+    }
+
+    /**
+     * Получить общий размер файлов пользователя
+     */
+    @GetMapping("/storage/usage")
+    public ResponseEntity<FileApiResponse<Long>> getStorageUsage(
+            @RequestHeader("Authorization") String tokenHeader) {
+
+        try {
+            Long userId = getUserIdFromToken(tokenHeader);
+            long usage = fileEntityService.getUserStorageUsed(userId);
+
+            return ResponseEntity.ok(FileApiResponse.success(usage));
+
+        } catch (NotFoundAuthToken e) {
+            return ResponseEntity.status(401)
+                    .body(FileApiResponse.error("Authentication required"));
+        } catch (Exception e) {
+            log.error("Error getting storage usage", e);
+            return ResponseEntity.badRequest()
+                    .body(FileApiResponse.error("Failed to get storage usage: " + e.getMessage()));
+        }
+    }
+
+    /**
+     * Пометить файл как удаленный
+     */
+    @DeleteMapping("/{fileId}")
+    public ResponseEntity<FileApiResponse<Void>> deleteFile(
+            @PathVariable String fileId,
+            @RequestHeader("Authorization") String tokenHeader) {
+
+        try {
+            Long userId = getUserIdFromToken(tokenHeader);
+            FileEntityResponse fileInfo = fileEntityService.getById(fileId);
+
+            if (!fileInfo.getUserId().equals(userId)) {
+                return ResponseEntity.status(403)
+                        .body(FileApiResponse.error("Access denied"));
+            }
+
+            fileEntityService.markAsDeleted(fileId);
+
+            return ResponseEntity.ok(FileApiResponse.success(
+                    "File marked as deleted", null));
+
+        } catch (NotFoundAuthToken e) {
+            return ResponseEntity.status(401)
+                    .body(FileApiResponse.error("Authentication required"));
+        } catch (Exception e) {
+            log.error("Error deleting file", e);
+            return ResponseEntity.badRequest()
+                    .body(FileApiResponse.error("Failed to delete file: " + e.getMessage()));
+        }
+    }
+
+    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/dto/AuthResponse.java

@@ -0,0 +1,10 @@
+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/LogOutAnswer.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 LogOutAnswer {
-    private String Token;
-
-    private List<Map<String, String>> fieldErrors;
-}

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/LoginResponse.java

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

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

@@ -1,30 +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_JSON_BODY(2, "Invalid fields in JSON object"),
-    MSG_ID_NOT_FOUND(4, "Message id not found"),
-
-    AUTH_EMAIL_NOT_FOUND(4, "Email 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/RegisterRequest.java

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

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

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

@@ -0,0 +1,22 @@
+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 FileListResponse {
+
+    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/entity/User.java

@@ -42,7 +42,6 @@ public class User {
     private String password;
 
     @Size(min = 11, max = 14)
-    @Column(unique = true)
     private String phone;
 
     @Enumerated(EnumType.STRING)

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

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

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

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

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

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

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/GlobalExceptionHandler.java

@@ -29,13 +29,15 @@ public class GlobalExceptionHandler {
                         "message" ,message));
     }
 
-    @ExceptionHandler(NotValidFieldException.class)
-    @ResponseStatus(HttpStatus.OK)
-    public ResponseEntity<?> handleUserContainsException(NotValidFieldException ex) {
-
-        return ResponseEntity
-                .ok()
-                .body(ex.getBaseResponse());
+    @ExceptionHandler(UserAlreadyExistsException.class)
+    @ResponseStatus(HttpStatus.CONFLICT)
+    public ResponseEntity<?> handleUserContainsException(UserAlreadyExistsException ex) {
+        return ResponseEntity.
+                badRequest()
+                .body(Map.of(
+                        "success", false,
+                        "message" ,ex.getMessage()
+                ));
     }
 
     @ExceptionHandler(UserNotFoundException.class)

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/RegRequestHandler.java

@@ -1,62 +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.entity.AuthToken;
-import ru.soune.nocopy.exception.NotValidFieldException;
-import ru.soune.nocopy.exception.ValidationException;
-import ru.soune.nocopy.handler.validator.RegRequestValidator;
-import ru.soune.nocopy.repository.UserRepository;
-import ru.soune.nocopy.service.AuthService;
-
-import java.util.Arrays;
-import java.util.Map;
-
-@Slf4j
-@Component
-@RequiredArgsConstructor
-public class RegRequestHandler implements RequestHandler {
-    private final UserRepository userRepository;
-
-    private final RegRequestValidator regRequestValidator;
-
-    private final AuthService authService;
-
-    private final ObjectMapper objectMapper;
-
-    @Override
-    public BaseResponse handle(BaseRequest request) throws ValidationException {
-        RegRequest regRequest = objectMapper.convertValue(request.getMessageBody(), RegRequest.class);
-
-        if (userRepository.existsByEmail(regRequest.getEmail()) || userRepository.existsByPhone(regRequest.getPhone())) {
-            RegAnswer regAnswer = new RegAnswer();
-            regAnswer.setFieldErrors(Arrays.asList(Map.of("email", regRequest.getEmail())));
-            regAnswer.setFieldErrors(Arrays.asList(Map.of("phone", regRequest.getPhone())));
-
-            throw new NotValidFieldException("User already exists with email:" + regRequest.getEmail() + " or phone: " +
-                    regRequest.getPhone(), new BaseResponse(request.getMsgId(),
-                    MessageCode.REG_EMAIL_OR_PHONE_EXISTS.getCode(),
-                    MessageCode.REG_EMAIL_OR_PHONE_EXISTS.getDescription(), regAnswer));
-        }
-
-        BindingResult bindingResult = new BeanPropertyBindingResult(regRequest, "regRequest");
-        regRequestValidator.validate(regRequest, bindingResult);
-
-        if (bindingResult.hasErrors()) {
-            throw new ValidationException(bindingResult, request.getMsgId());
-        }
-
-        AuthToken authToken = authService.register(regRequest);
-
-        RegAnswer regAnswer = new RegAnswer();
-        regAnswer.setToken(authToken.getToken());
-
-        return new BaseResponse(request.getMsgId(), MessageCode.SUCCESS.getCode(),
-                MessageCode.SUCCESS.getDescription(), regAnswer);
-    }
-}

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

@@ -1,8 +0,0 @@
-package ru.soune.nocopy.handler;
-
-import ru.soune.nocopy.dto.BaseRequest;
-import ru.soune.nocopy.dto.BaseResponse;
-
-public interface RequestHandler {
-    BaseResponse handle(BaseRequest request) throws Exception;
-}

src/main/java/ru/soune/nocopy/handler/validator/RegRequestValidator.java

@@ -1,225 +0,0 @@
-package ru.soune.nocopy.handler.validator;
-
-import org.apache.commons.validator.routines.DomainValidator;
-import org.apache.commons.validator.routines.EmailValidator;
-import org.springframework.stereotype.Component;
-import org.springframework.validation.Errors;
-import org.springframework.validation.Validator;
-import ru.soune.nocopy.dto.RegRequest;
-
-import java.net.InetAddress;
-import java.net.UnknownHostException;
-import java.util.*;
-
-@Component
-public class RegRequestValidator implements Validator {
-    private static final String COMPANY_REGEX = "^[a-zA-Zа-яА-ЯёЁ0-9\\s\\-&.,'()]{0,200}$";
-
-    private static final String NAME_REGEX = "^[a-zA-Zа-яА-ЯёЁ\\s\\-'.]{2,100}$";
-
-    @Override
-    public boolean supports(Class<?> clazz) {
-        return RegRequest.class.isAssignableFrom(clazz);
-    }
-
-    @Override
-    public void validate(Object target, Errors errors) {
-        RegRequest request = (RegRequest) target;
-
-        validatePhone(request.getPhone(), errors);
-        validatePassword(request.getPassword(), errors);
-        validateEmail(request.getEmail(), errors);
-        validateCompanyName(request.getCompanyName(), errors);
-        validateFullName(request.getFullName(), errors);
-    }
-
-    private void validateFullName(String fullName, Errors errors) {
-        if (fullName == null || fullName.trim().isEmpty()) {
-            errors.rejectValue("fullName", "fullName.required",
-                    "Full name is required");
-            return;
-        }
-
-        String trimmedName = fullName.trim();
-
-        if (trimmedName.length() < 2) {
-            errors.rejectValue("fullName", "fullName.too.short",
-                    "Full name must be at least 2 characters");
-        }
-
-        if (trimmedName.length() > 100) {
-            errors.rejectValue("fullName", "fullName.too.long",
-                    "Full name must be less than 100 characters");
-        }
-
-        if (!trimmedName.matches(NAME_REGEX)) {
-            errors.rejectValue("fullName", "fullName.invalid.chars",
-                    "Name can only contain letters, spaces, hyphens and apostrophes");
-        }
-    }
-
-    private void validateCompanyName(String companyName, Errors errors) {
-        if (companyName == null || companyName.trim().isEmpty()) {
-            return;
-        }
-
-        String trimmedCompany = companyName.trim();
-
-        if (trimmedCompany.length() > 200) {
-            errors.rejectValue("companyName", "companyName.too.long",
-                    "Company name must be less than 200 characters");
-        }
-
-        if (!trimmedCompany.matches(COMPANY_REGEX)) {
-            errors.rejectValue("companyName", "companyName.invalid.chars",
-                    "Company name contains invalid characters");
-        }
-
-        validateForbiddenWords(trimmedCompany, "companyName", errors,
-                Arrays.asList("admin", "root", "system", "test"));
-    }
-
-    private void validateForbiddenWords(String text, String fieldName,
-                                        Errors errors, List<String> forbiddenWords) {
-        String lowerText = text.toLowerCase();
-        for (String word : forbiddenWords) {
-            if (lowerText.contains(word)) {
-                errors.rejectValue(fieldName, fieldName + ".forbidden.word",
-                        "Contains forbidden word: " + word);
-                break;
-            }
-        }
-    }
-
-    private void validateEmail(String email, Errors errors) {
-        if (email == null || email.trim().isEmpty()) {
-            errors.rejectValue("email", "email.is.empty", "Email must not be empty");
-            return;
-        }
-
-        String trimmedEmail = email.trim().toLowerCase();
-
-        if (trimmedEmail.length() > 254) {
-            errors.rejectValue("email", "email.too.long", "Email is too long");
-            return;
-        }
-
-        EmailValidator emailValidator = EmailValidator.getInstance(true, true);
-        if (!emailValidator.isValid(trimmedEmail)) {
-            errors.rejectValue("email", "email.invalid", "Invalid email address");
-            return;
-        }
-    }
-
-
-    private void validatePhone(String phone, Errors errors) {
-        if (phone == null || phone.trim().isEmpty()) {
-            errors.rejectValue("phone", "phone.empty",
-                    "Test phone numbers are not allowed");
-            return;
-        }
-
-        String trimmedPhone = phone.trim();
-        String digitsOnly = trimmedPhone.replaceAll("[^0-9+]", "");
-
-        if (digitsOnly.length() < 11 || digitsOnly.length() > 14) {
-            errors.rejectValue("phone", "phone.invalid.length",
-                    "Phone number must contain 11-14 digits");
-            return;
-        }
-
-        if (!digitsOnly.matches("^(\\+7|8|7)[0-9]{10}$")) {
-            errors.rejectValue("phone", "phone.invalid.format",
-                    "Invalid phone number format");
-            return;
-        }
-    }
-
-    private void validatePassword(String password, Errors errors) {
-        if (password == null || password.isEmpty()) {
-            errors.rejectValue("password", "password.empty",
-                    "Password are not allowed");
-            return;
-        }
-
-        if (password.length() < 8) {
-            errors.rejectValue("password", "password.too.short",
-                    "Password must be at least 8 characters");
-        }
-
-        if (password.length() > 50) {
-            errors.rejectValue("password", "password.too.long",
-                    "Password must be less than 50 characters");
-        }
-
-        if (password.contains(" ")) {
-            errors.rejectValue("password", "password.contains.spaces",
-                    "Password cannot contain spaces");
-        }
-
-//        recomment if need complexity
-//        checkPasswordComplexity(password, errors);
-
-//        reccoment if need check simply standart password
-//        checkCommonPasswords(password, errors);
-
-//        reccoment if need check simply standart password
-//        checkForSequences(password, errors);
-    }
-
-    private void checkPasswordComplexity(String password, Errors errors) {
-        boolean hasUpper = false;
-        boolean hasLower = false;
-        boolean hasDigit = false;
-        boolean hasSpecial = false;
-
-        for (char c : password.toCharArray()) {
-            if (Character.isUpperCase(c)) hasUpper = true;
-            if (Character.isLowerCase(c)) hasLower = true;
-            if (Character.isDigit(c)) hasDigit = true;
-            if ("!@#$%^&*()_+-=[]{}|;:,.<>?".indexOf(c) >= 0) hasSpecial = true;
-        }
-
-        List<String> missing = new ArrayList<>();
-        if (!hasUpper) missing.add("uppercase letter");
-        if (!hasLower) missing.add("lowercase letter");
-        if (!hasDigit) missing.add("digit");
-        if (!hasSpecial) missing.add("special character");
-
-        if (!missing.isEmpty()) {
-            String message = "Password must contain: " + String.join(", ", missing);
-            errors.rejectValue("password", "password.complexity.missing", message);
-        }
-    }
-
-    private void checkCommonPasswords(String password, Errors errors) {
-        Set<String> commonPasswords = Set.of(
-                "password", "12345678", "qwerty123", "admin123",
-                "welcome1", "password1", "123456789", "qwertyuiop"
-        );
-
-        if (commonPasswords.contains(password.toLowerCase())) {
-            errors.rejectValue("password", "password.too.common",
-                    "This password is too common, please choose another");
-        }
-    }
-
-    private void checkForSequences(String password, Errors errors) {
-        String lower = password.toLowerCase();
-
-        if (lower.matches(".*123456.*") || lower.matches(".*987654.*")) {
-            errors.rejectValue("password", "password.sequence.numbers",
-                    "Password contains predictable number sequence");
-        }
-
-        if (lower.matches(".*abcdef.*") || lower.matches(".*qwerty.*")) {
-            errors.rejectValue("password", "password.sequence.letters",
-                    "Password contains predictable letter sequence");
-        }
-
-        if (lower.matches(".*(.)\\1{3,}.*")) {
-            errors.rejectValue("password", "password.repeating.chars",
-                    "Password contains too many repeating characters");
-        }
-    }
-}

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

@@ -0,0 +1,33 @@
+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.FileEntity;
+import ru.soune.nocopy.entity.file.FileStatus;
+
+import java.util.List;
+import java.util.Optional;
+
+@Repository
+public interface FileEntityRepository extends JpaRepository<FileEntity, String> {
+
+    List<FileEntity> findByUserId(Long userId);
+
+    List<FileEntity> findByUserIdAndStatus(Long userId, FileStatus status);
+
+    Optional<FileEntity> findByFilePath(String filePath);
+
+    Optional<FileEntity> findByUploadSessionId(String uploadSessionId);
+
+    boolean existsByFilePath(String filePath);
+
+    @Query("SELECT SUM(f.fileSize) FROM FileEntity f WHERE f.userId = :userId AND f.status = 'ACTIVE'")
+    Long getTotalSizeByUserId(@Param("userId") Long userId);
+
+    @Query("SELECT f FROM FileEntity f WHERE f.userId = :userId AND f.originalFileName LIKE %:keyword%")
+    List<FileEntity> searchByFileName(@Param("userId") Long userId, @Param("keyword") String keyword);
+
+    long countByUserId(Long userId);
+}

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

@@ -1,6 +1,5 @@
 package ru.soune.nocopy.repository;
 
-import jakarta.validation.constraints.Size;
 import org.springframework.data.jpa.repository.JpaRepository;
 import ru.soune.nocopy.entity.User;
 
@@ -9,5 +8,4 @@ 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/nocopy/service/AuthService.java

@@ -5,18 +5,19 @@ 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.dto.LoginRequest;
+import ru.soune.nocopy.dto.RegisterRequest;
 import ru.soune.nocopy.entity.AuthToken;
 import ru.soune.nocopy.entity.User;
-import ru.soune.nocopy.exception.NotValidFieldException;
+import ru.soune.nocopy.exception.NotValidationPasswordException;
+import ru.soune.nocopy.exception.UserAlreadyExistsException;
+import ru.soune.nocopy.exception.UserNotFoundException;
 import ru.soune.nocopy.repository.AuthTokenRepository;
 import ru.soune.nocopy.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.Optional;
 
 @Service
@@ -34,18 +35,22 @@ public class AuthService {
     private final SecureRandom secureRandom = new SecureRandom();
 
     @Transactional
-    public AuthToken register(RegRequest registerRequest) {
-        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());
+    public AuthToken register(RegisterRequest registerRequest) {
+        if (userRepository.existsByEmail(registerRequest.email())) {
+            throw new UserAlreadyExistsException("User already exists with email: " + registerRequest.email());
         }
 
-        if (registerRequest.getPhone() != null) {
-            user.setPhone(registerRequest.getPhone());
+        User user = new User();
+        user.setFullName(registerRequest.fullName());
+        user.setEmail(registerRequest.email());
+        user.setPassword(passwordEncoder.encode(registerRequest.password()));
+
+        if (registerRequest.companyName() != null) {
+            user.setCompany(registerRequest.companyName());
+        }
+
+        if (registerRequest.phone() != null) {
+            user.setPhone(registerRequest.phone());
         }
 
         User savedUser = userRepository.save(user);
@@ -60,15 +65,15 @@ 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());

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

@@ -0,0 +1,277 @@
+package ru.soune.nocopy.service.file;
+
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+import ru.soune.nocopy.dto.file.FileEntityResponse;
+import ru.soune.nocopy.dto.file.FileListResponse;
+import ru.soune.nocopy.entity.file.FileEntity;
+import ru.soune.nocopy.entity.file.FileStatus;
+import ru.soune.nocopy.entity.file.FileUploadSession;
+import ru.soune.nocopy.exception.FileEntityNotFoundException;
+import ru.soune.nocopy.repository.FileEntityRepository;
+
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.time.LocalDateTime;
+import java.util.List;
+import java.util.stream.Collectors;
+
+@Slf4j
+@Service
+@RequiredArgsConstructor
+public class FileEntityService {
+
+    private final FileEntityRepository fileEntityRepository;
+
+    /**
+     * Создает FileEntity на основе завершенной сессии загрузки
+     */
+    @Transactional
+    public FileEntity createFromUploadSession(FileUploadSession session, String checksum) {
+        log.info("Creating FileEntity for upload session: {}", session.getUploadId());
+
+        try {
+            Path filePath = Paths.get(session.getFilePath());
+
+            if (!Files.exists(filePath)) {
+                throw new IOException("File not found on disk: " + filePath);
+            }
+
+            long fileSize = Files.size(filePath);
+            String originalName = session.getFileName();
+            String extension = extractFileExtension(originalName);
+            String storedName = filePath.getFileName().toString();
+
+            FileEntity fileEntity = FileEntity.builder()
+                    .userId(session.getUserId())
+                    .originalFileName(originalName)
+                    .storedFileName(storedName)
+                    .filePath(session.getFilePath())
+                    .fileSize(fileSize)
+                    .mimeType(session.getFileType())
+                    .fileExtension(extension)
+                    .checksum(checksum)
+                    .uploadSessionId(session.getUploadId())
+                    .status(FileStatus.ACTIVE)
+                    .build();
+
+            FileEntity saved = fileEntityRepository.save(fileEntity);
+            log.info("FileEntity created successfully: {} (size: {} bytes)",
+                    saved.getId(), fileSize);
+
+            return saved;
+
+        } catch (IOException e) {
+            log.error("Failed to create FileEntity for session {}: {}",
+                    session.getUploadId(), e.getMessage(), e);
+            throw new RuntimeException("Failed to create file entity: " + e.getMessage(), e);
+        }
+    }
+
+    /**
+     * Извлекает расширение файла из имени
+     */
+    private String extractFileExtension(String fileName) {
+        int dotIndex = fileName.lastIndexOf('.');
+        if (dotIndex > 0 && dotIndex < fileName.length() - 1) {
+            return fileName.substring(dotIndex + 1).toLowerCase();
+        }
+        return "";
+    }
+
+    /**
+     * Получает FileEntity по ID
+     */
+    @Transactional(readOnly = true)
+    public FileEntityResponse getById(String fileId) {
+        FileEntity fileEntity = fileEntityRepository.findById(fileId)
+                .orElseThrow(() -> new FileEntityNotFoundException(fileId));
+
+        return convertToResponse(fileEntity);
+    }
+
+    /**
+     * Получает FileEntity по ID сессии загрузки
+     */
+    @Transactional(readOnly = true)
+    public FileEntityResponse getByUploadSessionId(String uploadSessionId) {
+        FileEntity fileEntity = fileEntityRepository.findByUploadSessionId(uploadSessionId)
+                .orElseThrow(() -> new FileEntityNotFoundException(
+                        "Not found for upload session: " + uploadSessionId));
+
+        return convertToResponse(fileEntity);
+    }
+
+    /**
+     * Получает FileEntity по пути файла
+     */
+    @Transactional(readOnly = true)
+    public FileEntityResponse getByFilePath(String filePath) {
+        FileEntity fileEntity = fileEntityRepository.findByFilePath(filePath)
+                .orElseThrow(() -> new FileEntityNotFoundException("Path: " + filePath));
+
+        return convertToResponse(fileEntity);
+    }
+
+    /**
+     * Получает все файлы пользователя
+     */
+    @Transactional(readOnly = true)
+    public FileListResponse getAllUserFiles(Long userId) {
+        List<FileEntity> fileEntities = fileEntityRepository.findByUserIdAndStatus(
+                userId, FileStatus.ACTIVE);
+
+        List<FileEntityResponse> files = fileEntities.stream()
+                .map(this::convertToResponse)
+                .collect(Collectors.toList());
+
+        long totalSize = fileEntities.stream()
+                .mapToLong(FileEntity::getFileSize)
+                .sum();
+
+        return FileListResponse.builder()
+                .files(files)
+                .totalCount(files.size())
+                .totalSize(totalSize)
+                .formattedTotalSize(formatFileSize(totalSize))
+                .page(1)
+                .pageSize(files.size())
+                .build();
+    }
+
+    /**
+     * Получает файлы пользователя с пагинацией
+     */
+    @Transactional(readOnly = true)
+    public FileListResponse getUserFiles(Long userId, int page, int pageSize) {
+        List<FileEntity> allFiles = fileEntityRepository.findByUserIdAndStatus(
+                userId, FileStatus.ACTIVE);
+
+        int start = (page - 1) * pageSize;
+        int end = Math.min(start + pageSize, allFiles.size());
+
+        if (start >= allFiles.size()) {
+            return FileListResponse.builder()
+                    .files(List.of())
+                    .totalCount(allFiles.size())
+                    .totalSize(0)
+                    .formattedTotalSize("0 B")
+                    .page(page)
+                    .pageSize(pageSize)
+                    .build();
+        }
+
+        List<FileEntity> pageFiles = allFiles.subList(start, end);
+
+        List<FileEntityResponse> files = pageFiles.stream()
+                .map(this::convertToResponse)
+                .collect(Collectors.toList());
+
+        long totalSize = allFiles.stream()
+                .mapToLong(FileEntity::getFileSize)
+                .sum();
+
+        return FileListResponse.builder()
+                .files(files)
+                .totalCount(allFiles.size())
+                .totalSize(totalSize)
+                .formattedTotalSize(formatFileSize(totalSize))
+                .page(page)
+                .pageSize(pageSize)
+                .build();
+    }
+
+    /**
+     * Помечает файл как удаленный (мягкое удаление)
+     */
+    @Transactional
+    public void markAsDeleted(String fileId) {
+        FileEntity fileEntity = fileEntityRepository.findById(fileId)
+                .orElseThrow(() -> new FileEntityNotFoundException(fileId));
+
+        fileEntity.setStatus(FileStatus.DELETED);
+        fileEntity.setUpdatedAt(LocalDateTime.now());
+        fileEntityRepository.save(fileEntity);
+
+        log.info("FileEntity marked as deleted: {}", fileId);
+    }
+
+    /**
+     * Получает общий размер файлов пользователя
+     */
+    @Transactional(readOnly = true)
+    public long getUserStorageUsed(Long userId) {
+        Long totalSize = fileEntityRepository.getTotalSizeByUserId(userId);
+        return totalSize != null ? totalSize : 0L;
+    }
+
+    /**
+     * Поиск файлов пользователя по имени
+     */
+    @Transactional(readOnly = true)
+    public List<FileEntityResponse> searchFiles(Long userId, String query) {
+        List<FileEntity> files = fileEntityRepository.searchByFileName(userId, query);
+
+        return files.stream()
+                .filter(f -> f.getStatus() == FileStatus.ACTIVE)
+                .map(this::convertToResponse)
+                .collect(Collectors.toList());
+    }
+
+    /**
+     * Проверяет, существует ли файл на диске
+     */
+    private boolean checkFileExistsOnDisk(String filePath) {
+        try {
+            return Files.exists(Paths.get(filePath));
+        } catch (Exception e) {
+            log.warn("Error checking file existence: {}", filePath, e);
+            return false;
+        }
+    }
+
+    /**
+     * Конвертирует FileEntity в DTO
+     */
+    private FileEntityResponse convertToResponse(FileEntity fileEntity) {
+        boolean existsOnDisk = checkFileExistsOnDisk(fileEntity.getFilePath());
+
+        return FileEntityResponse.builder()
+                .id(fileEntity.getId())
+                .userId(fileEntity.getUserId())
+                .originalFileName(fileEntity.getOriginalFileName())
+                .storedFileName(fileEntity.getStoredFileName())
+                .filePath(fileEntity.getFilePath())
+                .fileSize(fileEntity.getFileSize())
+                .mimeType(fileEntity.getMimeType())
+                .fileExtension(fileEntity.getFileExtension())
+                .checksum(fileEntity.getChecksum())
+                .uploadSessionId(fileEntity.getUploadSessionId())
+                .status(fileEntity.getStatus())
+                .createdAt(fileEntity.getCreatedAt())
+                .updatedAt(fileEntity.getUpdatedAt())
+                .formattedSize(formatFileSize(fileEntity.getFileSize()))
+                .downloadUrl("/api/files/download/" + fileEntity.getId())
+                .existsOnDisk(existsOnDisk)
+                .build();
+    }
+
+    /**
+     * Форматирует размер файла в читаемый вид
+     */
+    private String formatFileSize(long size) {
+        if (size < 1024) {
+            return size + " B";
+        } else if (size < 1024 * 1024) {
+            return String.format("%.1f KB", size / 1024.0);
+        } else if (size < 1024 * 1024 * 1024) {
+            return String.format("%.1f MB", size / (1024.0 * 1024.0));
+        } else {
+            return String.format("%.1f GB", size / (1024.0 * 1024.0 * 1024.0));
+        }
+    }
+}

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

@@ -3,6 +3,7 @@ package ru.soune.nocopy.service.file;
 import jakarta.annotation.PostConstruct;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.beans.factory.annotation.Value;
 import org.springframework.scheduling.annotation.Async;
 import org.springframework.stereotype.Service;
@@ -56,6 +57,9 @@ public class FileUploadServiceImpl implements FileUploadService {
 
     private Path storageRoot;
 
+    @Autowired
+    private FileEntityService fileEntityService;
+
     @PostConstruct
     public void init() {
         try {
@@ -328,14 +332,46 @@ public class FileUploadServiceImpl implements FileUploadService {
         }
     }
 
+//    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 void assembleFile(FileUploadSession session) throws IOException {
         log.info("Starting file assembly for session: {} ({})",
                 session.getUploadId(), session.getFileName());
 
         Path finalFilePath = null;
+        String checksum = null;
 
         try {
             finalFilePath = prepareFinalFile(session);
+            log.info("Final file path: {}", finalFilePath);
 
             validateAllChunksExist(session);
 
@@ -343,18 +379,48 @@ public class FileUploadServiceImpl implements FileUploadService {
 
             validateFinalFile(session, finalFilePath);
 
-            updateSessionOnSuccess(session, finalFilePath);
+            checksum = calculateChecksum(finalFilePath);
+            log.debug("File checksum calculated: {}", checksum);
+
+            session.setFilePath(finalFilePath.toString());
+            session.setChecksum(checksum);
+            session.setStatus(UploadStatus.COMPLETED);
+            session.setCompletedAt(LocalDateTime.now());
+            sessionRepository.save(session);
+            log.info("Upload session updated to COMPLETED: {}", session.getUploadId());
+
+            try {
+                fileEntityService.createFromUploadSession(session, checksum);
+                log.info("FileEntity successfully created for session: {}",
+                        session.getUploadId());
+            } catch (Exception e) {
+                log.error("Failed to create FileEntity for session {} (file uploaded, but metadata not saved): {}",
+                        session.getUploadId(), e.getMessage());
+            }
 
             cleanupSessionFiles(session);
 
-            log.info("File assembly completed: {} -> {} ({} bytes)",
+            log.info("File assembly completed successfully: {} -> {} ({} bytes)",
                     session.getFileName(), finalFilePath, session.getFileSize());
 
         } catch (Exception e) {
+            log.error("File assembly failed for session {}: {}",
+                    session.getUploadId(), e.getMessage(), e);
+
             if (finalFilePath != null) {
-                Files.deleteIfExists(finalFilePath);
+                try {
+                    Files.deleteIfExists(finalFilePath);
+                    log.debug("Cleaned up partial file: {}", finalFilePath);
+                } catch (IOException ioException) {
+                    log.warn("Failed to cleanup partial file: {}", finalFilePath, ioException);
+                }
             }
-            throw e;
+
+            session.setStatus(UploadStatus.FAILED);
+            session.setLastError(e.getMessage());
+            sessionRepository.save(session);
+
+            throw new IOException("File assembly failed: " + e.getMessage(), e);
         }
     }
 

src/main/resources/application.yaml

@@ -31,6 +31,13 @@ file:
     temp-ttl-hours: ${TEMP_TTL_HOURS:72}  # 3 дня
     session-expiry-hours: ${SESSION_EXPIRY_HOURS:24}
 
+security:
+  cors:
+    allowed-origins: "*"
+    allowed-methods: GET,POST,PUT,DELETE,OPTIONS
+    allowed-headers: "*"
+    allow-credentials: true
+
 server:
   port: ${SERVER_PORT:8080}
 

src/test/java/ru/soune/nocopy/service/AuthServiceTest.java

@@ -9,17 +9,21 @@ import org.mockito.MockitoAnnotations;
 import org.springframework.context.MessageSource;
 import org.springframework.security.crypto.password.PasswordEncoder;
 import ru.soune.nocopy.dto.LoginRequest;
+import ru.soune.nocopy.dto.RegisterRequest;
 import ru.soune.nocopy.entity.AuthToken;
 import ru.soune.nocopy.entity.User;
 import ru.soune.nocopy.exception.NotValidationPasswordException;
+import ru.soune.nocopy.exception.UserAlreadyExistsException;
 import ru.soune.nocopy.exception.UserNotFoundException;
 import ru.soune.nocopy.repository.AuthTokenRepository;
 import ru.soune.nocopy.repository.UserRepository;
 
+import java.util.Locale;
 import java.util.Optional;
 
 import static org.junit.jupiter.api.Assertions.*;
 import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyString;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
 
@@ -45,6 +49,43 @@ public class AuthServiceTest {
         MockitoAnnotations.openMocks(this);
     }
 
+    @Test
+    void registerSuccess() {
+        RegisterRequest request = new RegisterRequest("John","A.","124124",
+                "john@example.com", null,"password123", null, null);
+
+        when(userRepository.existsByEmail(request.email())).thenReturn(false);
+        when(passwordEncoder.encode(request.password())).thenReturn("hashed");
+        when(userRepository.save(any(User.class))).thenAnswer(invocation -> invocation.getArgument(0));
+        when(authTokenRepository.save(any(AuthToken.class))).thenAnswer(invocation -> invocation.getArgument(0));
+
+        AuthToken token = authService.register(request);
+        User user = token.getUser();
+        String email = user.getEmail();
+
+        assertNotNull(token);
+        assertNotNull(token.getToken());
+        assertNotNull(token.getUser());
+        assertEquals("john@example.com", email);
+        assertNotNull(token.getExpiresAt());
+    }
+
+    @Test
+    void registerExistingEmailThrows() {
+        RegisterRequest request = new RegisterRequest("John","A.","124124",
+                "john@example.com", null,"password123", null, null);
+
+        when(userRepository.existsByEmail(request.email()))
+                .thenReturn(true);
+        when(messageSource.getMessage(anyString(), any(), any(Locale.class)))
+                .thenReturn("User exists");
+
+        UserAlreadyExistsException ex = assertThrows(UserAlreadyExistsException.class,
+                () -> authService.register(request));
+
+        assertEquals("User exists", ex.getMessage());
+    }
+
     @Test
     void login_success() {
         LoginRequest request = new LoginRequest("test@mail.com", "password");