change package,change message_code

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

@@ -0,0 +1,99 @@
+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);
+            throw new RuntimeException("Handler execution failed", e);
+        }
+    }
+
+    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

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

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

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

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

@@ -0,0 +1,11 @@
+package ru.soune.nocopy.controller;
+
+import lombok.AllArgsConstructor;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+@RestController
+@RequestMapping("v1/api/content")
+@AllArgsConstructor
+public class UserContentController {
+}

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

@@ -0,0 +1,111 @@
+package ru.soune.nocopy.controller;
+
+import lombok.RequiredArgsConstructor;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+import ru.soune.nocopy.dto.ChangePasswordRequest;
+import ru.soune.nocopy.dto.UserDTO;
+import ru.soune.nocopy.dto.UserRequest;
+import ru.soune.nocopy.entity.AuthToken;
+import ru.soune.nocopy.entity.User;
+import ru.soune.nocopy.exception.InvalidUserEmail;
+import ru.soune.nocopy.exception.NotFoundAuthToken;
+import ru.soune.nocopy.mapper.UserMapper;
+import ru.soune.nocopy.repository.AuthTokenRepository;
+import ru.soune.nocopy.repository.UserRepository;
+import ru.soune.nocopy.service.UserService;
+
+import java.util.List;
+import java.util.Optional;
+
+@RestController
+@RequestMapping("v1/api/user")
+@RequiredArgsConstructor
+public class UserController {
+
+    private final UserRepository userRepository;
+
+    private final UserService userService;
+
+    private final AuthTokenRepository authTokenRepository;
+
+    private final UserMapper userMapper;
+
+    @GetMapping("/all")
+    public ResponseEntity<List<UserDTO>> getAllUsers() {
+        List<UserDTO> allUsers = userRepository.findAll().stream()
+                .map(u -> new UserDTO(u.getFullName(), u.getCompany(), u.getEmail(), u.getIsActive(),
+                        u.getPhone(), u.getGenderType(),
+                        u.getBirthday(), u.getCreatedAt(), u.getSubscriptionType()))
+                .toList();
+
+        return ResponseEntity.ok(allUsers);
+    }
+
+    @GetMapping
+    public ResponseEntity<UserDTO> getUser(@RequestParam("email") String email,
+                                           @RequestHeader("Authorization") String tokenHeader) {
+        String token = tokenHeader.replace("Bearer ", "");
+
+        Optional<AuthToken> tokenOptional = authTokenRepository.findByToken(token);
+
+        AuthToken authToken = tokenOptional.orElseThrow(() -> new NotFoundAuthToken("Token: " + token + "not found"));
+
+        if (authToken != null) {
+            Optional<User> user = userRepository.findByEmail(email);
+            //TODO add mapper
+            if (user.isPresent()) {
+                UserDTO userDTO = userMapper.toDTO(user.get());
+                userDTO.setEmail(email);
+                userDTO.setFullName(user.get().getFullName());
+                userDTO.setCompany(user.get().getCompany());
+                userDTO.setPhone(user.get().getPhone());
+                userDTO.setGenderType(user.get().getGenderType());
+                userDTO.setBirthday(user.get().getBirthday());
+                userDTO.setCreatedAt(user.get().getCreatedAt());
+                userDTO.setSubscriptionType(user.get().getSubscriptionType());
+                userDTO.setActive(user.get().getIsActive());
+
+                return ResponseEntity.ok(userDTO);
+            }
+
+        }
+
+        return ResponseEntity.notFound().build();
+    }
+
+    //TODO fix mapper,doesnot exist all fields
+    @PostMapping("/change-password")
+    public ResponseEntity<UserDTO> updateUser(@RequestBody ChangePasswordRequest changePasswordRequest,
+                                              @RequestHeader("Authorization") String tokenHeader) {
+        String token = tokenHeader.replace("Bearer ", "");
+
+        Optional<AuthToken> tokenOptional = authTokenRepository.findByToken(token);
+
+        AuthToken authToken = tokenOptional.orElseThrow(() -> new NotFoundAuthToken("Token: " + token + "not found"));
+
+        User user = authToken.getUser();
+
+        if (!changePasswordRequest.getEmail().equals(user.getEmail())) {
+            throw new InvalidUserEmail("Email is not valid: " + changePasswordRequest.getEmail() + "not found");
+        }
+
+        User updateUser = userService.changePassword(user, changePasswordRequest);
+
+        return ResponseEntity.ok(userMapper.toDTO(updateUser));
+    }
+
+    @PatchMapping("/user-update")
+    public ResponseEntity<UserDTO> updateUser(@RequestBody UserRequest userRequest,
+                                              @RequestHeader("Authorization") String tokenHeader) {
+        String token = tokenHeader.replace("Bearer ", "");
+
+        Optional<AuthToken> tokenOptional = authTokenRepository.findByToken(token);
+
+        AuthToken authToken = tokenOptional.orElseThrow(() -> new NotFoundAuthToken("Token: " + token + "not found"));
+
+        User user = authToken.getUser();
+
+        return ResponseEntity.ok(userService.updateUser(userRequest, user));
+    }
+}