feature/7929/commit-info-dev

chat/pom.xml

@@ -27,6 +27,8 @@
         <jquery>3.1.1-1</jquery>
         <jjwt.version>0.12.3</jjwt.version>
         <checkstyle-maven-plugin.version>3.3.1</checkstyle-maven-plugin.version>
+        <org.eclipse.jgit.version>7.1.0.202411261347-r</org.eclipse.jgit.version>
+        <json-path.version>2.9.0</json-path.version>
     </properties>
 
     <dependencies>
@@ -175,6 +177,17 @@
                 </exclusion>
             </exclusions>
         </dependency>
+        <dependency>
+            <groupId>org.eclipse.jgit</groupId>
+            <artifactId>org.eclipse.jgit</artifactId>
+            <version>${org.eclipse.jgit.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>com.jayway.jsonpath</groupId>
+            <artifactId>json-path</artifactId>
+            <version>${json-path.version}</version> <!-- Use the latest stable version -->
+            <scope>test</scope>
+        </dependency>
     </dependencies>
 
     <build>

chat/src/main/java/greencity/config/SecurityConfig.java

@@ -30,7 +30,6 @@
 
 /**
  * Config for security.
- *
  */
 @Configuration
 @EnableWebSecurity
@@ -46,8 +45,8 @@ public class SecurityConfig {
      */
     @Autowired
     public SecurityConfig(JwtTool jwtTool, RestClientUser restClientUser,
-        AuthenticationConfiguration authenticationConfiguration,
-        @Value("${spring.messaging.stomp.websocket.allowed-origins}") String[] allowedOrigins) {
+                          AuthenticationConfiguration authenticationConfiguration,
+                          @Value("${spring.messaging.stomp.websocket.allowed-origins}") String[] allowedOrigins) {
         this.jwtTool = jwtTool;
         this.restClientUser = restClientUser;
         this.authenticationConfiguration = authenticationConfiguration;
@@ -107,6 +106,9 @@ public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Excepti
                     "/webjars/**",
                     "/chat/**")
                 .permitAll()
+                .requestMatchers(HttpMethod.GET,
+                    "/commit-info")
+                .permitAll()
                 .requestMatchers(HttpMethod.GET,
                     "/chat/create-chatRoom",
                     "/chat/messages/{room_id}",

chat/src/main/java/greencity/constant/AppConstant.java

@@ -1,6 +1,8 @@
 package greencity.constant;
 
 public final class AppConstant {
+    public static final String UKRAINE_TIMEZONE = "Europe/Kyiv";
+    public static final String DATE_FORMAT = "dd/MM/yyyy HH:mm:ss";
     public static final String ADMIN = "ADMIN";
     public static final String MODERATOR = "MODERATOR";
     public static final String USER = "USER";

chat/src/main/java/greencity/constant/ErrorMessage.java

@@ -9,6 +9,11 @@ public final class ErrorMessage {
     public static final String USER_NOT_THE_OWNER = "This user is not the owner of the chat";
     public static final String CHAT_MESSAGE_NOT_FOUND_BY_ID = "Chat message not found by id: ";
     public static final String CHAT_MESSAGE_CANNOT_BE_EMPTY = "Message content cannot be empty!";
+    public static final String WARNING_GIT_DIRECTORY_NOT_FOUND =
+        "WARNING: .git directory not found. Git commit info will be unavailable.";
+    public static final String GIT_REPOSITORY_NOT_INITIALIZED =
+        "Git repository not initialized. Commit info is unavailable.";
+    public static final String FAILED_TO_FETCH_COMMIT_INFO = "Failed to fetch commit info due to I/O error: ";
 
     private ErrorMessage() {
     }

chat/src/main/java/greencity/controller/CommitInfoController.java

@@ -0,0 +1,56 @@
+package greencity.controller;
+
+import greencity.constant.HttpStatuses;
+import greencity.dto.CommitInfoDto;
+import greencity.service.CommitInfoService;
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.media.Content;
+import io.swagger.v3.oas.annotations.media.ExampleObject;
+import io.swagger.v3.oas.annotations.responses.ApiResponse;
+import lombok.RequiredArgsConstructor;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+/**
+ * Controller for fetching Git commit information.
+ */
+@RestController
+@RequestMapping("/commit-info")
+@RequiredArgsConstructor
+public class CommitInfoController {
+    private final CommitInfoService commitInfoService;
+
+    /**
+     * Endpoint to fetch the latest Git commit hash and date.
+     *
+     * @return {@link CommitInfoDto}
+     */
+    @Operation(summary = "Get the latest commit hash and date.")
+    @ApiResponse(
+        responseCode = "200",
+        description = HttpStatuses.OK,
+        content = @Content(
+            mediaType = "application/json",
+            examples = @ExampleObject(
+                value = """
+                    {
+                        "commitHash": "d6e70c46b39857846f3f13ca9756c39448ab3d6f",
+                        "commitDate": "16/12/2024 10:55:00"
+                    }""")))
+    @ApiResponse(
+        responseCode = "404",
+        description = HttpStatuses.NOT_FOUND,
+        content = @Content(
+            mediaType = "application/json",
+            examples = @ExampleObject(
+                value = """
+                    {
+                        "message": "Git repository not initialized. Commit info is unavailable."
+                    }""")))
+    @GetMapping
+    public ResponseEntity<CommitInfoDto> getCommitInfo() {
+        return ResponseEntity.ok(commitInfoService.getLatestCommitInfo());
+    }
+}

chat/src/main/java/greencity/dto/CommitInfoDto.java

@@ -0,0 +1,21 @@
+package greencity.dto;
+
+import jakarta.validation.constraints.NotNull;
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import lombok.NoArgsConstructor;
+
+/**
+ * DTO for commit information response.
+ */
+@Data
+@AllArgsConstructor
+@NoArgsConstructor
+@EqualsAndHashCode
+public class CommitInfoDto {
+    @NotNull
+    private String commitHash;
+    @NotNull
+    private String commitDate;
+}

chat/src/main/java/greencity/exception/exceptions/ResourceNotFoundException.java

@@ -0,0 +1,10 @@
+package greencity.exception.exceptions;
+
+import lombok.experimental.StandardException;
+import org.springframework.http.HttpStatus;
+import org.springframework.web.bind.annotation.ResponseStatus;
+
+@StandardException
+@ResponseStatus(HttpStatus.NOT_FOUND)
+public class ResourceNotFoundException extends RuntimeException {
+}

chat/src/main/java/greencity/exception/handlers/CustomExceptionHandler.java

@@ -8,6 +8,7 @@
 import greencity.exception.exceptions.VoiceMessageNotFoundException;
 import greencity.exception.exceptions.UserIsNotAdminException;
 import greencity.exception.exceptions.TariffNotFoundException;
+import greencity.exception.exceptions.ResourceNotFoundException;
 import lombok.AllArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.boot.web.error.ErrorAttributeOptions;
@@ -129,4 +130,23 @@ public final ResponseEntity<Object> handleTariffNotFoundException(TariffNotFound
         log.trace(ex.getMessage(), ex);
         return ResponseEntity.status(HttpStatus.NOT_FOUND).body(exceptionResponse);
     }
+
+    /**
+     * Method intercepts exception {@link ResourceNotFoundException}.
+     *
+     * @param ex      Exception that should be intercepted.
+     * @param request Contains details about the occurred exception.
+     * @return {@code ResponseEntity} which contains the HTTP status and body with
+     *         the exception message.
+     */
+    @ExceptionHandler(ResourceNotFoundException.class)
+    public final ResponseEntity<Object> handleResourceNotFoundException(ResourceNotFoundException ex,
+        WebRequest request) {
+        log.error(ex.getMessage(), ex);
+
+        ExceptionResponse exceptionResponse = new ExceptionResponse(getErrorAttributes(request));
+        exceptionResponse.setMessage(ex.getMessage());
+
+        return ResponseEntity.status(HttpStatus.NOT_FOUND).body(exceptionResponse);
+    }
 }

chat/src/main/java/greencity/service/CommitInfoService.java

@@ -0,0 +1,15 @@
+package greencity.service;
+
+import greencity.dto.CommitInfoDto;
+
+/**
+ * Interface for fetching Git commit information.
+ */
+public interface CommitInfoService {
+    /**
+     * Fetches the latest Git commit hash and date.
+     *
+     * @return {@link CommitInfoDto}
+     */
+    CommitInfoDto getLatestCommitInfo();
+}

chat/src/main/java/greencity/service/impl/CommitInfoServiceImpl.java

@@ -0,0 +1,68 @@
+package greencity.service.impl;
+
+import greencity.constant.AppConstant;
+import greencity.constant.ErrorMessage;
+import greencity.dto.CommitInfoDto;
+import greencity.exception.exceptions.ResourceNotFoundException;
+import greencity.service.CommitInfoService;
+import java.io.File;
+import java.io.IOException;
+import java.time.ZoneId;
+import java.time.format.DateTimeFormatter;
+import lombok.extern.slf4j.Slf4j;
+import org.eclipse.jgit.lib.Repository;
+import org.eclipse.jgit.revwalk.RevCommit;
+import org.eclipse.jgit.revwalk.RevWalk;
+import org.eclipse.jgit.storage.file.FileRepositoryBuilder;
+import org.springframework.stereotype.Service;
+
+/**
+ * Service implementation for fetching Git commit information.
+ */
+@Service
+@Slf4j
+public class CommitInfoServiceImpl implements CommitInfoService {
+    private Repository repository;
+
+    private static final String COMMIT_REF = "HEAD";
+
+    public CommitInfoServiceImpl() {
+        try {
+            repository = new FileRepositoryBuilder()
+                .setGitDir(new File(".git"))
+                .setMustExist(true)
+                .readEnvironment()
+                .findGitDir()
+                .build();
+        } catch (IOException e) {
+            repository = null;
+            log.warn(ErrorMessage.WARNING_GIT_DIRECTORY_NOT_FOUND);
+        }
+    }
+
+    /**
+     * {@inheritDoc}
+     *
+     * @throws ResourceNotFoundException if the Git repository cannot be found, is
+     *                                   not initialized, or commit information
+     *                                   cannot be fetched due to an I/O error.
+     */
+    @Override
+    public CommitInfoDto getLatestCommitInfo() {
+        if (repository == null) {
+            throw new ResourceNotFoundException(ErrorMessage.GIT_REPOSITORY_NOT_INITIALIZED);
+        }
+
+        try (RevWalk revWalk = new RevWalk(repository)) {
+            RevCommit latestCommit = revWalk.parseCommit(repository.resolve(COMMIT_REF));
+            String latestCommitHash = latestCommit.name();
+            String latestCommitDate = DateTimeFormatter.ofPattern(AppConstant.DATE_FORMAT)
+                .withZone(ZoneId.of(AppConstant.UKRAINE_TIMEZONE))
+                .format(latestCommit.getAuthorIdent().getWhenAsInstant());
+
+            return new CommitInfoDto(latestCommitHash, latestCommitDate);
+        } catch (IOException e) {
+            throw new ResourceNotFoundException(ErrorMessage.FAILED_TO_FETCH_COMMIT_INFO + e.getMessage());
+        }
+    }
+}

chat/src/test/java/greencity/controller/CommitInfoControllerTest.java

@@ -0,0 +1,65 @@
+package greencity.controller;
+
+import greencity.dto.CommitInfoDto;
+import greencity.exception.exceptions.ResourceNotFoundException;
+import greencity.service.CommitInfoService;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+
+import org.mockito.junit.jupiter.MockitoExtension;
+import org.springframework.http.MediaType;
+import org.springframework.test.web.servlet.MockMvc;
+import org.springframework.test.web.servlet.setup.MockMvcBuilders;
+
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.jsonPath;
+import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
+import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
+
+@ExtendWith(MockitoExtension.class)
+class CommitInfoControllerTest {
+    @InjectMocks
+    private CommitInfoController commitInfoController;
+
+    @Mock
+    private CommitInfoService commitInfoService;
+
+    private MockMvc mockMvc;
+
+    @BeforeEach
+    void setUp() {
+        mockMvc = MockMvcBuilders.standaloneSetup(commitInfoController).build();
+    }
+
+    private static final String COMMIT_INFO_URL = "/commit-info";
+    private static final String COMMIT_HASH = "abc123";
+    private static final String COMMIT_DATE = "16/12/2024 12:06:32";
+
+    @Test
+    void getCommitInfoReturnsSuccessTest() throws Exception {
+        CommitInfoDto commitInfoDto = new CommitInfoDto(COMMIT_HASH, COMMIT_DATE);
+        when(commitInfoService.getLatestCommitInfo()).thenReturn(commitInfoDto);
+
+        mockMvc.perform(get(COMMIT_INFO_URL).accept(MediaType.APPLICATION_JSON))
+            .andExpect(status().isOk())
+            .andExpect(jsonPath("$.commitHash").value(COMMIT_HASH))
+            .andExpect(jsonPath("$.commitDate").value(COMMIT_DATE));
+
+        verify(commitInfoService, times(1)).getLatestCommitInfo();
+    }
+
+    @Test
+    void getCommitInfoReturnsErrorTest() throws Exception {
+        when(commitInfoService.getLatestCommitInfo()).thenThrow(new ResourceNotFoundException());
+
+        mockMvc.perform(get(COMMIT_INFO_URL))
+            .andExpect(status().isNotFound());
+
+        verify(commitInfoService, times(1)).getLatestCommitInfo();
+    }
+}