private void fixQueryObject(Study study, Query query, String sessionId) throws CatalogException { // The individuals introduced could be either ids or names. As so, we should use the smart resolutor to do this. if (StringUtils.isNotEmpty(query.getString(SampleDBAdaptor.QueryParams.INDIVIDUAL.key()))) { MyResources<Individual> resource = catalogManager.getIndividualManager().getUids( query.getAsStringList(SampleDBAdaptor.QueryParams.INDIVIDUAL.key()), study.getFqn(), sessionId); query.put(SampleDBAdaptor.QueryParams.INDIVIDUAL_UID.key(), resource.getResourceList().stream().map(Individual::getUid) .collect(Collectors.toList())); query.remove(SampleDBAdaptor.QueryParams.INDIVIDUAL.key()); } }
@Test public void readIndividualStudyManager() throws CatalogException { catalogManager.getIndividualManager().get(null, ind2, null, studyAdmin1SessionId); }
@Test public void readIndividualByReadingSomeSample() throws CatalogException { catalogManager.getIndividualManager().get(null, ind1, null, memberSessionId); }
public Map<String, Object> facet(String studyStr, String fileFields, String sampleFields, String individualFields, String cohortFields, String familyFields, boolean defaultStats, String sessionId) throws CatalogException, IOException { Map<String, Object> result = new HashMap<>(); result.put("sample", catalogManager.getSampleManager().facet(studyStr, new Query(), setFacetFields(sampleFields), defaultStats, sessionId)); result.put("file", catalogManager.getFileManager().facet(studyStr, new Query(), setFacetFields(fileFields), defaultStats, sessionId)); result.put("individual", catalogManager.getIndividualManager().facet(studyStr, new Query(), setFacetFields(individualFields), defaultStats, sessionId)); result.put("family", catalogManager.getFamilyManager().facet(studyStr, new Query(), setFacetFields(familyFields), defaultStats, sessionId)); result.put("cohort", catalogManager.getCohortManager().facet(studyStr, new Query(), setFacetFields(cohortFields), defaultStats, sessionId)); return result; }
private void fillIndividuals(String studyId, List<org.opencb.biodata.models.metadata.Individual> individuals) throws CatalogException { Map<String, org.opencb.biodata.models.metadata.Individual> individualMap = individuals .stream() .collect(Collectors.toMap(org.opencb.biodata.models.metadata.Individual::getId, i -> i)); Query query = new Query(IndividualDBAdaptor.QueryParams.ID.key(), new ArrayList<>(individualMap.keySet())); List<Individual> catalogIndividuals = catalogManager.getIndividualManager().get(studyId, query, INDIVIDUAL_QUERY_OPTIONS, sessionId) .getResult(); for (Individual catalogIndividual : catalogIndividuals) { org.opencb.biodata.models.metadata.Individual individual = individualMap.get(catalogIndividual.getName()); individual.setSex(catalogIndividual.getSex().name()); // individual.setFamily(catalogIndividual.getFamily()); individual.setPhenotype(catalogIndividual.getAffectationStatus().toString()); if (catalogIndividual.getMother() != null) { individual.setMother(catalogIndividual.getMother().getId()); } if (catalogIndividual.getFather() != null) { individual.setFather(catalogIndividual.getFather().getId()); } } }
@Test public void readIndividualForbidden() throws CatalogException { thrown.expect(CatalogAuthorizationException.class); catalogManager.getIndividualManager().get(null, ind2, null, externalSessionId); }
@Test public void readAllIndividuals() throws CatalogException { assertEquals(2, catalogManager.getIndividualManager().get(studyFqn, new Query(), null, ownerSessionId).getNumResults()); assertEquals(2, catalogManager.getIndividualManager().get(studyFqn, new Query(), null, studyAdmin1SessionId).getNumResults()); assertEquals(0, catalogManager.getIndividualManager().get(studyFqn, new Query(), null, externalSessionId).getNumResults()); }
private void createMissingIndividual(Individual individual, Map<String, Individual> individualMap, Study study, String sessionId) throws CatalogException { if (individual == null || individual.getUid() > 0) { return; } if (individual.getFather() != null && StringUtils.isNotEmpty(individual.getFather().getId())) { createMissingIndividual(individual.getFather(), individualMap, study, sessionId); individual.setFather(individualMap.get(individual.getFather().getId())); } if (individual.getMother() != null && StringUtils.isNotEmpty(individual.getMother().getId())) { createMissingIndividual(individual.getMother(), individualMap, study, sessionId); individual.setMother(individualMap.get(individual.getMother().getId())); } QueryResult<Individual> individualQueryResult = catalogManager.getIndividualManager().create(study.getFqn(), individual, QueryOptions.empty(), sessionId); if (individualQueryResult.getNumResults() == 0) { throw new CatalogException("Unexpected error when trying to create individual " + individual.getId()); } individualMap.put(individual.getId(), individualQueryResult.first()); }
@Test public void testAssignPermissionsWithPropagationWithIndividualAndNoIndividual() throws CatalogException { Sample sample = new Sample().setId("sample").setIndividual(new Individual().setId("individual")); catalogManager.getSampleManager().create(studyFqn, sample, QueryOptions.empty(), sessionIdUser); Sample sample2 = new Sample().setId("sample2"); catalogManager.getSampleManager().create(studyFqn, sample2, QueryOptions.empty(), sessionIdUser); List<QueryResult<SampleAclEntry>> queryResults = catalogManager.getSampleManager().updateAcl(studyFqn, Arrays.asList("sample", "sample2"), "user2", new Sample.SampleAclParams("VIEW", AclParams.Action.SET, null, null, null, true), sessionIdUser); assertEquals(2, queryResults.size()); assertEquals(1, queryResults.get(0).getNumResults()); assertEquals(1, queryResults.get(0).first().getPermissions().size()); assertTrue(queryResults.get(0).first().getPermissions().contains(SampleAclEntry.SamplePermissions.VIEW)); assertTrue(queryResults.get(1).first().getPermissions().contains(SampleAclEntry.SamplePermissions.VIEW)); List<QueryResult<IndividualAclEntry>> individualAcl = catalogManager.getIndividualManager().getAcls(studyFqn, Collections.singletonList("individual"), "user2", false, sessionIdUser); assertEquals(1, individualAcl.size()); assertEquals(1, individualAcl.get(0).getNumResults()); assertEquals(1, individualAcl.get(0).first().getPermissions().size()); assertTrue(individualAcl.get(0).first().getPermissions().contains(IndividualAclEntry.IndividualPermissions.VIEW)); }
@Override public QueryResult groupBy(@Nullable String studyStr, Query query, List<String> fields, QueryOptions options, String sessionId) throws CatalogException { query = ParamUtils.defaultObject(query, Query::new); options = ParamUtils.defaultObject(options, QueryOptions::new); if (fields == null || fields.size() == 0) { throw new CatalogException("Empty fields parameter."); } String userId = userManager.getUserId(sessionId); Study study = catalogManager.getStudyManager().resolveId(studyStr, userId); // Fix query if it contains any annotation AnnotationUtils.fixQueryAnnotationSearch(study, userId, query, authorizationManager); AnnotationUtils.fixQueryOptionAnnotation(options); // Add study id to the query query.put(SampleDBAdaptor.QueryParams.STUDY_UID.key(), study.getUid()); if (StringUtils.isNotEmpty(query.getString(SampleDBAdaptor.QueryParams.INDIVIDUAL.key()))) { String individualStr = query.getString(SampleDBAdaptor.QueryParams.INDIVIDUAL.key()); if (NumberUtils.isCreatable(individualStr) && Long.parseLong(individualStr) <= 0) { query.put(SampleDBAdaptor.QueryParams.INDIVIDUAL_UID.key(), -1); } else { MyResource resource = catalogManager.getIndividualManager().getUid(individualStr, studyStr, sessionId); query.put(SampleDBAdaptor.QueryParams.INDIVIDUAL_UID.key(), resource.getResource().getUid()); } query.remove(SampleDBAdaptor.QueryParams.INDIVIDUAL.key()); } QueryResult queryResult = sampleDBAdaptor.groupBy(query, fields, options, userId); return ParamUtils.defaultObject(queryResult, QueryResult::new); }
@Test public void testAnnotateIndividualUnique() throws CatalogException { String individualId = catalogManager.getIndividualManager().create(studyFqn, new Individual().setId("INDIVIDUAL_1"), new QueryOptions(), sessionIdUser).first().getId(); catalogManager.getIndividualManager().update(studyFqn, individualId, new ObjectMap() .append(IndividualDBAdaptor.QueryParams.ANNOTATION_SETS.key(), Collections.singletonList(new ObjectMap() .append(AnnotationSetManager.ID, "annotation1") ), QueryOptions.empty(), sessionIdUser); QueryResult<Individual> individualQueryResult = catalogManager.getIndividualManager().get(studyFqn, individualId, new QueryOptions(QueryOptions.INCLUDE, SampleDBAdaptor.QueryParams.ANNOTATION_SETS.key()), sessionIdUser); assertEquals(1, individualQueryResult.first().getAnnotationSets().size()); thrown.expect(CatalogException.class); thrown.expectMessage("unique"); catalogManager.getIndividualManager().update(studyFqn, individualId, new ObjectMap() .append(IndividualDBAdaptor.QueryParams.ANNOTATION_SETS.key(), Collections.singletonList(new ObjectMap() .append(AnnotationSetManager.ID, "annotation2")
@Test public void testCreateSampleWithIndividual() throws CatalogException { String individualId = catalogManager.getIndividualManager().create(studyFqn, new Individual().setId("Individual1"), new QueryOptions(), sessionIdUser).first().getId(); String sampleId1 = catalogManager.getSampleManager().create(studyFqn, new Sample() .setId("SAMPLE_1") .setIndividual(new Individual().setId(individualId)), new QueryOptions(), sessionIdUser).first().getId(); QueryResult<Individual> individualQueryResult = catalogManager.getIndividualManager().get(studyFqn, individualId, QueryOptions.empty(), sessionIdUser); assertEquals(sampleId1, individualQueryResult.first().getSamples().get(0).getId()); // Create sample linking to individual based on the individual name String sampleId2 = catalogManager.getSampleManager().create(studyFqn, new Sample() .setId("SAMPLE_2") .setIndividual(new Individual().setId("Individual1")), new QueryOptions(), sessionIdUser).first().getId(); individualQueryResult = catalogManager.getIndividualManager().get(studyFqn, individualId, QueryOptions.empty(), sessionIdUser); assertEquals(2, individualQueryResult.first().getSamples().size()); assertTrue(individualQueryResult.first().getSamples().stream().map(Sample::getId).collect(Collectors.toSet()).containsAll( Arrays.asList(sampleId1, sampleId2) )); }
@Test public void createClinicalAnalysisNoFamilyTest() throws CatalogException { QueryResult<ClinicalAnalysis> dummyEnvironment = createDummyEnvironment(false); assertEquals(1, dummyEnvironment.getNumResults()); assertEquals(0, dummyEnvironment.first().getInterpretations().size()); assertEquals(catalogManager.getIndividualManager().getUid("child1", STUDY, sessionIdUser).getResource().getUid(), dummyEnvironment.first().getProband().getUid()); assertEquals(1, dummyEnvironment.first().getProband().getSamples().size()); assertEquals(catalogManager.getSampleManager().getUid("sample2", STUDY, sessionIdUser).getResource().getUid(), dummyEnvironment.first().getProband().getSamples().get(0).getUid()); }
@Test public void updateSubjectsNoFamilyTest() throws CatalogException { createDummyEnvironment(false); ObjectMap params = new ObjectMap(ClinicalAnalysisDBAdaptor.QueryParams.PROBAND.key(), new Individual().setId("child1").setSamples(Arrays.asList(new Sample().setId("sample2")))); QueryResult<ClinicalAnalysis> updateResult = catalogManager.getClinicalAnalysisManager().update(STUDY, "analysis", params, QueryOptions.empty(), sessionIdUser); assertEquals(1, updateResult.getNumResults()); assertEquals(0, updateResult.first().getInterpretations().size()); assertEquals(catalogManager.getIndividualManager().getUid("child1", STUDY, sessionIdUser).getResource().getUid(), updateResult.first().getProband().getUid()); assertEquals(1, updateResult.first().getProband().getSamples().size()); assertEquals(catalogManager.getSampleManager().getUid("sample2", STUDY, sessionIdUser).getResource().getUid(), updateResult.first().getProband().getSamples().get(0).getUid()); }
@Test public void testModifySample() throws CatalogException { String sampleId1 = catalogManager.getSampleManager() .create(studyFqn, new Sample().setId("SAMPLE_1"), new QueryOptions(), sessionIdUser).first().getId(); String individualId = catalogManager.getIndividualManager().create(studyFqn, new Individual().setId("Individual1"), new QueryOptions(), sessionIdUser).first().getId(); Sample sample = catalogManager.getSampleManager() .update(studyFqn, sampleId1, new ObjectMap(SampleDBAdaptor.QueryParams.INDIVIDUAL.key(), individualId), new QueryOptions("lazy", false), sessionIdUser).first(); assertEquals(individualId, ((Individual) sample.getAttributes().get("individual")).getId()); }
@Test public void searchSamplesByIndividual() throws CatalogException { catalogManager.getIndividualManager().create(studyFqn, new Individual().setId("Individual1") .setSamples(Arrays.asList(new Sample().setId("sample1"), new Sample().setId("sample2"))), new QueryOptions(), sessionIdUser); QueryResult<Sample> sampleQueryResult = catalogManager.getSampleManager().search(studyFqn, new Query(SampleDBAdaptor.QueryParams.INDIVIDUAL.key(), "Individual1"), QueryOptions.empty(), sessionIdUser); assertEquals(2, sampleQueryResult.getNumResults()); sampleQueryResult = catalogManager.getSampleManager().search(studyFqn, new Query().append(SampleDBAdaptor.QueryParams.INDIVIDUAL.key(), "Individual1") .append(SampleDBAdaptor.QueryParams.ID.key(), "sample1"), QueryOptions.empty(), sessionIdUser); assertEquals(1, sampleQueryResult.getNumResults()); catalogManager.getIndividualManager().create(studyFqn, new Individual().setId("Individual2"), new QueryOptions(), sessionIdUser); sampleQueryResult = catalogManager.getSampleManager().search(studyFqn, new Query().append(SampleDBAdaptor.QueryParams.INDIVIDUAL.key(), "Individual2"), QueryOptions.empty(), sessionIdUser); assertEquals(0, sampleQueryResult.getNumResults()); }
@Test public void updateSubjectsAndFamilyTest() throws CatalogException { createDummyEnvironment(false); ObjectMap params = new ObjectMap() .append(ClinicalAnalysisDBAdaptor.QueryParams.PROBAND.key(), new Individual().setId("child1").setSamples(Arrays.asList(new Sample().setId("sample2")))) .append(ClinicalAnalysisDBAdaptor.QueryParams.FAMILY.key(), new Family().setId("family")); QueryResult<ClinicalAnalysis> updateResult = catalogManager.getClinicalAnalysisManager().update(STUDY, "analysis", params, QueryOptions.empty(), sessionIdUser); assertEquals(1, updateResult.getNumResults()); assertEquals(0, updateResult.first().getInterpretations().size()); assertEquals(catalogManager.getFamilyManager().getUid("family", STUDY, sessionIdUser).getResource().getUid(), updateResult.first().getFamily().getUid()); assertEquals(catalogManager.getIndividualManager().getUid("child1", STUDY, sessionIdUser).getResource().getUid(), updateResult.first().getProband().getUid()); assertEquals(1, updateResult.first().getProband().getSamples().size()); assertEquals(catalogManager.getSampleManager().getUid("sample2", STUDY, sessionIdUser).getResource().getUid(), updateResult.first().getProband().getSamples().get(0).getUid()); }
@Test public void testGetSampleAndIndividualWithPermissionsChecked() throws CatalogException { String sampleId1 = catalogManager.getSampleManager() .create(studyFqn, new Sample().setId("SAMPLE_1"), new QueryOptions(), sessionIdUser).first().getId(); String individualId = catalogManager.getIndividualManager().create(studyFqn, new Individual().setId("Individual1"), new QueryOptions(), sessionIdUser).first().getId(); Sample sample = catalogManager.getSampleManager() .update(studyFqn, sampleId1, new ObjectMap(SampleDBAdaptor.QueryParams.INDIVIDUAL.key(), individualId), new QueryOptions("lazy", false), sessionIdUser).first(); assertEquals(individualId, ((Individual) sample.getAttributes().get("individual")).getId()); assertEquals(sampleId1, sample.getId()); catalogManager.getSampleManager().updateAcl(studyFqn, Collections.singletonList("SAMPLE_1"), "user2", new Sample.SampleAclParams(SampleAclEntry.SamplePermissions.VIEW.name(), AclParams.Action.SET, null, null, null), sessionIdUser); sample = catalogManager.getSampleManager().get(studyFqn, "SAMPLE_1", new QueryOptions("lazy", false), sessionIdUser2).first(); assertEquals(null, sample.getAttributes().get("individual")); assertEquals(sampleId1, sample.getId()); catalogManager.getSampleManager().updateAcl(studyFqn, Collections.singletonList("SAMPLE_1"), "user2", new Sample.SampleAclParams(SampleAclEntry.SamplePermissions.VIEW.name(), AclParams.Action.SET, null, null, null, true), sessionIdUser); sample = catalogManager.getSampleManager().get(studyFqn, "SAMPLE_1", new QueryOptions("lazy", false), sessionIdUser2).first(); assertEquals(individualId, ((Individual) sample.getAttributes().get("individual")).getId()); assertEquals(sampleId1, sample.getId()); sample = catalogManager.getSampleManager().get(studyFqn, new Query("individual", "Individual1"), new QueryOptions("lazy", false), sessionIdUser2).first(); assertEquals(individualId, ((Individual) sample.getAttributes().get("individual")).getId()); assertEquals(sampleId1, sample.getId()); }
MyResource<Individual> probandResource = catalogManager.getIndividualManager() .getUid(query.getString(ClinicalAnalysisDBAdaptor.QueryParams.PROBAND.key()), study.getFqn(), sessionId); query.put(ClinicalAnalysisDBAdaptor.QueryParams.PROBAND_UID.key(), probandResource.getResource().getUid());
@Test public void testUpdateIndividuaParents() throws CatalogException { IndividualManager individualManager = catalogManager.getIndividualManager(); individualManager.create(studyFqn, new Individual().setId("child"), QueryOptions.empty(), sessionIdUser); individualManager.create(studyFqn, new Individual().setId("father"), QueryOptions.empty(), sessionIdUser); individualManager.create(studyFqn, new Individual().setId("mother"), QueryOptions.empty(), sessionIdUser); QueryResult<Individual> individualQueryResult = individualManager.update(studyFqn, "child", new ObjectMap() .append(IndividualDBAdaptor.QueryParams.FATHER.key(), new ObjectMap(IndividualDBAdaptor.QueryParams.ID.key(), "father")) .append(IndividualDBAdaptor.QueryParams.MOTHER.key(), new ObjectMap(IndividualDBAdaptor.QueryParams.ID.key(), "mother")), QueryOptions.empty(), sessionIdUser); assertEquals("mother", individualQueryResult.first().getMother().getId()); assertEquals(1, individualQueryResult.first().getMother().getVersion()); assertEquals("father", individualQueryResult.first().getFather().getId()); assertEquals(1, individualQueryResult.first().getFather().getVersion()); }