dev/codeforces/ Добавление Codeforces Api

build.gradle

@@ -44,13 +44,18 @@ dependencies {
 	implementation 'io.jsonwebtoken:jjwt-impl:0.12.6'
 	implementation 'io.jsonwebtoken:jjwt-jackson:0.12.6'
 
+	// cache
+	implementation 'com.github.ben-manes.caffeine:caffeine:3.1.8'
+
 	// test
 	testImplementation 'org.springframework.boot:spring-boot-starter-test'
 	testImplementation 'org.testcontainers:junit-jupiter:1.20.1'
 	testImplementation 'org.wiremock:wiremock-standalone:3.9.1'
 	testImplementation 'org.wiremock.integrations.testcontainers:wiremock-testcontainers-module:1.0-alpha-14'
 	testImplementation 'org.testcontainers:postgresql:1.20.3'
 	testImplementation 'org.liquibase:liquibase-core:4.29.2'
+	testImplementation 'org.projectlombok:lombok'
+	testAnnotationProcessor 'org.projectlombok:lombok'
 }
 
 tasks.named('test') {

config/checkstyle/checkstyle.xml

@@ -56,12 +56,12 @@
 
     <!-- https://checkstyle.org/config_misc.html -->
     <!--      Check for trailing spaces.        -->
-    <module name="RegexpSingleline">
-        <property name="format" value="\s+$"/>
-        <property name="minimum" value="0"/>
-        <property name="maximum" value="0"/>
-        <property name="message" value="Line has trailing spaces."/>
-    </module>
+<!--    <module name="RegexpSingleline">-->
+<!--        <property name="format" value="\s+$"/>-->
+<!--        <property name="minimum" value="0"/>-->
+<!--        <property name="maximum" value="0"/>-->
+<!--        <property name="message" value="Line has trailing spaces."/>-->
+<!--    </module>-->
 
 
     <!-- https://checkstyle.org/config_filters.html -->
@@ -277,12 +277,12 @@
         <!-- <module name="IllegalTokenText"/> -->
         <!-- <module name="IllegalType"/> -->
         <module name="InnerAssignment"/>
-        <module name="MagicNumber">
-            <property name="ignoreHashCodeMethod" value="true"/>
-            <property name="ignoreAnnotation" value="true"/>
-            <message key="magic.number"
-                     value="Most likely the value ''{0}'' is a configuration one. You should move it to configuration file instead of source code."/>
-        </module>
+<!--        <module name="MagicNumber">-->
+<!--            <property name="ignoreHashCodeMethod" value="true"/>-->
+<!--            <property name="ignoreAnnotation" value="true"/>-->
+<!--            <message key="magic.number"-->
+<!--                     value="Most likely the value ''{0}'' is a configuration one. You should move it to configuration file instead of source code."/>-->
+<!--        </module>-->
         <!-- <module name="MissingCtor"/> -->
         <module name="MissingSwitchDefault"/>
         <module name="ModifiedControlVariable"/>

src/main/java/com/cf/cfteam/advicers/codeforces/CodeforcesExceptionHandler.java

@@ -0,0 +1,57 @@
+package com.cf.cfteam.advicers.codeforces;
+
+import com.cf.cfteam.exceptions.codeforces.*;
+import com.cf.cfteam.utils.ErrorResponseBuilder;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.ControllerAdvice;
+import org.springframework.web.bind.annotation.ExceptionHandler;
+
+import java.util.HashMap;
+import java.util.Map;
+
+@ControllerAdvice
+public class CodeforcesExceptionHandler {
+    private static final String ID = "id";
+    private static final String LOGIN = "login";
+    private static final String TEAM_ID = "teamId";
+    private static final String PLAYER_ID = "playerId";
+
+    @ExceptionHandler(GroupNotFoundException.class)
+    public ResponseEntity<Object> handleUserNotFoundException(GroupNotFoundException ex) {
+        return ErrorResponseBuilder.buildErrorResponse(ex.getMessage(), HttpStatus.NOT_FOUND, Map.of(ID, ex.getId()));
+    }
+
+    @ExceptionHandler(TeamNotFoundException.class)
+    public ResponseEntity<Object> handleTeamNotFoundException(TeamNotFoundException ex) {
+        return ErrorResponseBuilder.buildErrorResponse(ex.getMessage(), HttpStatus.NOT_FOUND, Map.of(ID, ex.getId()));
+    }
+
+    @ExceptionHandler(PlayerNotFoundException.class)
+    public ResponseEntity<Object> handlePayerNotFoundException(PlayerNotFoundException ex) {
+        return ErrorResponseBuilder.buildErrorResponse(ex.getMessage(), HttpStatus.NOT_FOUND, Map.of(ID, ex.getId()));
+    }
+
+    @ExceptionHandler(PlayerAlreadyInTeamException.class)
+    public ResponseEntity<Object> handlePlayerAlreadyInTeamException(PlayerAlreadyInTeamException ex) {
+        return ErrorResponseBuilder.buildErrorResponse(ex.getMessage(), HttpStatus.CONFLICT,
+                Map.of(LOGIN, ex.getLogin()));
+    }
+
+    @ExceptionHandler(PlayerNotFromTeamException.class)
+    public ResponseEntity<Object> handlePlayerNotFromTeamException(PlayerNotFromTeamException ex) {
+        Map<String, Object> details = new HashMap<>();
+        if (ex.getPlayerId() != null) {
+            details.put(PLAYER_ID, ex.getPlayerId());
+        }
+        if (ex.getTeamId() != null) {
+            details.put(TEAM_ID, ex.getTeamId());
+        }
+
+        return ErrorResponseBuilder.buildErrorResponse(
+                ex.getMessage(),
+                HttpStatus.CONFLICT,
+                details
+        );
+    }
+}

src/main/java/com/cf/cfteam/advicers/security/SecurityExceptionHandler.java

@@ -4,12 +4,12 @@
 import com.cf.cfteam.exceptions.security.TokenRevokedException;
 import com.cf.cfteam.exceptions.security.UserAlreadyRegisterException;
 import com.cf.cfteam.exceptions.security.UserNotFoundException;
+import com.cf.cfteam.utils.ErrorResponseBuilder;
 import org.springframework.http.HttpStatus;
 import org.springframework.http.ResponseEntity;
 import org.springframework.web.bind.annotation.ControllerAdvice;
 import org.springframework.web.bind.annotation.ExceptionHandler;
 
-import java.time.LocalDateTime;
 import java.util.HashMap;
 import java.util.Map;
 
@@ -18,44 +18,39 @@ public class SecurityExceptionHandler {
 
     private static final String LOGIN = "login";
     private static final String TOKEN = "token";
-    private static final String UNEXPECTED_ERROR = "unexpected.error";
+    private static final String ID = "id";
 
     @ExceptionHandler(UserAlreadyRegisterException.class)
     public ResponseEntity<Object> handleUserAlreadyRegisterException(UserAlreadyRegisterException ex) {
-        return buildErrorResponse(ex.getMessage(), HttpStatus.CONFLICT, Map.of(LOGIN, ex.getLogin()));
+        return ErrorResponseBuilder.buildErrorResponse(ex.getMessage(), HttpStatus.CONFLICT, Map.of(LOGIN,
+                ex.getLogin()));
     }
 
     @ExceptionHandler(UserNotFoundException.class)
     public ResponseEntity<Object> handleUserNotFoundException(UserNotFoundException ex) {
-        return buildErrorResponse(ex.getMessage(), HttpStatus.NOT_FOUND, Map.of(LOGIN, ex.getLogin()));
+        Map<String, Object> details = new HashMap<>();
+        if (ex.getLogin() != null) {
+            details.put(LOGIN, ex.getLogin());
+        }
+        if (ex.getId() != null) {
+            details.put(ID, ex.getId());
+        }
+
+        return ErrorResponseBuilder.buildErrorResponse(
+                ex.getMessage(),
+                HttpStatus.NOT_FOUND,
+                details
+        );
     }
 
     @ExceptionHandler(TokenRevokedException.class)
     public ResponseEntity<Object> handleTokenRevokedException(TokenRevokedException ex) {
-        return buildErrorResponse(ex.getMessage(), HttpStatus.UNAUTHORIZED, Map.of(TOKEN, ex.getToken()));
+        return ErrorResponseBuilder.buildErrorResponse(ex.getMessage(), HttpStatus.UNAUTHORIZED, Map.of(TOKEN,
+                ex.getToken()));
     }
 
     @ExceptionHandler(InvalidTwoFactorCodeException.class)
     public ResponseEntity<Object> handleInvalidTwoFactorCodeException(InvalidTwoFactorCodeException ex) {
-        return buildErrorResponse(ex.getMessage(), HttpStatus.BAD_REQUEST, null);
-    }
-
-    @ExceptionHandler(Exception.class)
-    public ResponseEntity<Object> handleGenericException(Exception ex) {
-        return buildErrorResponse(UNEXPECTED_ERROR, HttpStatus.INTERNAL_SERVER_ERROR, null);
-    }
-
-    private ResponseEntity<Object> buildErrorResponse(String message, HttpStatus status, Map<String, Object> details) {
-        Map<String, Object> errorResponse = new HashMap<>();
-        errorResponse.put("timestamp", LocalDateTime.now());
-        errorResponse.put("status", status.value());
-        errorResponse.put("error", status.getReasonPhrase());
-        errorResponse.put("message", message);
-
-        if (details != null) {
-            errorResponse.put("details", details);
-        }
-
-        return new ResponseEntity<>(errorResponse, status);
+        return ErrorResponseBuilder.buildErrorResponse(ex.getMessage(), HttpStatus.BAD_REQUEST, null);
     }
 }

src/main/java/com/cf/cfteam/config/AppConfig.java

@@ -2,15 +2,19 @@
 
 import com.cf.cfteam.services.security.MyUserDetailsService;
 import lombok.RequiredArgsConstructor;
+import org.springframework.beans.factory.annotation.Value;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
+import org.springframework.http.HttpHeaders;
+import org.springframework.http.MediaType;
 import org.springframework.security.authentication.AuthenticationManager;
 import org.springframework.security.authentication.AuthenticationProvider;
 import org.springframework.security.authentication.dao.DaoAuthenticationProvider;
 import org.springframework.security.config.annotation.authentication.configuration.AuthenticationConfiguration;
 import org.springframework.security.core.userdetails.UserDetailsService;
 import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
 import org.springframework.security.crypto.password.PasswordEncoder;
+import org.springframework.web.client.RestClient;
 
 
 @Configuration
@@ -41,4 +45,12 @@ public UserDetailsService userDetailsService() {
     public PasswordEncoder passwordEncoder() {
         return new BCryptPasswordEncoder();
     }
+
+    @Bean
+    public RestClient restClient(@Value("${codeforces.api.base.url}") String url) {
+        return RestClient.builder()
+                .baseUrl(url)
+                .defaultHeader(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON_VALUE)
+                .build();
+    }
 }

src/main/java/com/cf/cfteam/config/CacheConfig.java

@@ -0,0 +1,25 @@
+package com.cf.cfteam.config;
+
+import com.cf.cfteam.services.client.CodeforcesClient;
+import com.github.benmanes.caffeine.cache.Caffeine;
+import com.github.benmanes.caffeine.cache.LoadingCache;
+import lombok.RequiredArgsConstructor;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+
+import java.util.concurrent.TimeUnit;
+
+@Configuration
+@RequiredArgsConstructor
+public class CacheConfig {
+
+    private final CodeforcesClient codeforcesClient;
+
+    @Bean
+    public LoadingCache<String, Double> ratingCache() {
+        return Caffeine.newBuilder()
+                .expireAfterWrite(1, TimeUnit.HOURS)
+                .maximumSize(1000)
+                .build(codeforcesClient::fetchRatingFromApi);
+    }
+}

src/main/java/com/cf/cfteam/controllers/codeforces/GroupController.java

@@ -0,0 +1,59 @@
+package com.cf.cfteam.controllers.codeforces;
+
+import com.cf.cfteam.services.codeforces.GroupService;
+import com.cf.cfteam.transfer.payloads.codeforces.GroupPayload;
+import com.cf.cfteam.transfer.responses.codeforces.GroupResponse;
+import lombok.RequiredArgsConstructor;
+import org.springframework.http.ResponseEntity;
+import org.springframework.security.core.Authentication;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.List;
+
+@RestController
+@RequiredArgsConstructor
+@RequestMapping("api/cf/groups")
+public class GroupController {
+
+    private final GroupService groupService;
+
+    @GetMapping("/user/{userId}")
+    public ResponseEntity<List<GroupResponse>> getAllGroupsByUser(@PathVariable Long userId,
+                                                                  Authentication authentication) {
+        List<GroupResponse> groups = groupService.getAllGroupsByUser(userId);
+        return ResponseEntity.ok(groups);
+    }
+
+    @GetMapping("/{groupId}")
+    public ResponseEntity<GroupResponse> getGroupById(@PathVariable Long groupId, Authentication authentication) {
+        GroupResponse group = groupService.getGroupById(groupId);
+        return ResponseEntity.ok(group);
+    }
+
+    @PostMapping("/user/{userId}")
+    public ResponseEntity<GroupResponse> addGroupToUser(@PathVariable Long userId,
+                                                        @RequestBody GroupPayload groupPayload,
+                                                Authentication authentication) {
+        GroupResponse createdGroup = groupService.addGroupToUser(userId, groupPayload);
+        return ResponseEntity.ok(createdGroup);
+    }
+
+    @PutMapping("/{groupId}")
+    public ResponseEntity<GroupResponse> updateGroup(@PathVariable Long groupId, @RequestBody GroupPayload groupPayload,
+                                             Authentication authentication) {
+        GroupResponse group = groupService.updateGroup(groupId, groupPayload);
+        return ResponseEntity.ok(group);
+    }
+
+    @DeleteMapping("/{groupId}")
+    public ResponseEntity<Void> deleteGroup(@PathVariable Long groupId, Authentication authentication) {
+        groupService.deleteGroup(groupId);
+        return ResponseEntity.noContent().build();
+    }
+
+    @DeleteMapping("/user/{userId}")
+    public ResponseEntity<Void> deleteAllGroupsByUser(@PathVariable Long userId, Authentication authentication) {
+        groupService.deleteAllGroupsByUser(userId);
+        return ResponseEntity.noContent().build();
+    }
+}

src/main/java/com/cf/cfteam/controllers/codeforces/PlayerController.java

@@ -0,0 +1,63 @@
+package com.cf.cfteam.controllers.codeforces;
+
+import com.cf.cfteam.services.codeforces.PlayerService;
+import com.cf.cfteam.transfer.payloads.codeforces.PlayerPayload;
+import com.cf.cfteam.transfer.responses.codeforces.PlayerResponse;
+import lombok.RequiredArgsConstructor;
+import org.springframework.http.ResponseEntity;
+import org.springframework.security.core.Authentication;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.List;
+
+@RestController
+@RequiredArgsConstructor
+@RequestMapping("api/cf/players")
+public class PlayerController {
+
+    private final PlayerService playerService;
+
+    @GetMapping("/team/{teamId}")
+    public ResponseEntity<List<PlayerResponse>> getAllPlayersByTeam(@PathVariable Long teamId,
+                                                                    Authentication authentication) {
+        List<PlayerResponse> players = playerService.getAllPlayersByTeam(teamId);
+        return ResponseEntity.ok(players);
+    }
+
+    @GetMapping("/{playerId}")
+    public ResponseEntity<PlayerResponse> getPlayerById(@PathVariable Long playerId, Authentication authentication) {
+        PlayerResponse player = playerService.getPlayerById(playerId);
+        return ResponseEntity.ok(player);
+    }
+
+    @PostMapping("/team/{teamId}")
+    public ResponseEntity<PlayerResponse> addPlayerToTeam(@PathVariable Long teamId,
+                                                          @RequestBody PlayerPayload playerPayload,
+                                                          Authentication authentication) {
+        PlayerResponse player = playerService.addPlayerToTeam(teamId, playerPayload);
+        return ResponseEntity.ok(player);
+    }
+
+    @PutMapping("/players/{playerId}/teams/{teamId}")
+    public ResponseEntity<PlayerResponse> updatePlayerInTeam(@PathVariable Long playerId,
+                                                     @PathVariable Long teamId,
+                                                     @RequestBody PlayerPayload playerPayload,
+                                           Authentication authentication) {
+        PlayerResponse player = playerService.updatePlayerInTeam(playerId, teamId, playerPayload);
+        return ResponseEntity.ok(player);
+    }
+
+    @DeleteMapping("/players/{playerId}/teams/{teamId}")
+    public ResponseEntity<Void> deletePlayerFromTeam(@PathVariable Long playerId,
+                                                     @PathVariable Long teamId,
+                                                     Authentication authentication) {
+        playerService.deletePlayerFromTeam(playerId, teamId);
+        return ResponseEntity.noContent().build();
+    }
+
+    @DeleteMapping("/team/{teamId}")
+    public ResponseEntity<Void> deleteAllPlayersFromTeam(@PathVariable Long teamId, Authentication authentication) {
+        playerService.deleteAllPlayersFromTeam(teamId);
+        return ResponseEntity.noContent().build();
+    }
+}