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

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

@@ -0,0 +1,105 @@
+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,13 +1,8 @@
 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;
@@ -25,22 +20,6 @@ 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("/api")
+@RequestMapping("check/api")
 public class HealtCheckController {
 
     @GetMapping("/healt")

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

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

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

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

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

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

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

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

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

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

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

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

@@ -42,6 +42,7 @@ 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/exception/NotValidFieldException.java

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

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

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

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

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

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

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

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

@@ -1,5 +1,6 @@
 package ru.soune.nocopy.repository;
 
+import jakarta.validation.constraints.Size;
 import org.springframework.data.jpa.repository.JpaRepository;
 import ru.soune.nocopy.entity.User;
 
@@ -8,4 +9,5 @@ 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,19 +5,18 @@ 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.LoginRequest;
-import ru.soune.nocopy.dto.RegisterRequest;
+import ru.soune.nocopy.dto.*;
 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.exception.NotValidFieldException;
 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
@@ -35,22 +34,18 @@ public class AuthService {
     private final SecureRandom secureRandom = new SecureRandom();
 
     @Transactional
-    public AuthToken register(RegisterRequest registerRequest) {
-        if (userRepository.existsByEmail(registerRequest.email())) {
-            throw new UserAlreadyExistsException("User already exists with email: " + registerRequest.email());
-        }
-
+    public AuthToken register(RegRequest registerRequest) {
         User user = new User();
-        user.setFullName(registerRequest.fullName());
-        user.setEmail(registerRequest.email());
-        user.setPassword(passwordEncoder.encode(registerRequest.password()));
+        user.setFullName(registerRequest.getFullName());
+        user.setEmail(registerRequest.getEmail());
+        user.setPassword(passwordEncoder.encode(registerRequest.getPassword()));
 
-        if (registerRequest.companyName() != null) {
-            user.setCompany(registerRequest.companyName());
+        if (registerRequest.getCompanyName() != null) {
+            user.setCompany(registerRequest.getCompanyName());
         }
 
-        if (registerRequest.phone() != null) {
-            user.setPhone(registerRequest.phone());
+        if (registerRequest.getPhone() != null) {
+            user.setPhone(registerRequest.getPhone());
         }
 
         User savedUser = userRepository.save(user);
@@ -65,15 +60,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())) {
-            throw new NotValidationPasswordException("Invalid password");
+            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));
         }
 
         user.setLastLoginAt(LocalDateTime.now());

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

@@ -9,21 +9,17 @@ 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;
 
@@ -49,43 +45,6 @@ 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");