create EndorsementController

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

@@ -2,6 +2,7 @@
 
 import com.RDS.skilltree.Common.Response.GenericResponse;
 import jakarta.persistence.EntityNotFoundException;
+import jakarta.validation.Valid;
 import jakarta.validation.constraints.Min;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
@@ -46,4 +47,14 @@ public ResponseEntity<GenericResponse<EndorsementDTO>> getEndorsementById(@PathV
             return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(new GenericResponse<EndorsementDTO>(null, message));
         }
     }
+
+    @PostMapping(value="")
+    public ResponseEntity<?> postEndorsement(@RequestBody @Valid EndorsementDRO endorsementDRO) {
+
+        EndorsementModel endorsementModel = endorsementService.createEndorsement(endorsementDRO);
+            if (endorsementModel != null)
+                return new ResponseEntity<>(endorsementModel, HttpStatus.CREATED);
+            return new ResponseEntity<>("Failed to create endorsement", HttpStatus.BAD_REQUEST);
+
+    }
 }

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

@@ -0,0 +1,21 @@
+package com.RDS.skilltree.Endorsement;
+
+import jakarta.validation.constraints.NotNull;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+import java.util.UUID;
+
+@NoArgsConstructor
+@AllArgsConstructor
+@Data
+@Builder
+public class EndorsementDRO {
+    @NotNull(message = "user id cannot be null")
+    private UUID userId;
+    @NotNull(message = "skill id cannot be null")
+    private UUID skillId;
+
+}

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

@@ -7,4 +7,5 @@
 public interface EndorsementService {
     EndorsementDTO getEndorsementById(UUID id);
     Page<EndorsementModel> getEndorsements(PageRequest pageRequest);
+    EndorsementModel createEndorsement(EndorsementDRO endorsementDRO);
 }

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

@@ -1,5 +1,10 @@
 package com.RDS.skilltree.Endorsement;
 
+import com.RDS.skilltree.Exceptions.NoEntityException;
+import com.RDS.skilltree.Skill.SkillModel;
+import com.RDS.skilltree.Skill.SkillRepository;
+import com.RDS.skilltree.User.UserModel;
+import com.RDS.skilltree.User.UserRepository;
 import jakarta.persistence.EntityNotFoundException;
 import lombok.RequiredArgsConstructor;
 import org.springframework.data.domain.Page;
@@ -13,6 +18,8 @@
 @RequiredArgsConstructor
 public class EndorsementServiceImpl implements EndorsementService {
     private final EndorsementRepository endorsementRepository;
+    private final UserRepository userRepository;
+    private final SkillRepository skillRepository;
 
     @Override
     public EndorsementDTO getEndorsementById(UUID id) throws IllegalStateException {
@@ -25,4 +32,24 @@ public EndorsementDTO getEndorsementById(UUID id) throws IllegalStateException {
     public Page<EndorsementModel> getEndorsements(PageRequest pageRequest) {
         return endorsementRepository.findAll(pageRequest);
     }
+
+    @Override
+    public EndorsementModel createEndorsement(EndorsementDRO endorsementDRO) {
+        UUID userId = endorsementDRO.getUserId();
+        UUID skillId = endorsementDRO.getSkillId();
+        Optional<UserModel> userOptional = userRepository.findById(userId);
+        Optional<SkillModel> skillOptional = skillRepository.findById(skillId);
+        if (userOptional.isPresent() && skillOptional.isPresent()) {
+        EndorsementModel endorsementModel =  EndorsementModel.builder()
+                .user(userOptional.get())
+                .skill(skillOptional.get())
+                .build();
+
+            return endorsementRepository.save(endorsementModel);
+        } else {
+            if (userOptional.isEmpty())
+                throw new NoEntityException("User with id:" + userId + " not found");
+            throw new NoEntityException("Skill with id:" + skillId + " not found");
+        }
+    }
 }

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

@@ -0,0 +1,20 @@
+package com.RDS.skilltree.EndorsementList;
+
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+import java.util.UUID;
+
+@AllArgsConstructor
+@NoArgsConstructor
+@Data
+@Builder
+public class EndorsementListDRO {
+    private String description;
+    private UUID endorsementId;
+    private UUID endorserId;
+    private EndorsementType type;
+
+}

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

@@ -0,0 +1,19 @@
+package com.RDS.skilltree.EndorsementList;
+
+import com.RDS.skilltree.User.UserModel;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+
+import java.util.UUID;
+
+@Builder
+@Data
+@AllArgsConstructor
+public class EndorsementListDTO {
+    private UUID id;
+    private String description;
+    private UserModel endorser;
+    private EndorsementType type;
+
+}

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

@@ -0,0 +1,52 @@
+package com.RDS.skilltree.EndorsementList;
+
+import com.RDS.skilltree.Endorsement.EndorsementModel;
+import com.RDS.skilltree.Endorsement.EndorsementRepository;
+import com.RDS.skilltree.Exceptions.NoEntityException;
+import com.RDS.skilltree.User.UserModel;
+import com.RDS.skilltree.User.UserRepository;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+import java.util.Optional;
+import java.util.UUID;
+
+@Service
+public class EndorsementListService {
+    @Autowired
+    private final EndorsementListRepository endorsementListRepository;
+    private final EndorsementRepository endorsementRepository;
+    private final UserRepository userRepository;
+
+    public EndorsementListService(EndorsementListRepository endorsementListRepository, EndorsementRepository endorsementRepository, UserRepository userRepository) {
+        this.endorsementListRepository = endorsementListRepository;
+        this.endorsementRepository = endorsementRepository;
+        this.userRepository = userRepository;
+    }
+
+
+    public EndorsementListModel createEndorsementListEntry(EndorsementListDRO endorsementListDRO) {
+        EndorsementListModel endorsementListEntry = new EndorsementListModel();
+
+        UUID endorserId = endorsementListDRO.getEndorserId();
+        UUID endorsementId = endorsementListDRO.getEndorsementId();
+        Optional<UserModel> endorserOptional = userRepository.findById(endorserId);
+        Optional<EndorsementModel> endorsementOptional = endorsementRepository.findById(endorsementId);
+        if (endorserOptional.isPresent() && endorsementOptional.isPresent()) {
+
+            endorsementListEntry.setEndorser(endorserOptional.get());
+            endorsementListEntry.setEndorsement(endorsementOptional.get());
+            endorsementListEntry.setDescription(endorsementListDRO.getDescription());
+            endorsementListEntry.setType(endorsementListDRO.getType());
+            endorsementListRepository.save(endorsementListEntry);
+            return endorsementListEntry;
+
+        } else {
+            if (endorserOptional.isEmpty())
+                throw new NoEntityException("User with id:" + endorserId + " not found");
+            throw new NoEntityException("Endorsement with id:" + endorsementId + " not found");
+        }
+
+    }
+
+}

skill-tree/src/test/java/com/RDS/skilltree/SkillTreeApplicationTests.java

@@ -1,13 +1,9 @@
 package com.RDS.skilltree;
 
-import org.junit.jupiter.api.Test;
 import org.springframework.boot.test.context.SpringBootTest;
 
 @SpringBootTest
 class SkillTreeApplicationTests {
 
-	@Test
-	void contextLoads() {
-	}
 
 }

skill-tree/src/test/java/com/RDS/skilltree/unit/EndorsementListServiceTest.java

@@ -0,0 +1,118 @@
+package com.RDS.skilltree.unit;
+
+import com.RDS.skilltree.Endorsement.EndorsementModel;
+import com.RDS.skilltree.Endorsement.EndorsementRepository;
+import com.RDS.skilltree.EndorsementList.*;
+import com.RDS.skilltree.Exceptions.NoEntityException;
+import com.RDS.skilltree.User.UserModel;
+import com.RDS.skilltree.User.UserRepository;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+
+import java.util.Optional;
+import java.util.UUID;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.Mockito.*;
+
+class EndorsementListServiceTest {
+
+    @Mock
+    private EndorsementListRepository endorsementListRepository;
+
+    @Mock
+    private EndorsementRepository endorsementRepository;
+
+    @Mock
+    private UserRepository userRepository;
+
+    @InjectMocks
+    private EndorsementListService endorsementListService;
+
+    @BeforeEach
+    void setUp() {
+        MockitoAnnotations.openMocks(this);
+    }
+
+    @Test
+    void testCreateEndorsementListEntry() {
+        // Mock data
+        UUID endorserId = UUID.randomUUID();
+        UUID endorsementId = UUID.randomUUID();
+        EndorsementListDRO endorsementListDRO = new EndorsementListDRO();
+        endorsementListDRO.setEndorserId(endorserId);
+        endorsementListDRO.setEndorsementId(endorsementId);
+        endorsementListDRO.setDescription("Test Description");
+        endorsementListDRO.setType(EndorsementType.POSITIVE);
+
+        UserModel mockUser = new UserModel();
+        mockUser.setId(endorserId);
+
+        EndorsementModel mockEndorsement = new EndorsementModel();
+        mockEndorsement.setId(endorsementId);
+
+        // Mock the repository behavior
+        when(userRepository.findById(endorserId)).thenReturn(Optional.of(mockUser));
+        when(endorsementRepository.findById(endorsementId)).thenReturn(Optional.of(mockEndorsement));
+
+        // Call the service method
+        EndorsementListModel result = endorsementListService.createEndorsementListEntry(endorsementListDRO);
+
+        // Verify the interactions
+        verify(endorsementListRepository, times(1)).save(any(EndorsementListModel.class));
+
+        // Assertions
+        assertNotNull(result);
+        assertEquals(endorserId, result.getEndorser().getId());
+        assertEquals(endorsementId, result.getEndorsement().getId());
+        assertEquals("Test Description", result.getDescription());
+        assertEquals(EndorsementType.POSITIVE, result.getType());
+    }
+
+    @Test
+    void testCreateEndorsementListEntryWithInvalidUser() {
+        UUID endorserId = UUID.randomUUID();
+        UUID endorsementId = UUID.randomUUID();
+        EndorsementListDRO endorsementListDRO = new EndorsementListDRO();
+        endorsementListDRO.setEndorserId(endorserId);
+        endorsementListDRO.setEndorsementId(endorsementId);
+
+        // Mock the repository behavior for an invalid user
+        when(userRepository.findById(endorserId)).thenReturn(Optional.empty());
+
+        // Assert that a NoEntityException is thrown
+        NoEntityException exception = assertThrows(NoEntityException.class,
+                () -> endorsementListService.createEndorsementListEntry(endorsementListDRO));
+        assertEquals("User with id:" + endorserId + " not found", exception.getMessage());
+
+        // Verify that save method is not called
+        verify(endorsementListRepository, never()).save(any(EndorsementListModel.class));
+    }
+
+    @Test
+    void testCreateEndorsementListEntryWithInvalidEndorsement() {
+        UUID endorserId = UUID.randomUUID();
+        UUID endorsementId = UUID.randomUUID();
+        EndorsementListDRO endorsementListDRO = new EndorsementListDRO();
+        endorsementListDRO.setEndorserId(endorserId);
+        endorsementListDRO.setEndorsementId(endorsementId);
+
+        UserModel mockUser = new UserModel();
+        mockUser.setId(endorserId);
+
+        // Mock the repository behavior for an invalid endorsement
+        when(userRepository.findById(endorserId)).thenReturn(Optional.of(mockUser));
+        when(endorsementRepository.findById(endorsementId)).thenReturn(Optional.empty());
+
+        // Assert that a NoEntityException is thrown
+        NoEntityException exception = assertThrows(NoEntityException.class,
+                () -> endorsementListService.createEndorsementListEntry(endorsementListDRO));
+        assertEquals("Endorsement with id:" + endorsementId + " not found", exception.getMessage());
+
+        // Verify that save method is not called
+        verify(endorsementListRepository, never()).save(any(EndorsementListModel.class));
+    }
+}