diff --git a/src/main/java/hbp/mip/controllers/AlgorithmsAPI.java b/src/main/java/hbp/mip/controllers/AlgorithmsAPI.java index 18dffdc2ce01bc3b3e2c0a546408eae8413b232d..d67acb12037e3dbc18369c67132075de80531bb2 100644 --- a/src/main/java/hbp/mip/controllers/AlgorithmsAPI.java +++ b/src/main/java/hbp/mip/controllers/AlgorithmsAPI.java @@ -19,6 +19,7 @@ import static org.springframework.http.MediaType.APPLICATION_JSON_VALUE; public class AlgorithmsAPI { private final AlgorithmService algorithmService; + private final ActiveUserService activeUserService; public AlgorithmsAPI(ActiveUserService activeUserService, AlgorithmService algorithmService) { diff --git a/src/main/java/hbp/mip/controllers/PathologiesAPI.java b/src/main/java/hbp/mip/controllers/PathologiesAPI.java index da9f6d50961b6957337f534e2673a689074707b5..e6b76eabc0ce3eda1b07bf963a3685fe8978aebb 100644 --- a/src/main/java/hbp/mip/controllers/PathologiesAPI.java +++ b/src/main/java/hbp/mip/controllers/PathologiesAPI.java @@ -1,125 +1,41 @@ package hbp.mip.controllers; -import com.google.gson.Gson; -import com.google.gson.reflect.TypeToken; -import hbp.mip.models.DTOs.Exareme2AttributesDTO; -import hbp.mip.models.DTOs.Exareme2CommonDataElement; import hbp.mip.models.DTOs.PathologyDTO; import hbp.mip.services.ActiveUserService; -import hbp.mip.utils.ClaimUtils; -import hbp.mip.utils.Exceptions.InternalServerError; -import hbp.mip.utils.HTTPUtil; +import hbp.mip.services.PathologyService; import hbp.mip.utils.Logger; -import org.springframework.beans.factory.annotation.Value; import org.springframework.http.ResponseEntity; import org.springframework.security.core.Authentication; import org.springframework.web.bind.annotation.GetMapping; import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RestController; -import java.util.ArrayList; -import java.util.HashMap; import java.util.List; -import java.util.Map; - -import static org.springframework.http.MediaType.APPLICATION_JSON_VALUE; +import java.util.stream.Collectors; @RestController -@RequestMapping(value = "/pathologies", produces = {APPLICATION_JSON_VALUE}) +@RequestMapping(value = "/pathologies") public class PathologiesAPI { - private static final Gson gson = new Gson(); + private final PathologyService pathologyService; + private final ActiveUserService activeUserService; - private final ClaimUtils claimUtils; - // Enable HBP collab authentication (1) or disable it (0). Default is 1 - @Value("#{'${authentication.enabled}'}") - private boolean authenticationIsEnabled; - @Value("#{'${services.exareme2.attributesUrl}'}") - private String exareme2AttributesUrl; - @Value("#{'${services.exareme2.cdesMetadataUrl}'}") - private String exareme2CDEsMetadataUrl; - public PathologiesAPI(ActiveUserService activeUserService, ClaimUtils claimUtils) { + public PathologiesAPI(ActiveUserService activeUserService, PathologyService pathologyService) { this.activeUserService = activeUserService; - this.claimUtils = claimUtils; + this.pathologyService = pathologyService; } @GetMapping - public ResponseEntity<String> getPathologies(Authentication authentication) { + public ResponseEntity<List<PathologyDTO>> getPathologies(Authentication authentication) { Logger logger = new Logger(activeUserService.getActiveUser(authentication).username(), "(GET) /pathologies"); - logger.LogUserAction("Loading pathologies ..."); - - Map<String, List<PathologyDTO.EnumerationDTO>> datasetsPerPathology = getExareme2DatasetsPerPathology(logger); - - Map<String, Exareme2AttributesDTO> exareme2PathologyAttributes = getExareme2PathologyAttributes(logger); + List<PathologyDTO> pathologies = pathologyService.getPathologies(authentication, logger); - List<PathologyDTO> pathologyDTOS = new ArrayList<>(); - for (String pathology : exareme2PathologyAttributes.keySet()) { - PathologyDTO newPathology; - try { - newPathology = new PathologyDTO(pathology, exareme2PathologyAttributes.get(pathology), datasetsPerPathology.get(pathology)); - } catch (InternalServerError e) { - logger.LogUserAction(e.getMessage()); - continue; - } + String userPathologiesSTR = pathologies.stream().map(PathologyDTO::code) + .collect(Collectors.joining(", ")); + logger.LogUserAction("Access given to " + pathologies.size() + " pathologies: [" + userPathologiesSTR + "]."); - pathologyDTOS.add(newPathology); - } - - // If authentication is disabled return everything - if (!authenticationIsEnabled) { - logger.LogUserAction("Successfully loaded " + pathologyDTOS.size() + " pathologies"); - return ResponseEntity.ok().body(gson.toJson(pathologyDTOS)); - } - - logger.LogUserAction("Successfully loaded all authorized pathologies"); - return ResponseEntity.ok().body(gson.toJson(claimUtils.getAuthorizedPathologies(logger, authentication, pathologyDTOS))); + return ResponseEntity.ok(pathologies); } - public Map<String, List<PathologyDTO.EnumerationDTO>> getExareme2DatasetsPerPathology(Logger logger) { - Map<String, Map<String, Exareme2CommonDataElement>> exareme2CDEsMetadata; - // Get Exareme2 algorithms - try { - StringBuilder response = new StringBuilder(); - HTTPUtil.sendGet(exareme2CDEsMetadataUrl, response); - exareme2CDEsMetadata = gson.fromJson( - response.toString(), - new TypeToken<HashMap<String, Map<String, Exareme2CommonDataElement>>>() { - }.getType() - ); - } catch (Exception e) { - logger.LogUserAction("An exception occurred: " + e.getMessage()); - return null; - } - - Map<String, List<PathologyDTO.EnumerationDTO>> datasetsPerPathology = new HashMap<>(); - - exareme2CDEsMetadata.forEach((pathology, cdePerDataset) -> { - List<PathologyDTO.EnumerationDTO> pathologyDatasetDTOS = new ArrayList<>(); - Map<String, String> datasetEnumerations = (Map<String, String>) cdePerDataset.get("dataset").getEnumerations(); - datasetEnumerations.forEach((code, label) -> pathologyDatasetDTOS.add(new PathologyDTO.EnumerationDTO(code, label))); - datasetsPerPathology.put(pathology, pathologyDatasetDTOS); - }); - - return datasetsPerPathology; - } - - public Map<String, Exareme2AttributesDTO> getExareme2PathologyAttributes(Logger logger) { - Map<String, Exareme2AttributesDTO> exareme2PathologyAttributes; - // Get Exareme2 algorithms - try { - StringBuilder response = new StringBuilder(); - HTTPUtil.sendGet(exareme2AttributesUrl, response); - exareme2PathologyAttributes = gson.fromJson( - response.toString(), - new TypeToken<HashMap<String, Exareme2AttributesDTO>>() { - }.getType() - ); - } catch (Exception e) { - logger.LogUserAction("An exception occurred: " + e.getMessage()); - return null; - } - - return exareme2PathologyAttributes; - } } diff --git a/src/main/java/hbp/mip/models/DTOs/Exareme2AttributesDTO.java b/src/main/java/hbp/mip/models/DTOs/Exareme2AttributesDTO.java deleted file mode 100644 index 3755dcdc23fbbc0b1509a46ed20b131b95da907f..0000000000000000000000000000000000000000 --- a/src/main/java/hbp/mip/models/DTOs/Exareme2AttributesDTO.java +++ /dev/null @@ -1,19 +0,0 @@ -package hbp.mip.models.DTOs; - -import com.google.gson.annotations.SerializedName; -import lombok.AllArgsConstructor; -import lombok.Data; - -import java.util.List; -import java.util.Map; - -@Data -@AllArgsConstructor -public class Exareme2AttributesDTO { - @SerializedName("properties") - private Map<String, List<MetadataHierarchyDTO>> properties; - - @SerializedName("tags") - private Object tags; - -} diff --git a/src/main/java/hbp/mip/models/DTOs/MetadataHierarchyDTO.java b/src/main/java/hbp/mip/models/DTOs/MetadataHierarchyDTO.java deleted file mode 100644 index 0c91008097e8d611fa2aa887cfc4b69c20a6f132..0000000000000000000000000000000000000000 --- a/src/main/java/hbp/mip/models/DTOs/MetadataHierarchyDTO.java +++ /dev/null @@ -1,94 +0,0 @@ -package hbp.mip.models.DTOs; - -import com.google.gson.annotations.SerializedName; -import lombok.AllArgsConstructor; -import lombok.Data; - -import java.util.List; - -@Data -@AllArgsConstructor -public class MetadataHierarchyDTO { - - @SerializedName("variables") - private List<CommonDataElement> variables; - - @SerializedName("code") - private String code; - - @SerializedName("groups") - private List<MetadataHierarchyDTO> groups; - - @SerializedName("label") - private String label; - @Data - @AllArgsConstructor - public static class CommonDataElement { - @SerializedName("is_categorical") - private Boolean is_categorical; - - @SerializedName("code") - private String code; - - @SerializedName("sql_type") - private String sql_type; - - @SerializedName("description") - private String description; - - @SerializedName("enumerations") - private List<PathologyDTO.EnumerationDTO> enumerations; - - @SerializedName("label") - private String label; - - @SerializedName("units") - private String units; - - @SerializedName("type") - private String type; - - @SerializedName("methodology") - private String methodology; - - @SerializedName("min") - private String min; - - @SerializedName("max") - private String max; - } - - - public boolean isDatasetCDEPresent(){ - if (this.variables != null) { - for (CommonDataElement variable : this.variables) { - if (variable.code.equals("dataset")){ - return true; - } - } - - } - if (this.groups != null) { - for (MetadataHierarchyDTO group: this.groups){ - if (group.isDatasetCDEPresent()){ - return true; - } - } - } - return false; - } - - public void updateDatasetCde(List<PathologyDTO.EnumerationDTO> pathologyDatasetDTOS){ - if (this.variables != null) { - List<MetadataHierarchyDTO.CommonDataElement> variables = this.variables; - variables.stream().filter(cde -> cde.getCode().equals("dataset")). - findAny().ifPresent(cde -> cde.setEnumerations(pathologyDatasetDTOS)); - } - - if (this.groups != null) { - for (MetadataHierarchyDTO group: this.groups){ - group.updateDatasetCde(pathologyDatasetDTOS); - } - } - } -} diff --git a/src/main/java/hbp/mip/models/DTOs/PathologyDTO.java b/src/main/java/hbp/mip/models/DTOs/PathologyDTO.java index 794a5ee7a25abb1105c5c342ce080e2d7aaa1657..a1364379bf8ee8e0bb86ba62d2fcbdd5f5a0574e 100644 --- a/src/main/java/hbp/mip/models/DTOs/PathologyDTO.java +++ b/src/main/java/hbp/mip/models/DTOs/PathologyDTO.java @@ -1,66 +1,17 @@ package hbp.mip.models.DTOs; -import com.google.gson.annotations.SerializedName; -import hbp.mip.utils.Exceptions.InternalServerError; -import lombok.AllArgsConstructor; -import lombok.Data; - -import java.util.Arrays; import java.util.List; -@Data -@AllArgsConstructor -public class PathologyDTO { - - @SerializedName("code") - private String code; - - @SerializedName("version") - private String version; - - - @SerializedName("label") - private String label; - - @SerializedName("metadataHierarchy") - private MetadataHierarchyDTO metadataHierarchyDTO; - - @SerializedName("datasets") - private List<EnumerationDTO> datasets; - - public PathologyDTO(){ - } - - - public PathologyDTO(String pathology, Exareme2AttributesDTO exareme2AttributesDTO, List<EnumerationDTO> pathologyDatasetDTOS) { - MetadataHierarchyDTO metadataHierarchyDTO = exareme2AttributesDTO.getProperties().get("cdes").get(0); - if (!metadataHierarchyDTO.isDatasetCDEPresent()) throw new InternalServerError("CommonDataElement Dataset was not present in the pathology:" + pathology); - metadataHierarchyDTO.updateDatasetCde(pathologyDatasetDTOS); - - List<String> pathology_info = Arrays.asList(pathology.split(":", 2)); - this.code = pathology_info.get(0); - this.version = pathology_info.get(1); - this.metadataHierarchyDTO = metadataHierarchyDTO; - this.label = metadataHierarchyDTO.getLabel(); - this.datasets = pathologyDatasetDTOS; - } - - @Data - @AllArgsConstructor - public static class EnumerationDTO { - @SerializedName("code") - private String code; - - @SerializedName("label") - private String label; - - public String toString() { - return code; - } - } - - public String toString() { - return code; +public record PathologyDTO( + String code, + String version, + String label, + Boolean longitudinal, + PathologyMetadataDTO metadataHierarchy, + List<EnumerationDTO> datasets +) { + public record EnumerationDTO(String code, String label) { } } + diff --git a/src/main/java/hbp/mip/models/DTOs/PathologyMetadataDTO.java b/src/main/java/hbp/mip/models/DTOs/PathologyMetadataDTO.java new file mode 100644 index 0000000000000000000000000000000000000000..eb795fb22aceed911635fcbd7ffc177187402de6 --- /dev/null +++ b/src/main/java/hbp/mip/models/DTOs/PathologyMetadataDTO.java @@ -0,0 +1,45 @@ +package hbp.mip.models.DTOs; + +import lombok.AllArgsConstructor; +import lombok.Data; +import lombok.NoArgsConstructor; + +import java.util.List; + +public record PathologyMetadataDTO( + String code, + String version, + String label, + Boolean longitudinal, + List<CommonDataElementDTO> variables, + List<PathologyMetadataGroupDTO> groups +) { + public record PathologyMetadataGroupDTO( + String code, + String label, + List<CommonDataElementDTO> variables, + List<PathologyMetadataGroupDTO> groups + ) { + } + + @Data + @NoArgsConstructor + @AllArgsConstructor + public static class CommonDataElementDTO { + private String code; + private String label; + private String description; + private String sql_type; + private String is_categorical; + private List<PathologyDTO.EnumerationDTO> enumerations; + private String min; + private String max; + private String type; + private String methodology; + private String units; + + public void setEnumerations(List<PathologyDTO.EnumerationDTO> enumerations) { + this.enumerations = enumerations; + } + } +} \ No newline at end of file diff --git a/src/main/java/hbp/mip/services/ActiveUserService.java b/src/main/java/hbp/mip/services/ActiveUserService.java index 3b650021f8223263dbd07437693b672986dba6e4..07d0841d58aeea0d52aaea317c107ae4c56ae166 100644 --- a/src/main/java/hbp/mip/services/ActiveUserService.java +++ b/src/main/java/hbp/mip/services/ActiveUserService.java @@ -9,18 +9,20 @@ import org.springframework.context.annotation.ScopedProxyMode; import org.springframework.security.core.Authentication; import org.springframework.security.oauth2.core.oidc.OidcUserInfo; import org.springframework.security.oauth2.core.oidc.user.DefaultOidcUser; -import org.springframework.stereotype.Component; +import org.springframework.stereotype.Service; import java.util.Objects; -@Component +@Service @Scope(value = "session", proxyMode = ScopedProxyMode.TARGET_CLASS) public class ActiveUserService { private final UserRepository userRepository; @Value("${authentication.enabled}") + private boolean authenticationIsEnabled; + private UserDTO activeUserDetails; public ActiveUserService(UserRepository userRepository) { diff --git a/src/main/java/hbp/mip/services/PathologyService.java b/src/main/java/hbp/mip/services/PathologyService.java new file mode 100644 index 0000000000000000000000000000000000000000..ea0ff309078730de985bb36b4821cd4d02e021bb --- /dev/null +++ b/src/main/java/hbp/mip/services/PathologyService.java @@ -0,0 +1,186 @@ +package hbp.mip.services; + +import com.google.gson.Gson; +import com.google.gson.reflect.TypeToken; +import hbp.mip.models.DTOs.Exareme2CommonDataElement; +import hbp.mip.models.DTOs.PathologyMetadataDTO; +import hbp.mip.models.DTOs.PathologyDTO; +import hbp.mip.utils.ClaimUtils; +import hbp.mip.utils.Exceptions.InternalServerError; +import hbp.mip.utils.HTTPUtil; +import hbp.mip.utils.Logger; +import org.springframework.beans.factory.annotation.Value; +import org.springframework.security.core.Authentication; +import org.springframework.stereotype.Service; + +import java.io.IOException; +import java.lang.reflect.Type; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +@Service +public class PathologyService { + + private static final Gson gson = new Gson(); + + private final ClaimUtils claimUtils; + + @Value("${authentication.enabled}") + private boolean authenticationIsEnabled; + + @Value("${services.exareme2.attributesUrl}") + private String exareme2AttributesUrl; + + @Value("${services.exareme2.cdesMetadataUrl}") + private String exareme2CDEsMetadataUrl; + + public PathologyService(ClaimUtils claimUtils) { + this.claimUtils = claimUtils; + } + + public List<PathologyDTO> getPathologies(Authentication authentication, Logger logger) { + List<PathologyDTO> allPathologyDTOs = getAggregatedPathologyDTOs(logger); + + if (!authenticationIsEnabled) { + return allPathologyDTOs; + } + return claimUtils.getAuthorizedPathologies(logger, authentication, allPathologyDTOs); + } + + /** + * This method will fetch all necessary information about pathologies from exareme and then aggregate them. + * The information that needs to be aggregated is the dataset CDE enumerations. + * Exareme returns the information about the dataset enumerations in a separate endpoint. + */ + private List<PathologyDTO> getAggregatedPathologyDTOs(Logger logger) { + Map<String, PathologyMetadataDTO> pathologiesMetadataHierarchy = getExaremePathologiesMetadataHierarchyDTO(logger); + Map<String, List<PathologyDTO.EnumerationDTO>> datasetsPerPathology = getExareme2DatasetsPerPathology(logger); + + List<PathologyDTO> allPathologyDTOs = new ArrayList<>(); + for (String pathology : datasetsPerPathology.keySet()) { + PathologyMetadataDTO pathologyMetadata = pathologiesMetadataHierarchy.get(pathology); + assert pathologyMetadata != null; + List<PathologyDTO.EnumerationDTO> pathologyDatasets = datasetsPerPathology.get(pathology); + + // Exareme collects the dataset CDE enumerations automatically from the nodes when there is an addition/deletion. + // Exareme provides that information in a separate endpoint from the rest of the pathologies' metadata. + // We need to manually update the dataset CDE enumerations in each pathology's metadata in order to + // return the latest information in the frontend, without the need for data aggregation. + if (!hasDatasetCDE(pathologyMetadata.variables(), pathologyMetadata.groups())) + throw new InternalServerError("CommonDataElement 'dataset' was not present in the pathology's metadata:" + pathologyMetadata); + updateDatasetCDEEnumerations(pathologyMetadata.variables(), pathologyMetadata.groups(), pathologyDatasets); + + allPathologyDTOs.add( + new PathologyDTO( + pathologyMetadata.code(), + pathologyMetadata.version(), + pathologyMetadata.label(), + pathologyMetadata.longitudinal(), + pathologyMetadata, + pathologyDatasets + ) + ); + } + return allPathologyDTOs; + } + + private Map<String, List<PathologyDTO.EnumerationDTO>> getExareme2DatasetsPerPathology(Logger logger) { + Map<String, Map<String, Exareme2CommonDataElement>> exareme2CDEsMetadata; + Type exaremeCDEsMetadataType = new TypeToken<HashMap<String, Map<String, Exareme2CommonDataElement>>>(){}.getType(); + try { + StringBuilder response = new StringBuilder(); + HTTPUtil.sendGet(exareme2CDEsMetadataUrl, response); + exareme2CDEsMetadata = gson.fromJson(response.toString(),exaremeCDEsMetadataType); + } catch (IOException e) { + logger.LogUserAction("There was a problem communicating with exareme: " + e.getMessage()); + return new HashMap<>(); // Return empty result + } + + // Get the datasets for each pathology + Map<String, List<PathologyDTO.EnumerationDTO>> datasetsPerPathology = new HashMap<>(); + exareme2CDEsMetadata.forEach((pathology, cdePerDataset) -> { + List<PathologyDTO.EnumerationDTO> pathologyDatasetDTOS = new ArrayList<>(); + Map<String, String> datasetEnumerations = (Map<String, String>) cdePerDataset.get("dataset").getEnumerations(); + datasetEnumerations.forEach((code, label) -> pathologyDatasetDTOS.add(new PathologyDTO.EnumerationDTO(code, label))); + datasetsPerPathology.put(pathology, pathologyDatasetDTOS); + }); + + return datasetsPerPathology; + } + + private Map<String, Map<String, Map<String, List<Object>>>> getExareme2PathologyAttributes(Logger logger) { + Map<String, Map<String, Map<String, List<Object>>>> exareme2PathologyAttributes; + Type pathologyAttributesType = new TypeToken<Map<String, Map<String, Map<String, List<PathologyMetadataDTO>>>>>(){}.getType(); + try { + StringBuilder response = new StringBuilder(); + HTTPUtil.sendGet(exareme2AttributesUrl, response); + exareme2PathologyAttributes = gson.fromJson(response.toString(),pathologyAttributesType); + } catch (IOException e) { + logger.LogUserAction("There was a problem communicating with exareme: " + e.getMessage()); + return new HashMap<>(); // Return empty result + } + + return exareme2PathologyAttributes; + } + + private Map<String, PathologyMetadataDTO> getExaremePathologiesMetadataHierarchyDTO(Logger logger) { + Map<String, Map<String, Map<String, List<Object>>>> pathologiesAttributes = getExareme2PathologyAttributes(logger); + + Map<String, PathologyMetadataDTO> pathologiesHierarchies = new HashMap<>(); + pathologiesAttributes.forEach((pathology, attributes) -> { + assert attributes.get("properties") != null; + assert attributes.get("properties").get("cdes") != null; + assert !attributes.get("properties").get("cdes").isEmpty(); + pathologiesHierarchies.put(pathology, (PathologyMetadataDTO) attributes.get("properties").get("cdes").get(0)); + }); + + return pathologiesHierarchies; + } + + + private static boolean hasDatasetCDE( + List<PathologyMetadataDTO.CommonDataElementDTO> variables, + List<PathologyMetadataDTO.PathologyMetadataGroupDTO> groups + ) { + if (variables != null) { + for (PathologyMetadataDTO.CommonDataElementDTO variable : variables) { + if (variable.getCode().equals("dataset")){ + return true; + } + } + + } + if (groups != null) { + for (PathologyMetadataDTO.PathologyMetadataGroupDTO group: groups){ + if (hasDatasetCDE(group.variables(), group.groups())){ + return true; + } + } + } + return false; + } + + private static void updateDatasetCDEEnumerations( + List<PathologyMetadataDTO.CommonDataElementDTO> variables, + List<PathologyMetadataDTO.PathologyMetadataGroupDTO> groups, + List<PathologyDTO.EnumerationDTO> datasetEnumerations + ){ + if (variables != null) { + variables.stream().filter(cde -> cde.getCode().equals("dataset")). + findAny().ifPresent(cde -> cde.setEnumerations(datasetEnumerations)); + } + + if (groups != null) { + for (PathologyMetadataDTO.PathologyMetadataGroupDTO group: groups){ + updateDatasetCDEEnumerations( + group.variables(), + group.groups(), + datasetEnumerations + ); + } + } + } + +} diff --git a/src/main/java/hbp/mip/utils/ClaimUtils.java b/src/main/java/hbp/mip/utils/ClaimUtils.java index 7b650f17fcef6085ddbdd816a3100a54aee3ef32..dfd2df437865748fc18afa445bde384d01cecb76 100644 --- a/src/main/java/hbp/mip/utils/ClaimUtils.java +++ b/src/main/java/hbp/mip/utils/ClaimUtils.java @@ -70,33 +70,31 @@ public class ClaimUtils { ArrayList<String> authorities = getAuthorityRoles(authentication); - List<PathologyDTO> userPathologies = new ArrayList<>(); if (hasRoleAccess(authorities, allDatasetsAllowedClaim, logger)) { - userPathologies = allPathologies; - - } else { - for (PathologyDTO curPathology : allPathologies) { - List<PathologyDTO.EnumerationDTO> userPathologyDatasets = new ArrayList<>(); - for (PathologyDTO.EnumerationDTO dataset : curPathology.getDatasets()) { - if (hasRoleAccess(authorities, getDatasetClaim(dataset.getCode()), logger)) { - userPathologyDatasets.add(dataset); - } - } + return allPathologies; + } - if (!userPathologyDatasets.isEmpty()) { - PathologyDTO userPathology = new PathologyDTO(); - userPathology.setCode(curPathology.getCode()); - userPathology.setLabel(curPathology.getLabel()); - userPathology.setMetadataHierarchyDTO(curPathology.getMetadataHierarchyDTO()); - userPathology.setDatasets(userPathologyDatasets); - userPathologies.add(userPathology); + List<PathologyDTO> userPathologies = new ArrayList<>(); + for (PathologyDTO curPathology : allPathologies) { + List<PathologyDTO.EnumerationDTO> userPathologyDatasets = new ArrayList<>(); + for (PathologyDTO.EnumerationDTO dataset : curPathology.datasets()) { + if (hasRoleAccess(authorities, getDatasetClaim(dataset.code()), logger)) { + userPathologyDatasets.add(dataset); } } - } - String userPathologiesSTR = userPathologies.stream().map(PathologyDTO::toString) - .collect(Collectors.joining(", ")); - logger.LogUserAction("Allowed pathologies: [" + userPathologiesSTR + "]"); + if (!userPathologyDatasets.isEmpty()) { + PathologyDTO userPathology = new PathologyDTO( + curPathology.code(), + curPathology.version(), + curPathology.label(), + curPathology.longitudinal(), + curPathology.metadataHierarchy(), + userPathologyDatasets + ); + userPathologies.add(userPathology); + } + } return userPathologies; } } diff --git a/src/main/java/hbp/mip/utils/Logger.java b/src/main/java/hbp/mip/utils/Logger.java index faeed30eca1d6a54fa536e399a93891ee34a611c..553b5a0c5da57361b31050f50e3219a660136e0f 100644 --- a/src/main/java/hbp/mip/utils/Logger.java +++ b/src/main/java/hbp/mip/utils/Logger.java @@ -15,8 +15,8 @@ public class Logger { } public void LogUserAction(String actionInfo) { - LOGGER.info(" User -> " + username + " ," - + "Endpoint -> " + endpoint + " ," + LOGGER.info(" User -> " + username + " , " + + "Endpoint -> " + endpoint + " , " + "Info -> " + actionInfo); } }