@Deprecated public QueryResult<Individual> create(long studyId, String name, String family, long fatherId, long motherId, IndividualProperty.Sex sex, String ethnicity, String populationName, String populationSubpopulation, String populationDescription, String dateOfBirth, IndividualProperty.KaryotypicSex karyotypicSex, IndividualProperty.LifeStatus lifeStatus, IndividualProperty.AffectationStatus affectationStatus, QueryOptions options, String sessionId) throws CatalogException { Individual individual = new Individual(name, name, null, null, null, null, sex, karyotypicSex, ethnicity, new Individual.Population(populationName, populationSubpopulation, populationDescription), dateOfBirth, -1, 1, null, null, lifeStatus, affectationStatus, null, null, null, false, null, null); return create(String.valueOf(studyId), individual, options, sessionId); }
public QueryResult<Individual> get(long studyId, Query query, QueryOptions options, String sessionId) throws CatalogException { return get(String.valueOf(studyId), query, options, sessionId); }
public List<QueryResult<IndividualAclEntry>> getAcls(String studyStr, List<String> individualList, String member, boolean silent, String sessionId) throws CatalogException { List<QueryResult<IndividualAclEntry>> individualAclList = new ArrayList<>(individualList.size()); for (String individual : individualList) { try { MyResource<Individual> resource = getUid(individual, studyStr, sessionId); QueryResult<IndividualAclEntry> allIndividualAcls; if (StringUtils.isNotEmpty(member)) { allIndividualAcls = authorizationManager.getIndividualAcl(resource.getStudy().getUid(), resource.getResource().getUid(), resource.getUser(), member); } else { allIndividualAcls = authorizationManager.getAllIndividualAcls(resource.getStudy().getUid(), resource.getResource().getUid(), resource.getUser()); } allIndividualAcls.setId(individual); individualAclList.add(allIndividualAcls); } catch (CatalogException e) { if (silent) { individualAclList.add(new QueryResult<>(individual, 0, 0, 0, "", e.toString(), new ArrayList<>(0))); } else { throw e; } } } return individualAclList; }
@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) )); }
.setSex(IndividualProperty.Sex.UNKNOWN); ind.setAnnotationSets(Collections.singletonList(annotationSet)); ind = catalogManager.getIndividualManager().create(studyFqn, ind, QueryOptions.empty(), sessionIdUser).first(); catalogManager.getIndividualManager().updateAnnotations(studyFqn, ind.getId(), annotationSet.getId(), annotationSet.getAnnotations(), ParamUtils.CompleteUpdateAction.SET, new QueryOptions(Constants.INCREMENT_VERSION, true), sessionIdUser); ind = catalogManager.getIndividualManager().get(studyFqn, ind.getId(), null, sessionIdUser).first(); check.accept(sample.getAnnotationSets().get(0)); check.accept(ind.getAnnotationSets().get(0)); catalogManager.getIndividualManager().updateAnnotations(studyFqn, ind.getId(), annotationSet.getId(), annotationSet.getAnnotations(), ParamUtils.CompleteUpdateAction.SET, new QueryOptions(Constants.INCREMENT_VERSION, true), sessionIdUser); catalogManager.getIndividualManager().updateAnnotations(studyFqn, ind.getId(), annotationSet.getId(), annotationSet.getAnnotations(), ParamUtils.CompleteUpdateAction.SET, new QueryOptions(Constants.INCREMENT_VERSION, true), sessionIdUser); ind = catalogManager.getIndividualManager().get(studyFqn, ind.getId(), null, sessionIdUser).first(); check.accept(sample.getAnnotationSets().get(0)); check.accept(ind.getAnnotationSets().get(0)); catalogManager.getIndividualManager().updateAnnotations(studyFqn, ind.getId(), annotationSet.getId(), annotationSet.getAnnotations(), ParamUtils.CompleteUpdateAction.SET, new QueryOptions(Constants.INCREMENT_VERSION, true), sessionIdUser); ind = catalogManager.getIndividualManager().get(studyFqn, ind.getId(), null, sessionIdUser).first();
@Test public void testUpdateIndividualInfo() throws CatalogException { IndividualManager individualManager = catalogManager.getIndividualManager(); QueryResult<Individual> individualQueryResult = individualManager.create(studyFqn, new Individual().setId("Test") .setDateOfBirth("19870214"), QueryOptions.empty(), sessionIdUser); assertEquals(1, individualQueryResult.getNumResults()); assertEquals("Test", individualQueryResult.first().getId()); assertEquals("19870214", individualQueryResult.first().getDateOfBirth()); QueryResult<Individual> update = individualManager.update(studyFqn, individualQueryResult.first().getId(), new ObjectMap(IndividualDBAdaptor.QueryParams.DATE_OF_BIRTH.key() , null), QueryOptions.empty(), sessionIdUser); assertEquals("", update.first().getDateOfBirth()); update = individualManager.update(studyFqn, individualQueryResult.first().getId(), new ObjectMap(IndividualDBAdaptor.QueryParams.DATE_OF_BIRTH.key(), "19870214"), QueryOptions.empty(), sessionIdUser); assertEquals("19870214", update.first().getDateOfBirth()); update = individualManager.update(studyFqn, String.valueOf(individualQueryResult.first().getId()), new ObjectMap(IndividualDBAdaptor.QueryParams.ATTRIBUTES.key(), Collections.singletonMap("key", "value")), QueryOptions.empty(), sessionIdUser); assertEquals("value", update.first().getAttributes().get("key")); update = individualManager.update(studyFqn, String.valueOf(individualQueryResult.first().getId()), new ObjectMap(IndividualDBAdaptor.QueryParams.ATTRIBUTES.key(), Collections.singletonMap("key2", "value2")), QueryOptions.empty(), sessionIdUser); assertEquals("value", update.first().getAttributes().get("key")); // Keep "key" assertEquals("value2", update.first().getAttributes().get("key2")); // add new "key2" // Wrong date of birth format thrown.expect(CatalogException.class); thrown.expectMessage("Invalid date of birth format"); individualManager.update(studyFqn, individualQueryResult.first().getId(), new ObjectMap(IndividualDBAdaptor.QueryParams.DATE_OF_BIRTH.key(), "198421"), QueryOptions.empty(), sessionIdUser); }
Query query = new Query(IndividualDBAdaptor.QueryParams.SAMPLES.key(), aclParams.getSample()); QueryOptions options = new QueryOptions(QueryOptions.INCLUDE, IndividualDBAdaptor.QueryParams.ID.key()); QueryResult<Individual> indQueryResult = catalogManager.getIndividualManager().get(studyStr, query, options, sessionId); MyResources<Individual> resource = getUids(individualList, studyStr, sessionId); checkMembers(resource.getStudy().getUid(), members); allIndividualPermissions, Entity.INDIVIDUAL); if (aclParams.isPropagate()) { List<String> sampleIds = getSamplesFromIndividuals(resource); if (sampleIds.size() > 0) { Sample.SampleAclParams sampleAclParams = new Sample.SampleAclParams(aclParams.getPermissions(), .map(Individual::getUid).collect(Collectors.toList()), members, permissions, Entity.INDIVIDUAL); if (aclParams.isPropagate()) { List<String> sampleIds = getSamplesFromIndividuals(resource); if (sampleIds.size() > 0) { Sample.SampleAclParams sampleAclParams = new Sample.SampleAclParams(aclParams.getPermissions(), .collect(Collectors.toList()), members, permissions, Entity.INDIVIDUAL); if (aclParams.isPropagate()) { List<String> sampleIds = getSamplesFromIndividuals(resource); if (CollectionUtils.isNotEmpty(sampleIds)) { Sample.SampleAclParams sampleAclParams = new Sample.SampleAclParams(aclParams.getPermissions(), .collect(Collectors.toList()), members, null, Entity.INDIVIDUAL); if (aclParams.isPropagate()) { List<String> sampleIds = getSamplesFromIndividuals(resource);
Query query = new Query(IndividualDBAdaptor.QueryParams.ID.key(), sampleAclParams.getIndividual()); QueryOptions options = new QueryOptions(QueryOptions.INCLUDE, IndividualDBAdaptor.QueryParams.SAMPLES.key()); QueryResult<Individual> indQueryResult = catalogManager.getIndividualManager().get(studyStr, query, options, sessionId); .collect(Collectors.toList()), ","), false); catalogManager.getIndividualManager().updateAcl(studyStr, null, memberIds, aclParams, sessionId); } catch (CatalogException e) { logger.warn("Error propagating permissions to individual: {}", e.getMessage(), e); AclParams.Action.ADD, StringUtils.join(resource.getResourceList().stream().map(Sample::getId) .collect(Collectors.toList()), ","), false); catalogManager.getIndividualManager().updateAcl(studyStr, null, memberIds, aclParams, sessionId); } catch (CatalogException e) { logger.warn("Error propagating permissions to individual: {}", e.getMessage(), e); .collect(Collectors.toList()), ","), false); catalogManager.getIndividualManager().updateAcl(studyStr, null, memberIds, aclParams, sessionId); } catch (CatalogException e) { logger.warn("Error propagating permissions to individual: {}", e.getMessage(), e); .collect(Collectors.toList()), ","), false); catalogManager.getIndividualManager().updateAcl(studyStr, null, memberIds, aclParams, sessionId); } catch (CatalogException e) { logger.warn("Error propagating permissions to individual: {}", e.getMessage(), e);
MyResources<Individual> resource = catalogManager.getIndividualManager().getUids( query.getAsStringList(FamilyDBAdaptor.QueryParams.MEMBERS.key()), study.getFqn(), sessionId); query.put(FamilyDBAdaptor.QueryParams.MEMBER_UID.key(), resource.getResourceList().stream().map(Individual::getUid) .append(IndividualDBAdaptor.QueryParams.SAMPLES.key(), query.getString(IndividualDBAdaptor.QueryParams.SAMPLES.key())); QueryOptions options = new QueryOptions(QueryOptions.INCLUDE, IndividualDBAdaptor.QueryParams.UID.key()); QueryResult<Individual> individualResult = catalogManager.getIndividualManager().get(study.getFqn(), newQuery, options, sessionId);
options = ParamUtils.defaultObject(options, QueryOptions::new); MyResource<Individual> resource = getUid(entryStr, studyStr, sessionId); String userId = resource.getUser(); long studyId = resource.getStudy().getUid(); Map<Long, Integer> existingSamplesInIndividual = checkSamplesNotInUseInOtherIndividual( sampleResource.getResourceList().stream().map(Sample::getUid).collect(Collectors.toSet()), studyId, individualId); Map<String, Object> map = parameters.getMap(IndividualDBAdaptor.QueryParams.FATHER.key()); if (map != null && StringUtils.isNotEmpty((String) map.get(IndividualDBAdaptor.QueryParams.ID.key()))) { MyResource tmpResource = getUid((String) map.get(IndividualDBAdaptor.QueryParams.ID.key()), studyStr, sessionId); parameters.remove(IndividualDBAdaptor.QueryParams.FATHER.key()); parameters.put(IndividualDBAdaptor.QueryParams.FATHER_UID.key(), tmpResource.getResource().getUid()); Map<String, Object> map = parameters.getMap(IndividualDBAdaptor.QueryParams.MOTHER.key()); if (map != null && StringUtils.isNotEmpty((String) map.get(IndividualDBAdaptor.QueryParams.ID.key()))) { MyResource tmpResource = getUid((String) map.get(IndividualDBAdaptor.QueryParams.ID.key()), studyStr, sessionId); parameters.remove(IndividualDBAdaptor.QueryParams.MOTHER.key()); parameters.put(IndividualDBAdaptor.QueryParams.MOTHER_UID.key(), tmpResource.getResource().getUid()); return unsafeUpdate(resource.getStudy(), resource.getResource(), parameters, options, userId);
@Test public void testGetIndividualWithSamples() throws CatalogException { IndividualManager individualManager = catalogManager.getIndividualManager(); individualManager.create(studyFqn, new Individual().setId("individual1") .setSamples(Arrays.asList(new Sample().setId("sample1"), new Sample().setId("sample2"), new Sample().setId("sample3"))), QueryOptions.empty(), sessionIdUser); individualManager.create(studyFqn, new Individual().setId("individual2") .setSamples(Arrays.asList(new Sample().setId("sample4"), new Sample().setId("sample5"), new Sample().setId("sample6"))), QueryOptions.empty(), sessionIdUser); QueryResult<Individual> search = individualManager.search(studyFqn, new Query(), QueryOptions.empty(), sessionIdUser); assertEquals(2, search.getNumResults()); search.getResult().forEach(i -> { search = individualManager.search(studyFqn, new Query(), new QueryOptions(QueryOptions.EXCLUDE, "samples.creationDate"), sessionIdUser); assertEquals(2, search.getNumResults()); search = individualManager.search(studyFqn, new Query(), new QueryOptions(QueryOptions.INCLUDE, "samples.id"), sessionIdUser); assertEquals(2, search.getNumResults()); search = individualManager.search(studyFqn, new Query(), new QueryOptions(QueryOptions.INCLUDE, "id,creationDate,samples.id"), sessionIdUser); assertEquals(2, search.getNumResults());
List<VariableSet> variableSetList = validateNewAnnotationSetsAndExtractVariableSets(studyUid, individual.getAnnotationSets()); checkSamplesNotInUseInOtherIndividual(existingSampleIds, studyUid, null); MyResource<Individual> fatherResource = getUid(individual.getFather().getId(), study.getFqn(), sessionId); individual.setFather(fatherResource.getResource()); MyResource<Individual> motherResource = getUid(individual.getMother().getId(), study.getFqn(), sessionId); individual.setMother(motherResource.getResource());
public QueryResult<Individual> resetAnnotations(String studyStr, String individualStr, String annotationSetId, List<String> annotations, QueryOptions options, String token) throws CatalogException { return updateAnnotations(studyStr, individualStr, annotationSetId, new ObjectMap("reset", StringUtils.join(annotations, ",")), ParamUtils.CompleteUpdateAction.RESET, options, token); }
public QueryResult<Individual> updateAnnotationSet(String studyStr, String individualStr, List<AnnotationSet> annotationSetList, ParamUtils.UpdateAction action, QueryOptions options, String token) throws CatalogException { ObjectMap params = new ObjectMap(AnnotationSetManager.ANNOTATION_SETS, annotationSetList); options = ParamUtils.defaultObject(options, QueryOptions::new); options.put(Constants.ACTIONS, new ObjectMap(AnnotationSetManager.ANNOTATION_SETS, action)); return update(studyStr, individualStr, params, options, token); }
assertEquals(0, familyQueryResult.first().getMembers().size()); catalogManager.getIndividualManager().updateAcl(STUDY, Collections.singletonList("child2"), "user2", new Individual.IndividualAclParams("VIEW", AclParams.Action.SET, "", false), sessionIdUser); familyQueryResult = familyManager.get(STUDY, "Martinez-Martinez", QueryOptions.empty(), token); assertEquals("child2", familyQueryResult.first().getMembers().get(0).getId()); catalogManager.getIndividualManager().updateAcl(STUDY, Collections.singletonList("child3"), "user2", new Individual.IndividualAclParams("VIEW", AclParams.Action.SET, "", false), sessionIdUser); familyQueryResult = familyManager.get(STUDY, "Martinez-Martinez", QueryOptions.empty(), token);
public QueryResult<Individual> addAnnotationSet(String studyStr, String individualStr, AnnotationSet annotationSet, QueryOptions options, String token) throws CatalogException { return addAnnotationSets(studyStr, individualStr, Collections.singletonList(annotationSet), options, token); }
sampleManager = new SampleManager(authorizationManager, auditManager, this, catalogDBAdaptorFactory, catalogIOManagerFactory, configuration); individualManager = new IndividualManager(authorizationManager, auditManager, this, catalogDBAdaptorFactory, catalogIOManagerFactory, configuration); cohortManager = new CohortManager(authorizationManager, auditManager, this, catalogDBAdaptorFactory,
String individualId1 = catalogManager.getIndividualManager().create(studyFqn, new Individual().setId("INDIVIDUAL_1") .setKaryotypicSex(IndividualProperty.KaryotypicSex.UNKNOWN).setLifeStatus(IndividualProperty.LifeStatus.UNKNOWN) .setAffectationStatus(IndividualProperty.AffectationStatus.UNKNOWN), new QueryOptions(), sessionIdUser) .first().getId(); String individualId2 = catalogManager.getIndividualManager().create(studyFqn, new Individual().setId("INDIVIDUAL_2") .setKaryotypicSex(IndividualProperty.KaryotypicSex.UNKNOWN).setLifeStatus(IndividualProperty.LifeStatus.UNKNOWN) .setAffectationStatus(IndividualProperty.AffectationStatus.UNKNOWN), new QueryOptions(), sessionIdUser) .first().getId(); String individualId3 = catalogManager.getIndividualManager().create(studyFqn, new Individual().setId("INDIVIDUAL_3") .setKaryotypicSex(IndividualProperty.KaryotypicSex.UNKNOWN).setLifeStatus(IndividualProperty.LifeStatus.UNKNOWN) .setAffectationStatus(IndividualProperty.AffectationStatus.UNKNOWN), new QueryOptions(), sessionIdUser) .first().getId(); catalogManager.getIndividualManager().update(studyFqn, individualId1, new ObjectMap() .append(IndividualDBAdaptor.QueryParams.ANNOTATION_SETS.key(), Collections.singletonList(new ObjectMap() .append(AnnotationSetManager.ID, "annot1") catalogManager.getIndividualManager().update(studyFqn, individualId2, new ObjectMap() .append(IndividualDBAdaptor.QueryParams.ANNOTATION_SETS.key(), Collections.singletonList(new ObjectMap() .append(AnnotationSetManager.ID, "annot1") catalogManager.getIndividualManager().update(studyFqn, individualId3, new ObjectMap() .append(IndividualDBAdaptor.QueryParams.ANNOTATION_SETS.key(), Collections.singletonList(new ObjectMap() .append(AnnotationSetManager.ID, "annot1") individuals = catalogManager.getIndividualManager().get(studyFqn, new Query(IndividualDBAdaptor.QueryParams.ANNOTATION.key(), variableSet.getId() + ":NAME=~^INDIVIDUAL_"), null, sessionIdUser)
QueryResult<Individual> individualQueryResult = catalogManager.getIndividualManager().get(studyStr, sample.getIndividual().getId(), new QueryOptions(QueryOptions.INCLUDE, Arrays.asList( sample.getIndividual().setSamples(Collections.singletonList(queryResult.first())); try { catalogManager.getIndividualManager().create(studyStr, sample.getIndividual(), QueryOptions.empty(), sessionId); } catch (CatalogException e) {