Adds Get Endorsement End Point

skill-tree /src/main/java/com/RDS/skilltree/Endorsement/EndorsementController.java

@@ -0,0 +1,41 @@
+package com.RDS.skilltree.Endorsement;
+
+import jakarta.persistence.EntityNotFoundException;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.http.HttpHeaders;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.MediaType;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+import java.util.UUID;
+
+@RestController
+@RequestMapping("/v1/endorsements")
+@Slf4j
+@RequiredArgsConstructor
+public class EndorsementController {
+    private final EndorsementService endorsementService;
+
+    @GetMapping("/{id}")
+    public ResponseEntity<EndorsementResponse<EndorsementDTO>> getEndorsementById(@PathVariable(value = "id", required = true) String id){
+        HttpHeaders headers = new HttpHeaders();
+        headers.setContentType(MediaType.APPLICATION_JSON);
+        try {
+            UUID uuid = UUID.fromString(id);
+            EndorsementDTO response = endorsementService.getEndorsementById(uuid);
+            return ResponseEntity.ok().headers(headers).body(new EndorsementResponse<EndorsementDTO>(response, "Data retrieved successfully"));
+        } catch (IllegalArgumentException e) {
+            String message = "Invalid UUID: " + id;
+            return ResponseEntity.status(HttpStatus.BAD_REQUEST).headers(headers).body(new EndorsementResponse<EndorsementDTO>(null, message));
+        } catch (EntityNotFoundException e) {
+            return ResponseEntity.status(HttpStatus.NOT_FOUND).headers(headers).body(new EndorsementResponse<EndorsementDTO>(null, e.getMessage()));
+        } catch (Exception e) {
+            String message = "Something went wrong. Please contact admin.";
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).headers(headers).body(new EndorsementResponse<EndorsementDTO>(null, message));
+        }
+    }
+}

skill-tree /src/main/java/com/RDS/skilltree/Endorsement/EndorsementDTO.java

@@ -0,0 +1,36 @@
+package com.RDS.skilltree.Endorsement;
+
+import com.RDS.skilltree.EndorsementList.EndorsementListModel;
+import com.RDS.skilltree.Skill.SkillDTO;
+import com.RDS.skilltree.User.UserDTO;
+import com.RDS.skilltree.utils.TrackedProperties;
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+import lombok.*;
+import java.util.List;
+import java.util.UUID;
+
+@Getter
+@Builder
+@JsonIgnoreProperties(ignoreUnknown = true)
+public class EndorsementDTO extends TrackedProperties {
+    private UUID id;
+    private UserDTO user;
+    private SkillDTO skill;
+    private EndorsementStatus status;
+    private List<EndorsementListModel> endorsersList;
+
+    public static EndorsementDTO toDto(EndorsementModel endorsementModel) {
+        EndorsementDTO endorsementDTO = EndorsementDTO.builder()
+                .id(endorsementModel.getId())
+                .user(UserDTO.toDTO(endorsementModel.getUser()))
+                .skill(SkillDTO.toDto(endorsementModel.getSkill()))
+                .status(endorsementModel.getStatus())
+                .endorsersList(endorsementModel.getEndorsersList())
+                .build();
+        endorsementDTO.setCreatedAt(endorsementModel.getCreatedAt());
+        endorsementDTO.setUpdatedAt(endorsementModel.getUpdatedAt());
+        endorsementDTO.setCreatedBy(endorsementModel.getCreatedBy());
+        endorsementDTO.setUpdatedBy(endorsementModel.getUpdatedBy());
+        return endorsementDTO;
+    }
+}

skill-tree /src/main/java/com/RDS/skilltree/Endorsement/EndorsementModel.java

@@ -4,19 +4,19 @@
 import com.RDS.skilltree.Skill.SkillModel;
 import com.RDS.skilltree.User.UserModel;
 import com.RDS.skilltree.utils.TrackedProperties;
+import com.fasterxml.jackson.annotation.JsonManagedReference;
 import jakarta.persistence.*;
-import lombok.Data;
-import lombok.EqualsAndHashCode;
-import lombok.NoArgsConstructor;
+import lombok.*;
 
 import java.util.ArrayList;
 import java.util.List;
 import java.util.UUID;
 
-@EqualsAndHashCode(callSuper = true)
-@Entity
+@AllArgsConstructor
 @NoArgsConstructor
-@Data
+@Entity
+@Builder
+@Getter
 @Table(name = "endorsements")
 public class EndorsementModel extends TrackedProperties {
     @Id
@@ -33,15 +33,10 @@ public class EndorsementModel extends TrackedProperties {
     private SkillModel skill;
 
     @OneToMany(mappedBy = "endorsement")
+    @JsonManagedReference
     private List<EndorsementListModel> endorsersList = new ArrayList<>();
 
     @Column(name = "endorsement_status")
     @Enumerated(value = EnumType.STRING)
     private EndorsementStatus status = EndorsementStatus.PENDING;
-
-    public EndorsementModel(UserModel user, SkillModel skill) {
-        this.status = EndorsementStatus.PENDING;
-        this.user = user;
-        this.skill = skill;
-    }
-}
+}

skill-tree /src/main/java/com/RDS/skilltree/Endorsement/EndorsementResponse.java

@@ -0,0 +1,12 @@
+package com.RDS.skilltree.Endorsement;
+
+import lombok.*;
+
+@Getter
+@Setter
+@NoArgsConstructor
+@AllArgsConstructor
+public class EndorsementResponse<T> {
+    private T data;
+    private String message;
+}

skill-tree /src/main/java/com/RDS/skilltree/Endorsement/EndorsementService.java

@@ -0,0 +1,6 @@
+package com.RDS.skilltree.Endorsement;
+import java.util.UUID;
+
+public interface EndorsementService {
+    EndorsementDTO getEndorsementById(UUID id);
+}

skill-tree /src/main/java/com/RDS/skilltree/Endorsement/EndorsementServiceImpl.java

@@ -0,0 +1,18 @@
+package com.RDS.skilltree.Endorsement;
+import jakarta.persistence.EntityNotFoundException;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Service;
+
+import java.util.*;
+
+@Service
+@RequiredArgsConstructor
+public class EndorsementServiceImpl implements EndorsementService {
+    private final EndorsementRepository endorsementRepository;
+
+    @Override
+    public EndorsementDTO getEndorsementById(UUID id) throws IllegalStateException {
+        Optional<EndorsementModel> endorsementModel = endorsementRepository.findById(id);
+        return EndorsementDTO.toDto(endorsementModel.orElseThrow(() -> new EntityNotFoundException("No endorsement with the id " + id + " found")));
+    }
+}

skill-tree /src/main/java/com/RDS/skilltree/EndorsementList/EndorsementListModel.java

@@ -3,6 +3,7 @@
 import com.RDS.skilltree.Endorsement.EndorsementModel;
 import com.RDS.skilltree.User.UserModel;
 import com.RDS.skilltree.utils.TrackedProperties;
+import com.fasterxml.jackson.annotation.JsonBackReference;
 import jakarta.persistence.*;
 import lombok.Data;
 import lombok.EqualsAndHashCode;
@@ -23,6 +24,7 @@ public class EndorsementListModel extends TrackedProperties {
 
     @JoinColumn(name = "endorsement_id", referencedColumnName = "id")
     @ManyToOne(targetEntity = EndorsementModel.class, cascade = CascadeType.ALL)
+    @JsonBackReference
     private EndorsementModel endorsement;
 
     @JoinColumn(name = "user_id", referencedColumnName = "id")
@@ -40,11 +42,11 @@ public class EndorsementListModel extends TrackedProperties {
     private EndorsementType type;
 
     public EndorsementListModel(EndorsementModel endorsement, UserModel endorser, String description,
-            EndorsementType type) {
+                                EndorsementType type) {
         this.endorsement = endorsement;
         this.endorser = endorser;
         this.description = description;
         this.type = type;
         this.deleted = false;
     }
-}
+}

skill-tree /src/test/java/com/RDS/skilltree/Endorsement/EndorsementServiceTest.java

@@ -0,0 +1,66 @@
+package com.RDS.skilltree.Endorsement;
+
+import com.RDS.skilltree.Skill.SkillModel;
+import com.RDS.skilltree.User.UserModel;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnitRunner;
+import org.springframework.beans.factory.annotation.Autowired;
+
+import static org.junit.Assert.*;
+import static org.mockito.Mockito.when;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+
+import java.time.Instant;
+import java.util.Optional;
+import java.util.UUID;
+
+@RunWith(MockitoJUnitRunner.class)
+public class EndorsementServiceTest {
+    @Mock
+    private EndorsementRepository endorsementRepository;
+
+    @InjectMocks
+    @Autowired
+    private EndorsementServiceImpl underTest;
+
+    @Test
+    public void itShouldGetEndorsementsById() {
+        UUID endorsementId = UUID.randomUUID();
+        UUID userId = UUID.randomUUID();
+        UUID skillId = UUID.randomUUID();
+
+        UserModel userModel = UserModel.builder().id(userId).build();
+        SkillModel skillModel = SkillModel.builder().id(skillId).build();
+        EndorsementModel endorsementModel = EndorsementModel.builder()
+                .id(endorsementId)
+                .user(userModel)
+                .skill(skillModel)
+                .build();
+        endorsementModel.setCreatedAt(Instant.now());
+        endorsementModel.setUpdatedAt(Instant.now());
+        endorsementModel.setCreatedBy(userModel);
+        endorsementModel.setUpdatedBy(userModel);
+
+        when(endorsementRepository.findById(endorsementId)).thenReturn(Optional.of(endorsementModel));
+
+        EndorsementDTO result = underTest.getEndorsementById(endorsementId);
+
+        assertNotNull(result);
+        assertEquals("The Endorsement Id doesn't matches the expected endorsement Id", endorsementId, result.getId());
+    }
+
+    @Test
+    public void itShouldHandleEndorsementNotFound() {
+        UUID nonExistentEndorsementId = UUID.randomUUID();
+        when(endorsementRepository.findById(nonExistentEndorsementId)).thenReturn(Optional.empty());
+
+        assertThatThrownBy(() -> underTest.getEndorsementById(nonExistentEndorsementId))
+                .isInstanceOf(IllegalStateException.class)
+                .hasMessageContaining("No endorsement with the id " + nonExistentEndorsementId + " found");
+    }
+
+}