Mapping-step-defs + Fix-warnings

README.md

@@ -2,7 +2,7 @@
 
 Template for a Spring Boot project including Spring REST, HATEOAS, JPA, etc. Additional details: [HELP.md](HELP.md)
 
-[![Open Issues](https://img.shields.io/github/issues-raw/UdL-EPS-SoftArch/spring-template?logo=github)](https://github.com/orgs/UdL-EPS-SoftArch/projects/12)
+[![Open Issues](https://img.shields.io/github/issues-raw/Tab2KGWiz/tab2kgwiz-client?logo=github)](https://github.com/orgs/Tab2KGWiz/projects/2)
 [![CI/CD](https://github.com/UdL-EPS-SoftArch/spring-template/actions/workflows/ci-cd.yml/badge.svg)](https://github.com/UdL-EPS-SoftArch/spring-template/actions)
 [![CucumberReports: UdL-EPS-SoftArch](https://messages.cucumber.io/api/report-collections/faed8ca5-e474-4a1a-a72a-b8e2a2cd69f0/badge)](https://reports.cucumber.io/report-collections/faed8ca5-e474-4a1a-a72a-b8e2a2cd69f0)
 [![Deployment status](https://img.shields.io/uptimerobot/status/m792691238-18db2a43adf8d8ded474f885)](https://spring-template.fly.dev/users)

pom.xml

@@ -59,6 +59,12 @@
         <dependency>
 			<groupId>com.fasterxml.jackson.datatype</groupId>
 			<artifactId>jackson-datatype-jsr310</artifactId>
+			<version>2.13.0</version>
+		</dependency>
+		<dependency>
+			<groupId>com.fasterxml.jackson.dataformat</groupId>
+			<artifactId>jackson-dataformat-yaml</artifactId>
+			<version>2.13.0</version>
 		</dependency>
 		<dependency>
 			<groupId>org.apache.tomcat</groupId>

src/main/java/cat/udl/eps/softarch/demo/config/AuthenticationConfig.java

@@ -1,6 +1,8 @@
 package cat.udl.eps.softarch.demo.config;
 
 import cat.udl.eps.softarch.demo.domain.User;
+import cat.udl.eps.softarch.demo.repository.SupplierRepository;
+import cat.udl.eps.softarch.demo.domain.Supplier;
 import cat.udl.eps.softarch.demo.repository.UserRepository;
 import org.springframework.beans.factory.annotation.Value;
 import org.springframework.context.annotation.Configuration;
@@ -16,15 +18,39 @@ public class AuthenticationConfig extends GlobalAuthenticationConfigurerAdapter
   final BasicUserDetailsService basicUserDetailsService;
   final UserRepository userRepository;
 
-  public AuthenticationConfig(BasicUserDetailsService basicUserDetailsService, UserRepository userRepository) {
+  final SupplierRepository supplierRepository;
+
+  public AuthenticationConfig(BasicUserDetailsService basicUserDetailsService, UserRepository userRepository,
+                              SupplierRepository supplierRepository) {
     this.basicUserDetailsService = basicUserDetailsService;
     this.userRepository = userRepository;
+    this.supplierRepository = supplierRepository;
   }
 
   @Override
   public void init(AuthenticationManagerBuilder auth) throws Exception {
     auth
         .userDetailsService(basicUserDetailsService)
         .passwordEncoder(User.passwordEncoder);
+
+
+    //Sample User
+    if (!userRepository.existsById("demo")) {
+      User user = new User();
+      user.setEmail("[email protected]");
+      user.setUsername("demo");
+      user.setPassword(defaultPassword);
+      user.encodePassword();
+      userRepository.save(user);
+    }
+
+    if (!supplierRepository.existsById("demoSupplier")) {
+      Supplier supplier = new Supplier();
+      supplier.setUsername("demoSupplier");
+      supplier.setEmail("[email protected]");
+      supplier.setPassword(defaultPassword);
+      supplier.encodePassword();
+      supplierRepository.save(supplier);
+    }
   }
 }

src/main/java/cat/udl/eps/softarch/demo/config/BasicUserDetailsService.java

@@ -1,7 +1,6 @@
 package cat.udl.eps.softarch.demo.config;
 
 import cat.udl.eps.softarch.demo.repository.UserRepository;
-import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.security.core.userdetails.UserDetails;
 import org.springframework.security.core.userdetails.UserDetailsService;
 import org.springframework.security.core.userdetails.UsernameNotFoundException;

src/main/java/cat/udl/eps/softarch/demo/config/DBInitialization.java

@@ -24,7 +24,7 @@ public void initializeDatabase() {
         if (!userRepository.existsById("demo")) {
             User user = new User();
             user.setEmail("[email protected]");
-            user.setId("demo");
+            user.setUsername("demo");
             user.setPassword(defaultPassword);
             user.encodePassword();
             userRepository.save(user);
@@ -34,7 +34,7 @@ public void initializeDatabase() {
             if (!userRepository.existsById("test")) {
                 User user = new User();
                 user.setEmail("[email protected]");
-                user.setId("test");
+                user.setUsername("test");
                 user.setPassword(defaultPassword);
                 user.encodePassword();
                 userRepository.save(user);

src/main/java/cat/udl/eps/softarch/demo/config/WebSecurityConfig.java

@@ -30,6 +30,12 @@ protected SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exce
                 .requestMatchers(HttpMethod.GET, "/identity").authenticated()
                 .requestMatchers(HttpMethod.POST, "/users").anonymous()
                 .requestMatchers(HttpMethod.POST, "/users/*").denyAll()
+                .requestMatchers(HttpMethod.DELETE, "/suppliers/*").hasRole("SUPPLIER")
+                .requestMatchers(HttpMethod.PATCH, "/suppliers/*").hasRole("SUPPLIER")
+                .requestMatchers(HttpMethod.POST, "/suppliers").anonymous()
+                .requestMatchers(HttpMethod.POST, "/mappings").hasRole("SUPPLIER")
+                .requestMatchers(HttpMethod.DELETE, "/mappings/*").hasRole("SUPPLIER")
+                .requestMatchers(HttpMethod.PATCH, "/mappings/*").hasRole("SUPPLIER")
                 .requestMatchers(HttpMethod.POST, "/**/*").authenticated()
                 .requestMatchers(HttpMethod.PUT, "/**/*").authenticated()
                 .requestMatchers(HttpMethod.PATCH, "/**/*").authenticated()
@@ -38,7 +44,7 @@ protected SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exce
             .csrf((csrf) -> csrf.disable())
             .sessionManagement((session) -> session.sessionCreationPolicy(SessionCreationPolicy.STATELESS))
             .cors((cors) -> cors.configurationSource(corsConfigurationSource()))
-            .httpBasic((httpBasic) -> httpBasic.realmName("demo"));
+            .httpBasic((httpBasic) -> httpBasic.realmName("tab2kgwiz"));
         return http.build();
     }
 

src/main/java/cat/udl/eps/softarch/demo/controller/ColumnController.java

@@ -0,0 +1,90 @@
+package cat.udl.eps.softarch.demo.controller;
+
+import cat.udl.eps.softarch.demo.domain.Column;
+import cat.udl.eps.softarch.demo.domain.Mapping;
+import cat.udl.eps.softarch.demo.domain.Supplier;
+import cat.udl.eps.softarch.demo.domain.User;
+import cat.udl.eps.softarch.demo.exception.NotAuthorizedException;
+import cat.udl.eps.softarch.demo.exception.NotFoundException;
+import cat.udl.eps.softarch.demo.repository.ColumnRepository;
+import cat.udl.eps.softarch.demo.repository.MappingRepository;
+import cat.udl.eps.softarch.demo.repository.SupplierRepository;
+import org.springframework.data.rest.webmvc.PersistentEntityResource;
+import org.springframework.data.rest.webmvc.PersistentEntityResourceAssembler;
+import org.springframework.data.rest.webmvc.RepositoryRestController;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.security.authentication.AnonymousAuthenticationToken;
+import org.springframework.security.core.Authentication;
+import org.springframework.security.core.context.SecurityContextHolder;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestMethod;
+import org.springframework.web.bind.annotation.ResponseBody;
+
+import java.util.Objects;
+import java.util.Optional;
+
+@RepositoryRestController
+public class ColumnController {
+    private final ColumnRepository columnRepository;
+    private final MappingRepository mappingRepository;
+    private final SupplierRepository supplierRepository;
+
+    public ColumnController(ColumnRepository columnRepository, MappingRepository mappingRepository, SupplierRepository supplierRepository) {
+        this.columnRepository = columnRepository;
+        this.mappingRepository = mappingRepository;
+        this.supplierRepository = supplierRepository;
+    }
+
+    @RequestMapping(value = "/columns/{id}", method = RequestMethod.GET)
+    public @ResponseBody PersistentEntityResource getColumn(PersistentEntityResourceAssembler resourceAssembler,
+                                                             @PathVariable Long id) {
+
+        Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
+        if (authentication instanceof AnonymousAuthenticationToken) {
+            throw new NotAuthorizedException();
+        }
+
+        User user = (User) SecurityContextHolder.getContext().getAuthentication().getPrincipal();
+        Optional<Column> column = columnRepository.findById(id);
+
+        if (column.isEmpty()) {
+            throw new NotFoundException();
+        }
+
+        Column col = column.get();
+        assert col.getColumnBelongsTo().getId() != null;
+        Optional<Mapping> mappingBelongs = mappingRepository.findById(col.getColumnBelongsTo().getId());
+
+        if (mappingBelongs.isPresent() && Objects.equals(mappingBelongs.get().getProvidedBy().getId(), user.getId())) {
+            return resourceAssembler.toFullResource(col);
+        } else {
+            throw new NotAuthorizedException();
+        }
+    }
+
+    @RequestMapping(value = "/columns/{id}", method = RequestMethod.DELETE)
+    public ResponseEntity<String> deleteColumns(@PathVariable Long id) {
+        Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
+        String currentSupplierUsername = authentication.getName();
+        Supplier currentSupplier = supplierRepository.findByUsernameContaining(currentSupplierUsername).get(0);
+
+        Optional<Column> column = columnRepository.findById(id);
+
+        if (column.isEmpty()) {
+            return ResponseEntity.status(HttpStatus.NOT_FOUND).body("Column not found.");
+        }
+
+        Column col = column.get();
+        assert col.getColumnBelongsTo().getId() != null;
+        Optional<Mapping> mappingBelongs = mappingRepository.findById(col.getColumnBelongsTo().getId());
+
+        if (mappingBelongs.isPresent() && Objects.equals(mappingBelongs.get().getProvidedBy().getId(), currentSupplier.getId())) {
+            columnRepository.delete(col);
+            return ResponseEntity.ok("Column deleted successfully.");
+        } else {
+            throw new NotAuthorizedException();
+        }
+    }
+}

src/main/java/cat/udl/eps/softarch/demo/controller/MappingController.java

@@ -0,0 +1,100 @@
+package cat.udl.eps.softarch.demo.controller;
+import cat.udl.eps.softarch.demo.domain.Mapping;
+import cat.udl.eps.softarch.demo.domain.Supplier;
+import cat.udl.eps.softarch.demo.domain.User;
+import cat.udl.eps.softarch.demo.exception.NotAuthorizedException;
+import cat.udl.eps.softarch.demo.exception.NotFoundException;
+import cat.udl.eps.softarch.demo.repository.MappingRepository;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.security.authentication.AnonymousAuthenticationToken;
+import org.springframework.security.core.Authentication;
+import org.springframework.data.rest.webmvc.PersistentEntityResource;
+import org.springframework.data.rest.webmvc.PersistentEntityResourceAssembler;
+import org.springframework.data.rest.webmvc.RepositoryRestController;
+import org.springframework.security.core.context.SecurityContextHolder;
+import org.springframework.validation.BeanPropertyBindingResult;
+import org.springframework.web.bind.MethodArgumentNotValidException;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.Optional;
+
+@RepositoryRestController
+public class MappingController {
+    private final MappingRepository mappingRepository;
+
+    public MappingController(MappingRepository mappingRepository) {
+        this.mappingRepository = mappingRepository;
+    }
+
+    @RequestMapping(value = "/mappings/{id}", method = RequestMethod.GET)
+    public @ResponseBody PersistentEntityResource getMapping(PersistentEntityResourceAssembler resourceAssembler,
+                                                             @PathVariable Long id) {
+
+        Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
+        if (authentication instanceof AnonymousAuthenticationToken) {
+            throw new NotAuthorizedException();
+        }
+
+        User user = (User) SecurityContextHolder.getContext().getAuthentication().getPrincipal();
+        Optional<Mapping> mapping = mappingRepository.findById(id);
+
+        if (mapping.isEmpty()) {
+            throw new NotFoundException();
+        }
+
+        Mapping m = mapping.get();
+
+        if(m.getProvidedBy().getId() == null) {
+            throw new NotFoundException();
+        }
+
+        if (m.getProvidedBy().getId().equals(user.getId())) {
+            return resourceAssembler.toFullResource(m);
+        } else {
+            throw new NotAuthorizedException();
+        }
+    }
+
+    @RequestMapping(value = "/mappings", method = RequestMethod.POST)
+    @ResponseStatus(HttpStatus.CREATED)
+    public @ResponseBody PersistentEntityResource createMapping(PersistentEntityResourceAssembler resourceAssembler,
+                                                                @RequestBody Mapping mapping) throws MethodArgumentNotValidException {
+
+        Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
+        if (authentication instanceof AnonymousAuthenticationToken) {
+            throw new NotAuthorizedException();
+        }
+
+        Supplier supplier = (Supplier) SecurityContextHolder.getContext().getAuthentication().getPrincipal();
+
+        mapping.setProvidedBy(supplier);
+
+        try {
+            mapping = mappingRepository.save(mapping);
+        } catch (Exception e) {
+            throw new MethodArgumentNotValidException(null, new BeanPropertyBindingResult(mapping, "mapping"));
+        }
+
+        return resourceAssembler.toFullResource(mapping);
+    }
+
+    @RequestMapping(value = "/mappings/{id}", method = RequestMethod.DELETE)
+    public ResponseEntity<String> deleteMapping(@PathVariable Long id) {
+        Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
+        String currentSupplierUsername = authentication.getName();
+
+        Optional<Mapping> mapping = mappingRepository.findById(id);
+
+        if (mapping.isEmpty()) {
+            return ResponseEntity.status(HttpStatus.NOT_FOUND).body("Mapping not found.");
+        }
+
+        if (!mapping.get().getProvidedBy().getUsername().equals(currentSupplierUsername)) {
+            return ResponseEntity.status(HttpStatus.FORBIDDEN).body("You are not allowed to delete this mapping.");
+        }
+
+        mappingRepository.delete(mapping.get());
+        return ResponseEntity.ok("Mapping deleted successfully.");
+    }
+}

src/main/java/cat/udl/eps/softarch/demo/domain/Column.java

@@ -0,0 +1,41 @@
+package cat.udl.eps.softarch.demo.domain;
+
+import com.fasterxml.jackson.annotation.JsonIdentityReference;
+import jakarta.persistence.*;
+import jakarta.validation.constraints.NotBlank;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import org.hibernate.validator.constraints.Length;
+
+@Entity
+@Data
+@EqualsAndHashCode(callSuper = true)
+public class Column extends UriEntity<Long> {
+    @Id
+    @GeneratedValue(strategy = GenerationType.AUTO)
+    private Long id;
+
+    @NotBlank(message = "Title is mandatory")
+    @Length(min = 1, max = 80)
+    private String title;
+
+    @NotBlank
+    private String dataType;
+
+    private String ontologyURI;
+
+    private String ontologyType;
+
+
+    @ManyToOne
+    @JsonIdentityReference(alwaysAsId = true)
+    private Mapping columnBelongsTo;
+
+//    private String measurement;
+
+    @Override
+    public Long getId() {
+        return id;
+    }
+
+}

src/main/java/cat/udl/eps/softarch/demo/domain/CustomColumn.java

@@ -0,0 +1,16 @@
+package cat.udl.eps.softarch.demo.domain;
+
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.data.rest.core.config.Projection;
+
+@Projection(
+    name = "customColumn",
+    types = { Column.class }
+)
+
+public interface CustomColumn {
+    Long getId();
+    String getTitle();
+    @Value("#{target.columnBelongsTo.title}")
+    String getProvideBy();
+}

src/main/java/cat/udl/eps/softarch/demo/domain/CustomMapping.java

@@ -0,0 +1,16 @@
+package cat.udl.eps.softarch.demo.domain;
+
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.data.rest.core.config.Projection;
+
+@Projection(
+    name = "customMapping",
+    types = { Mapping.class }
+)
+
+public interface CustomMapping {
+    Long getId();
+    String getTitle();
+    @Value("#{target.providedBy.username}")
+    String getProvideBy();
+}