feat: create relationship import system

sample-data/competencies-sample.csv

@@ -0,0 +1,12 @@
+title,description
+Linear Algebra,Understand vectors and matrices and their applications in computer science.
+Probability and Statistics,Apply probability theory and statistical inference to model uncertainty.
+Graph Theory,"Represent and analyse graphs, implement BFS and DFS, and solve shortest-path problems."
+Lambda Calculus,"Understand alpha-equivalence, beta-reduction, and Church encodings."
+Logic and Proof Techniques,"Construct formal proofs using propositional logic, induction, and proof by contradiction."
+Compiler Design,"Implement lexers, parsers, and code generators; understand IR and optimisation."
+Memory Management,"Manage heap and stack allocation, understand garbage collection and ownership."
+Design Patterns,Apply creational and structural design patterns to build maintainable software.
+API Design,"Design RESTful and GraphQL APIs with versioning, pagination, and error handling."
+Distributed Systems,"Reason about CAP theorem, implement consensus protocols and distributed stores."
+Data Structures,

sample-data/competencies-sample.json

@@ -0,0 +1,43 @@
+[
+  {
+    "title": "Linear Algebra",
+    "description": "Understand vectors, matrices, transformations, eigenvalues, and their applications in computer science."
+  },
+  {
+    "title": "Probability and Statistics",
+    "description": "Apply probability theory, distributions, and statistical inference to model uncertainty in computational systems."
+  },
+  {
+    "title": "Graph Theory",
+    "description": "Represent and analyse graphs, implement traversal algorithms (BFS, DFS), and solve shortest-path and spanning-tree problems."
+  },
+  {
+    "title": "Lambda Calculus",
+    "description": "Understand the foundations of functional computation, alpha-equivalence, beta-reduction, and Church encodings."
+  },
+  {
+    "title": "Logic and Proof Techniques",
+    "description": "Construct formal proofs using propositional and predicate logic, induction, and proof by contradiction."
+  },
+  {
+    "title": "Compiler Design",
+    "description": "Implement lexers, parsers, semantic analysers, and code generators; understand intermediate representations and optimisation passes."
+  },
+  {
+    "title": "Memory Management",
+    "description": "Manage heap and stack allocation, understand garbage collection strategies, and reason about ownership and borrowing."
+  },
+  {
+    "title": "Design Patterns",
+    "description": "Apply creational, structural, and behavioural design patterns to build maintainable and extensible software systems."
+  },
+  {
+    "title": "API Design",
+    "description": "Design RESTful and GraphQL APIs; apply versioning, pagination, and error-handling conventions."
+  },
+  {
+    "title": "Distributed Systems",
+    "description": "Reason about consistency, availability, and partition tolerance; implement consensus protocols and distributed data stores."
+  },
+  { "title": "Duplicate: Data Structures" }
+]

sample-data/relationships-sample.csv

@@ -0,0 +1,21 @@
+originId,originTitle,destinationId,destinationTitle,relationshipType
+comp_ds_001,,comp_fp_001,,ASSUMES
+comp_fp_001,,comp_hof_001,,EXTENDS
+comp_hof_001,,comp_poly_001,,EXTENDS
+comp_poly_001,,comp_mod_001,,ASSUMES
+comp_fp_001,,comp_mod_001,,ASSUMES
+,Data Structures,comp_alg_001,,ASSUMES
+comp_alg_001,,,Complexity Theory,EXTENDS
+,Complexity Theory,comp_alg_001,,UNRELATED
+,Functional Programming,,Type Checking and Inference,ASSUMES
+,Higher-Order Functions,,Functional Programming,MATCHES
+comp_alg_001,,,Parsing and Grammars,ASSUMES
+,Evaluation Strategies,comp_fp_001,,EXTENDS
+comp_fp_001,,comp_err_001,,ASSUMES
+comp_alg_001,,comp_test_001,,EXTENDS
+comp_db_001,,comp_sec_001,,ASSUMES
+comp_os_001,,comp_conc_001,,ASSUMES
+comp_net_001,,comp_sec_001,,ASSUMES
+,Version Control with Git,,Software Security,UNRELATED
+,Testing and Verification,,Error Handling,EXTENDS
+,Object-Oriented Design,,Module System and Abstraction,MATCHES

sample-data/relationships-sample.json

@@ -0,0 +1,103 @@
+[
+  {
+    "originId": "comp_ds_001",
+    "destinationId": "comp_fp_001",
+    "relationshipType": "ASSUMES"
+  },
+  {
+    "originId": "comp_fp_001",
+    "destinationId": "comp_hof_001",
+    "relationshipType": "EXTENDS"
+  },
+  {
+    "originId": "comp_hof_001",
+    "destinationId": "comp_poly_001",
+    "relationshipType": "EXTENDS"
+  },
+  {
+    "originId": "comp_poly_001",
+    "destinationId": "comp_mod_001",
+    "relationshipType": "ASSUMES"
+  },
+  {
+    "originId": "comp_fp_001",
+    "destinationId": "comp_mod_001",
+    "relationshipType": "ASSUMES"
+  },
+
+  {
+    "originTitle": "Data Structures",
+    "destinationId": "comp_alg_001",
+    "relationshipType": "ASSUMES"
+  },
+  {
+    "originId": "comp_alg_001",
+    "destinationTitle": "Complexity Theory",
+    "relationshipType": "EXTENDS"
+  },
+  {
+    "originTitle": "Functional Programming",
+    "destinationTitle": "Type Checking and Inference",
+    "relationshipType": "ASSUMES"
+  },
+  {
+    "originTitle": "Higher-Order Functions",
+    "destinationTitle": "Functional Programming",
+    "relationshipType": "MATCHES"
+  },
+  {
+    "originTitle": "Testing and Verification",
+    "destinationTitle": "Error Handling",
+    "relationshipType": "EXTENDS"
+  },
+
+  {
+    "originId": "comp_alg_001",
+    "destinationTitle": "Parsing and Grammars",
+    "relationshipType": "ASSUMES"
+  },
+  {
+    "originTitle": "Evaluation Strategies",
+    "destinationId": "comp_fp_001",
+    "relationshipType": "EXTENDS"
+  },
+  {
+    "originId": "comp_os_001",
+    "destinationTitle": "Concurrency and Parallelism",
+    "relationshipType": "ASSUMES"
+  },
+
+  {
+    "originId": "comp_db_001",
+    "destinationId": "comp_sec_001",
+    "relationshipType": "ASSUMES"
+  },
+  {
+    "originId": "comp_net_001",
+    "destinationId": "comp_sec_001",
+    "relationshipType": "ASSUMES"
+  },
+  {
+    "originId": "comp_alg_001",
+    "destinationId": "comp_test_001",
+    "relationshipType": "EXTENDS"
+  },
+  {
+    "originId": "comp_fp_001",
+    "destinationId": "comp_err_001",
+    "relationshipType": "ASSUMES"
+  },
+
+  {
+    "originTitle": "Version Control with Git",
+    "destinationTitle": "Software Security",
+    "relationshipType": "UNRELATED"
+  },
+  {
+    "originTitle": "Object-Oriented Design",
+    "destinationTitle": "Module System and Abstraction",
+    "relationshipType": "MATCHES"
+  },
+
+  { "originId": "comp_ds_001", "destinationId": "comp_alg_001" }
+]

server/src/main/java/de/tum/cit/memo/controller/AdminController.java

@@ -3,6 +3,8 @@
 import com.fasterxml.jackson.databind.ObjectMapper;
 import de.tum.cit.memo.dto.CompetencyImportRow;
 import de.tum.cit.memo.dto.ImportResult;
+import de.tum.cit.memo.dto.RelationshipImportRow;
+import de.tum.cit.memo.service.CompetencyRelationshipService;
 import de.tum.cit.memo.service.CompetencyService;
 import io.swagger.v3.oas.annotations.Operation;
 import io.swagger.v3.oas.annotations.security.SecurityRequirement;
@@ -13,9 +15,9 @@
 import java.nio.charset.StandardCharsets;
 import java.util.ArrayList;
 import java.util.List;
+import lombok.RequiredArgsConstructor;
 import org.apache.commons.csv.CSVFormat;
 import org.apache.commons.csv.CSVRecord;
-import lombok.RequiredArgsConstructor;
 import org.springframework.http.ResponseEntity;
 import org.springframework.web.bind.annotation.PostMapping;
 import org.springframework.web.bind.annotation.RequestBody;
@@ -33,6 +35,7 @@
 public class AdminController {
 
     private final CompetencyService competencyService;
+    private final CompetencyRelationshipService competencyRelationshipService;
     private final ObjectMapper objectMapper;
 
     @PostMapping("/competencies/import")
@@ -58,6 +61,67 @@ public ResponseEntity<ImportResult> importFile(
         return ResponseEntity.ok(competencyService.bulkImportCompetencies(rows));
     }
 
+    @PostMapping("/relationships/import")
+    @Operation(summary = "Bulk import competency relationships from JSON array")
+    public ResponseEntity<ImportResult> importRelationshipsJson(
+        @RequestBody List<RelationshipImportRow> rows
+    ) {
+        return ResponseEntity.ok(competencyRelationshipService.bulkImportRelationships(rows));
+    }
+
+    @PostMapping(value = "/relationships/import/file", consumes = "multipart/form-data")
+    @Operation(summary = "Bulk import competency relationships from CSV or JSON file")
+    public ResponseEntity<ImportResult> importRelationshipsFile(
+        @RequestParam("file") MultipartFile file
+    ) throws IOException {
+        String originalFilename = file.getOriginalFilename();
+        List<RelationshipImportRow> rows;
+        if (originalFilename != null && originalFilename.endsWith(".csv")) {
+            rows = parseCsvRelationships(file);
+        } else {
+            rows = objectMapper.readValue(
+                file.getInputStream(),
+                objectMapper.getTypeFactory().constructCollectionType(List.class, RelationshipImportRow.class)
+            );
+        }
+        return ResponseEntity.ok(competencyRelationshipService.bulkImportRelationships(rows));
+    }
+
+    private List<RelationshipImportRow> parseCsvRelationships(MultipartFile file) throws IOException {
+        List<RelationshipImportRow> rows = new ArrayList<>();
+        CSVFormat format = CSVFormat.DEFAULT.builder()
+            .setHeader()
+            .setSkipHeaderRecord(true)
+            .setTrim(true)
+            .setIgnoreHeaderCase(true)
+            .build();
+        try (var reader = new InputStreamReader(file.getInputStream(), StandardCharsets.UTF_8);
+             var parser = format.parse(reader)) {
+            for (CSVRecord record : parser) {
+                RelationshipImportRow row = new RelationshipImportRow();
+                row.setOriginId(getMappedValue(record, "originId"));
+                row.setOriginTitle(getMappedValue(record, "originTitle"));
+                row.setDestinationId(getMappedValue(record, "destinationId"));
+                row.setDestinationTitle(getMappedValue(record, "destinationTitle"));
+                row.setRelationshipType(getMappedValue(record, "relationshipType"));
+                rows.add(row);
+            }
+        }
+        return rows;
+    }
+
+    private String getMappedValue(CSVRecord record, String header) {
+        if (!record.isMapped(header)) {
+            return null;
+        }
+        String val = record.get(header);
+        if (val.isEmpty()) {
+            return null;
+        } else {
+            return val;
+        }
+    }
+
     private List<CompetencyImportRow> parseCsv(MultipartFile file) throws IOException {
         List<CompetencyImportRow> rows = new ArrayList<>();
         CSVFormat format = CSVFormat.DEFAULT.builder()
@@ -68,18 +132,18 @@ private List<CompetencyImportRow> parseCsv(MultipartFile file) throws IOExceptio
         try (var reader = new InputStreamReader(file.getInputStream(), StandardCharsets.UTF_8);
              var parser = format.parse(reader)) {
             for (CSVRecord record : parser) {
-            String title;
-            if (record.size() > 0) {
-                title = record.get(0);
-            } else {
-                title = "";
-            }
-            String description;
-            if (record.size() > 1) {
-                description = record.get(1);
-            } else {
-                description = null;
-            }
+                String title;
+                if (record.size() > 0) {
+                    title = record.get(0);
+                } else {
+                    title = "";
+                }
+                String description;
+                if (record.size() > 1) {
+                    description = record.get(1);
+                } else {
+                    description = null;
+                }
                 rows.add(new CompetencyImportRow(title, description));
             }
         }

server/src/main/java/de/tum/cit/memo/dto/RelationshipImportRow.java

@@ -0,0 +1,17 @@
+package de.tum.cit.memo.dto;
+
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+@Data
+@NoArgsConstructor
+public class RelationshipImportRow {
+
+    private String originId;
+    private String originTitle;
+    private String destinationId;
+    private String destinationTitle;
+
+    /** One of: ASSUMES / EXTENDS / MATCHES / UNRELATED */
+    private String relationshipType;
+}

server/src/main/java/de/tum/cit/memo/repository/CompetencyRepository.java

@@ -7,6 +7,7 @@
 import org.springframework.stereotype.Repository;
 
 import java.util.List;
+import java.util.Optional;
 
 @Repository
 public interface CompetencyRepository extends JpaRepository<Competency, String> {
@@ -29,4 +30,6 @@ public interface CompetencyRepository extends JpaRepository<Competency, String>
     void decrementDegree(@Param("ids") List<String> ids);
 
     boolean existsByTitle(String title);
+
+    Optional<Competency> findByTitle(String title);
 }

server/src/main/java/de/tum/cit/memo/security/DbRoleJwtAuthenticationConverter.java

@@ -4,6 +4,7 @@
 import de.tum.cit.memo.enums.UserRole;
 import de.tum.cit.memo.repository.UserRepository;
 import java.util.List;
+import java.util.Map;
 import java.util.Objects;
 import lombok.RequiredArgsConstructor;
 import org.springframework.core.convert.converter.Converter;
@@ -26,8 +27,19 @@ public AbstractAuthenticationToken convert(@NonNull Jwt jwt) {
         String subject = Objects.requireNonNullElse(jwt.getSubject(), "");
         UserRole role = userRepository.findById(subject)
             .map(User::getRole)
-            .orElse(UserRole.USER);
+            .orElseGet(() -> extractRoleFromJwt(jwt));
         return new JwtAuthenticationToken(jwt,
             List.of(new SimpleGrantedAuthority("ROLE_" + role.name())));
     }
+
+    private UserRole extractRoleFromJwt(Jwt jwt) {
+        Map<String, Object> realmAccess = jwt.getClaim("realm_access");
+        if (realmAccess != null) {
+            Object roles = realmAccess.get("roles");
+            if (roles instanceof List<?> roleList && roleList.contains("ADMIN")) {
+                return UserRole.ADMIN;
+            }
+        }
+        return UserRole.USER;
+    }
 }