Adds Get Endorsement End Point

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

@@ -0,0 +1,7 @@
+package com.RDS.skilltree.Endorsement;
+
+import java.util.Map;
+
+public record ApiResponse<T>(T data, int statusCode, String status, String message) {
+
+}

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

@@ -0,0 +1,48 @@
+package com.RDS.skilltree.Endorsement;
+
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.http.HttpStatus;
+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.Map;
+import java.util.UUID;
+
+import static com.RDS.skilltree.Endorsement.JsonApiResponseConverter.convertToHashMap;
+
+@RestController
+@RequestMapping("/v1/endorsements")
+@Slf4j
+public class EndorsementController {
+    private final EndorsementService endorsementService;
+
+    public EndorsementController(EndorsementService endorsementService) {
+        this.endorsementService = endorsementService;
+    }
+
+    @GetMapping("/{id}")
+    public ResponseEntity<?> getEndorsementById(@PathVariable(value = "id", required = true) String id){
+        try {
+            UUID uuid = UUID.fromString(id);
+            EndorsementDTO response = endorsementService.getEndorsementById(uuid);
+            Map<String, Object> responseData = convertToHashMap(response);
+            return ResponseEntity.ok(responseData);
+
+        } catch (IllegalArgumentException e) {
+            String message = "Invalid UUID: " + id;
+            ApiResponse<String> response = new ApiResponse<>(null, HttpStatus.BAD_REQUEST.value(),HttpStatus.BAD_REQUEST.toString(),message);
+            return ResponseEntity.status(HttpStatus.BAD_REQUEST).body(response);
+        } catch (IllegalStateException e) {
+            String message = e.getMessage();
+            ApiResponse<String> response = new ApiResponse<>(null, HttpStatus.NOT_FOUND.value(),HttpStatus.NOT_FOUND.toString(),message);
+            return ResponseEntity.status(HttpStatus.NOT_FOUND).body(response);
+        } catch (Exception e) {
+            String message = e.getMessage();
+            ApiResponse<String> response = new ApiResponse<>(null, HttpStatus.BAD_REQUEST.value(),HttpStatus.BAD_REQUEST.toString(),message);
+            return ResponseEntity.status(HttpStatus.BAD_REQUEST).body(response);
+        }
+    }
+}

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

@@ -0,0 +1,38 @@
+package com.RDS.skilltree.Endorsement;
+
+import com.RDS.skilltree.EndorsementList.EndorsementListModel;
+import com.RDS.skilltree.Skill.SkillModel;
+import com.RDS.skilltree.User.UserModel;
+import com.RDS.skilltree.utils.TrackedProperties;
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+import lombok.*;
+
+import java.time.Instant;
+import java.util.List;
+import java.util.UUID;
+
+@Getter
+@Builder
+@JsonIgnoreProperties(ignoreUnknown = true)
+public class EndorsementDTO extends TrackedProperties {
+    private UUID id;
+    private UserModel user;
+    private SkillModel skill;
+    private EndorsementStatus status;
+    private List<EndorsementListModel> endorsersList;
+
+    public static EndorsementDTO toDto(EndorsementModel endorsementModel) {
+        EndorsementDTO endorsementDTO = EndorsementDTO.builder()
+                .id(endorsementModel.getId())
+                .user(endorsementModel.getUser())
+                .skill(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/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,24 @@
+package com.RDS.skilltree.Endorsement;
+import org.springframework.stereotype.Service;
+
+import java.util.*;
+
+@Service
+public class EndorsementServiceImpl implements EndorsementService {
+    private final EndorsementRepository endorsementRepository;
+
+    public EndorsementServiceImpl(EndorsementRepository endorsementRepository) {
+        this.endorsementRepository = endorsementRepository;
+    }
+
+    @Override
+    public EndorsementDTO getEndorsementById(UUID id) throws IllegalStateException {
+        Optional<EndorsementModel> endorsementModel = endorsementRepository.findById(id);
+        if (endorsementModel.isPresent()) {
+            return EndorsementDTO.toDto(endorsementModel.get());
+        } else {
+            String errorMessage = "No endorsement with the id " + id + " found";
+            throw new IllegalStateException(errorMessage);
+        }
+    }
+}

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

@@ -0,0 +1,166 @@
+package com.RDS.skilltree.Endorsement;
+
+import com.RDS.skilltree.EndorsementList.EndorsementListModel;
+import com.RDS.skilltree.Skill.SkillModel;
+import com.RDS.skilltree.User.UserModel;
+
+import java.lang.reflect.Field;
+import java.util.*;
+
+public class JsonApiResponseConverter {
+
+    public static Map<String, Object> convertToHashMap(EndorsementDTO endorsementDTO) {
+        Map<String, Object> result = new HashMap<>();
+        Map<String, Object> dataMap = new HashMap<>();
+
+        dataMap.put("id", endorsementDTO.getId());
+        dataMap.put("type", "endorsement");
+        dataMap.put("links", createLinksMap(endorsementDTO.getId().toString()));
+        dataMap.put("attributes", createAttributesHashMap(endorsementDTO));
+        dataMap.put("relationships",createRelationshipsHashMap(endorsementDTO));
+        dataMap.put("included",createIncludedList(endorsementDTO));
+        result.put("data", dataMap);
+        return result;
+    }
+
+    private static Map<String, Object> createLinksMap(String id) {
+        Map<String, Object> links = new HashMap<>();
+        links.put("self", "/endorsements/" + id);
+        return links;
+    }
+
+    private static Map<String, Object> createAttributesHashMap(EndorsementDTO endorsementDTO) {
+        Map<String, Object> attributes = new HashMap<>();
+        attributes.put("status", endorsementDTO.getStatus());
+        attributes.put("createdAt", endorsementDTO.getCreatedAt());
+        attributes.put("updatedAt", endorsementDTO.getUpdatedAt());
+        return attributes;
+    }
+
+    private static Map<String, Object> createRelationshipsHashMap(EndorsementDTO endorsementDTO) {
+        Map<String, Object> relationships = new HashMap<>();
+
+        Map<String, Object> userRelationship = getIdHashmap(endorsementDTO.getUser(),"user");
+        relationships.put("user", userRelationship);
+
+
+        Map<String, Object> skillRelationship = getIdHashmap(endorsementDTO.getSkill(),"skill");
+        relationships.put("skill", skillRelationship);
+
+        Map<String, Object> createdBy = getIdHashmap(endorsementDTO.getCreatedBy(),"user");
+        relationships.put("createdBy", createdBy);
+
+        Map<String, Object> updatedBy = getIdHashmap(endorsementDTO.getUpdatedBy(),"user");
+        relationships.put("updatedBy", updatedBy);
+
+        List<Map<String, Object>> endorsersList = new ArrayList<>();
+        for (EndorsementListModel endorserListModel : endorsementDTO.getEndorsersList()) {
+            Map<String, Object> data = new HashMap<>();
+            data.put("id",endorserListModel.getId());
+            data.put("type","endorser");
+            endorsersList.add(data);
+        }
+
+        Map<String, Object> endorseRelationships = new HashMap<>();
+        endorseRelationships.put("data",endorsersList);
+        relationships.put("endorsersList",endorseRelationships);
+
+        return relationships;
+    }
+
+    private static List<Map<String, Object>> createIncludedList(EndorsementDTO endorsementDTO) {
+        List<Map<String, Object>> includedList = new ArrayList<>();
+        includedList.add(extractSkillsAttributes(endorsementDTO.getSkill()));
+        includedList.add(extractUsersAttributes(endorsementDTO.getUser()));
+        for (EndorsementListModel endorserListModel : endorsementDTO.getEndorsersList()) {
+            includedList.add(extractEndorsementListModelAttributes(endorserListModel));
+        }
+        return includedList;
+    }
+    private static Map<String,Object> extractEndorsementListModelAttributes(EndorsementListModel endorsementListModel) {
+        Map<String, Object> result = new HashMap<>();
+
+        Map<String, Object> attributes = new HashMap<>();
+        attributes.put("type",endorsementListModel.getType());
+        attributes.put("deleted",endorsementListModel.isDeleted());
+        attributes.put("description",endorsementListModel.getDescription());
+        attributes.put("createdAt",endorsementListModel.getCreatedAt());
+        attributes.put("updatedAt",endorsementListModel.getUpdatedAt());
+
+        Map<String, Object> relationships = new HashMap<>();
+        relationships.put("endorsersList",getIdHashmap(endorsementListModel.getEndorser(),"user"));
+        relationships.put("createdBy",getIdHashmap(endorsementListModel.getCreatedBy(),"user"));
+        relationships.put("updatedBy",getIdHashmap(endorsementListModel.getUpdatedBy(),"user"));
+
+        result.put("id",endorsementListModel.getId());
+        result.put("type","EndorsementList");
+        result.put("attributes",attributes);
+        result.put("relationships",relationships);
+        return result;
+    }
+    private static Map<String,Object> extractSkillsAttributes(SkillModel skillModel) {
+        Map<String, Object> result = new HashMap<>();
+
+        Map<String, Object> attributes = new HashMap<>();
+        attributes.put("name",skillModel.getName());
+        attributes.put("type",skillModel.getType());
+        attributes.put("createdAt",skillModel.getCreatedAt());
+        attributes.put("updatedAt",skillModel.getUpdatedAt());
+        attributes.put("isDeleted",skillModel.isDeleted());
+
+        Map<String, Object> relationships = new HashMap<>();
+        relationships.put("createdBy",getIdHashmap(skillModel.getCreatedBy(),"user"));
+        relationships.put("updatedBy",getIdHashmap(skillModel.getUpdatedBy(),"user"));
+
+        result.put("id",skillModel.getId());
+        result.put("type","skill");
+        result.put("attributes",attributes);
+        result.put("relationships",relationships);
+
+        return result;
+    }
+    private static Map<String,Object> extractUsersAttributes(UserModel userModel) {
+        Map<String, Object> result = new HashMap<>();
+
+        Map<String, Object> attributes = new HashMap<>();
+        attributes.put("firstName",userModel.getFirstName());
+        attributes.put("lastName",userModel.getLastName());
+        attributes.put("rdsUserId",userModel.getRdsUserId());
+        attributes.put("role",userModel.getRole());
+        attributes.put("imageUrl",userModel.getImageUrl());
+        attributes.put("createdAt",userModel.getCreatedAt());
+        attributes.put("updatedAt",userModel.getUpdatedAt());
+
+        Map<String, Object> relationships = new HashMap<>();
+        relationships.put("createdBy",getIdHashmap(userModel.getCreatedBy(),"user"));
+        relationships.put("updatedBy",getIdHashmap(userModel.getUpdatedBy(),"user"));
+        result.put("id",userModel.getId());
+        result.put("type","user");
+        result.put("attributes",attributes);
+        result.put("relationships",relationships);
+        return result;
+    }
+    private static Map<String, Object> getIdHashmap(Object dto, String type) {
+        Map<String, Object> relationship = new HashMap<>();
+        Map<String, Object> data = new HashMap<>();
+        try {
+            if (dto == null) {
+                data.put("type", type);
+                data.put("id", null);
+            } else {
+                Field idField = dto.getClass().getDeclaredField("id");
+                idField.setAccessible(true);
+                Object id = idField.get(dto);
+
+                data.put("type", type);
+                data.put("id", id);
+
+            }
+        } catch (NoSuchFieldException | IllegalAccessException e) {
+            e.printStackTrace();
+        }
+        relationship.put("data", data);
+        return relationship;
+    }
+
+}

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;
     }
-}
+}