Document member = (Document) clinicalDocument.get(ClinicalAnalysisDBAdaptor.QueryParams.PROBAND.key()); if (member != null && !options.getBoolean(NATIVE_QUERY) && !options.getBoolean(NATIVE_QUERY + "_" + ClinicalAnalysisDBAdaptor.QueryParams.PROBAND.key())) { memberSet.add(member.getLong(UID)); Object family = clinicalDocument.get(ClinicalAnalysisDBAdaptor.QueryParams.FAMILY.key()); if (family != null && !options.getBoolean(NATIVE_QUERY) && !options.getBoolean(NATIVE_QUERY + "_" + ClinicalAnalysisDBAdaptor.QueryParams.FAMILY.key())) { familySet.add(((Document) family).getLong(UID)); Object somatic = clinicalDocument.get(ClinicalAnalysisDBAdaptor.QueryParams.SOMATIC.key()); if (somatic != null && !options.getBoolean(NATIVE_QUERY) && !options.getBoolean(NATIVE_QUERY + "_" + ClinicalAnalysisDBAdaptor.QueryParams.SOMATIC.key())) { somaticSet.add(((Document) somatic).getLong(UID)); Object germline = clinicalDocument.get(ClinicalAnalysisDBAdaptor.QueryParams.GERMLINE.key()); if (germline != null && !options.getBoolean(NATIVE_QUERY) && !options.getBoolean(NATIVE_QUERY + "_" + ClinicalAnalysisDBAdaptor.QueryParams.GERMLINE.key())) { germlineSet.add(((Document) germline).getLong(UID)); Document origMember = (Document) clinicalAnalysis.get(ClinicalAnalysisDBAdaptor.QueryParams.PROBAND.key()); clinicalAnalysis.put(ClinicalAnalysisDBAdaptor.QueryParams.PROBAND.key(), completeProband); Document sourceFamily = (Document) clinicalAnalysis.get(ClinicalAnalysisDBAdaptor.QueryParams.FAMILY.key()); if (sourceFamily != null && familyMap.containsKey(sourceFamily.getLong(UID))) { clinicalAnalysis.put(ClinicalAnalysisDBAdaptor.QueryParams.FAMILY.key(), familyMap.get(sourceFamily.getLong(UID))); Document sourceSomatic = (Document) clinicalAnalysis.get(ClinicalAnalysisDBAdaptor.QueryParams.SOMATIC.key());
fixComplexQueryParam(QueryParams.ATTRIBUTES.key(), query); fixComplexQueryParam(QueryParams.BATTRIBUTES.key(), query); fixComplexQueryParam(QueryParams.NATTRIBUTES.key(), query); QueryParams queryParam = QueryParams.getParam(entry.getKey()) != null ? QueryParams.getParam(entry.getKey()) : QueryParams.getParam(key); if (queryParam == null) { throw new CatalogDBException("Unexpected parameter " + entry.getKey() + ". The parameter does not exist or cannot be " switch (queryParam) { case UID: addAutoOrQuery(PRIVATE_UID, queryParam.key(), query, queryParam.type(), andBsonList); break; case STUDY_UID: addAutoOrQuery(PRIVATE_STUDY_ID, queryParam.key(), query, queryParam.type(), andBsonList); break; case ATTRIBUTES: addAutoOrQuery(entry.getKey(), entry.getKey(), query, queryParam.type(), andBsonList); break; case BATTRIBUTES: String mongoKey = entry.getKey().replace(QueryParams.BATTRIBUTES.key(), QueryParams.ATTRIBUTES.key()); addAutoOrQuery(mongoKey, entry.getKey(), query, queryParam.type(), andBsonList); break; case NATTRIBUTES: mongoKey = entry.getKey().replace(QueryParams.NATTRIBUTES.key(), QueryParams.ATTRIBUTES.key()); addAutoOrQuery(mongoKey, entry.getKey(), query, queryParam.type(), andBsonList); break; case DISORDER: addOntologyQueryFilter(queryParam.key(), queryParam.key(), query, andBsonList);
.append(ClinicalAnalysisDBAdaptor.QueryParams.STUDY_UID.key(), studyIds) .append(ClinicalAnalysisDBAdaptor.QueryParams.RELEASE.key(), "<=" + release); dbIterator = clinicalDBAdaptor.nativeIterator(query, QueryOptions.empty()); exportToFile(dbIterator, outputDir.resolve("clinical_analysis.json").toFile(), objectMapper, "clinical analysis");
if (parameters.containsKey(QueryParams.ID.key())) { .append(QueryParams.ID.key(), parameters.get(QueryParams.ID.key())) .append(QueryParams.STUDY_UID.key(), studyId); QueryResult<Long> count = count(tmpQuery); if (count.getResult().get(0) > 0) { throw new CatalogDBException("Cannot set id for clinical analysis. A clinical analysis with { id: '" + parameters.get(QueryParams.ID.key()) + "'} already exists."); document.getSet().put(QueryParams.ID.key(), parameters.get(QueryParams.ID.key())); String[] acceptedParams = {QueryParams.DESCRIPTION.key(), QueryParams.PRIORITY.key(), QueryParams.DUE_DATE.key()}; filterStringParams(parameters, document.getSet(), acceptedParams); String[] acceptedObjectParams = {QueryParams.FILES.key(), QueryParams.FAMILY.key(), QueryParams.DISORDER.key(), QueryParams.PROBAND.key(), QueryParams.COMMENTS.key(), QueryParams.STATUS.key()}; filterObjectParams(parameters, document.getSet(), acceptedObjectParams); clinicalConverter.validateFamilyToUpdate(document.getSet()); clinicalConverter.validateProbandToUpdate(document.getSet()); if (parameters.containsKey(QueryParams.INTERPRETATIONS.key())) { List<Object> objectInterpretationList = parameters.getAsList(QueryParams.INTERPRETATIONS.key()); List<Interpretation> interpretationList = new ArrayList<>(); for (Object interpretation : objectInterpretationList) { String operation = (String) actionMap.getOrDefault(QueryParams.INTERPRETATIONS.key(), "ADD"); switch (operation) { case "SET": document.getSet().put(QueryParams.INTERPRETATIONS.key(),
ClinicalAnalysisDBAdaptor.QueryParams queryParam = ClinicalAnalysisDBAdaptor.QueryParams.getParam(param.getKey()); switch (queryParam) { case ID: ParamUtils.checkAlias(parameters.getString(queryParam.key()), "id"); break; case INTERPRETATIONS: if (TimeUtils.toDate(parameters.getString(DUE_DATE.key())) == null) { throw new CatalogException("Unrecognised due date. Accepted format is: yyyyMMddHHmmss"); Query query = new Query(ClinicalAnalysisDBAdaptor.QueryParams.UID.key(), resource.getResource().getUid()); QueryResult<ClinicalAnalysis> clinicalAnalysisQueryResult = get(studyStr, query, new QueryOptions(), sessionId); ClinicalAnalysis clinicalAnalysis = clinicalAnalysisQueryResult.first(); if (parameters.containsKey(ClinicalAnalysisDBAdaptor.QueryParams.FAMILY.key())) { Family family = parameters.get(ClinicalAnalysisDBAdaptor.QueryParams.FAMILY.key(), Family.class); family = getFullValidatedFamily(family, resource.getStudy(), sessionId); clinicalAnalysis.setFamily(family); parameters.put(ClinicalAnalysisDBAdaptor.QueryParams.FAMILY.key(), family); if (parameters.containsKey(ClinicalAnalysisDBAdaptor.QueryParams.PROBAND.key())) { Individual proband = parameters.get(ClinicalAnalysisDBAdaptor.QueryParams.PROBAND.key(), Individual.class); proband = getFullValidatedMember(proband, resource.getStudy(), sessionId); clinicalAnalysis.setProband(proband); parameters.put(ClinicalAnalysisDBAdaptor.QueryParams.PROBAND.key(), proband); if (parameters.containsKey(ClinicalAnalysisDBAdaptor.QueryParams.FILES.key())) { Map<String, List<File>> files = (Map<String, List<File>>) parameters.get(ClinicalAnalysisDBAdaptor.QueryParams.FILES.key()); clinicalAnalysis.setFiles(files);
@Override ClinicalAnalysis smartResolutor(long studyUid, String entry, String user) throws CatalogException { Query query = new Query() .append(ClinicalAnalysisDBAdaptor.QueryParams.STUDY_UID.key(), studyUid); if (UUIDUtils.isOpenCGAUUID(entry)) { query.put(ClinicalAnalysisDBAdaptor.QueryParams.UUID.key(), entry); } else { query.put(ClinicalAnalysisDBAdaptor.QueryParams.ID.key(), entry); } QueryOptions options = new QueryOptions(QueryOptions.INCLUDE, Arrays.asList( ClinicalAnalysisDBAdaptor.QueryParams.UUID.key(), ClinicalAnalysisDBAdaptor.QueryParams.UID.key(), ClinicalAnalysisDBAdaptor.QueryParams.STUDY_UID.key(), ClinicalAnalysisDBAdaptor.QueryParams.RELEASE.key(), ClinicalAnalysisDBAdaptor.QueryParams.ID.key(), ClinicalAnalysisDBAdaptor.QueryParams.STATUS.key())); QueryResult<ClinicalAnalysis> analysisQueryResult = clinicalDBAdaptor.get(query, options, user); if (analysisQueryResult.getNumResults() == 0) { analysisQueryResult = clinicalDBAdaptor.get(query, options); if (analysisQueryResult.getNumResults() == 0) { throw new CatalogException("Clinical analysis " + entry + " not found"); } else { throw new CatalogAuthorizationException("Permission denied. " + user + " is not allowed to see the clinical analysis " + entry); } } else if (analysisQueryResult.getNumResults() > 1) { throw new CatalogException("More than one clinical analysis found based on " + entry); } else { return analysisQueryResult.first(); } }
private void fixQueryObject(Query query, Study study, String sessionId) throws CatalogException { if (query.containsKey(ClinicalAnalysisDBAdaptor.QueryParams.FAMILY.key())) { MyResource<Family> familyResource = catalogManager.getFamilyManager() .getUid(query.getString(ClinicalAnalysisDBAdaptor.QueryParams.FAMILY.key()), study.getFqn(), sessionId); query.put(ClinicalAnalysisDBAdaptor.QueryParams.FAMILY_UID.key(), familyResource.getResource().getUid()); query.remove(ClinicalAnalysisDBAdaptor.QueryParams.FAMILY.key()); query.put(ClinicalAnalysisDBAdaptor.QueryParams.SAMPLE_UID.key(), sampleResource.getResource().getUid()); query.remove("sample"); if (query.containsKey(ClinicalAnalysisDBAdaptor.QueryParams.PROBAND.key())) { 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()); query.remove(ClinicalAnalysisDBAdaptor.QueryParams.PROBAND.key()); if (query.containsKey(ClinicalAnalysisDBAdaptor.QueryParams.GERMLINE.key())) { MyResource<File> resource = catalogManager.getFileManager() .getUid(query.getString(ClinicalAnalysisDBAdaptor.QueryParams.GERMLINE.key()), study.getFqn(), sessionId); query.put(ClinicalAnalysisDBAdaptor.QueryParams.GERMLINE_UID.key(), resource.getResource().getUid()); query.remove(ClinicalAnalysisDBAdaptor.QueryParams.GERMLINE.key()); if (query.containsKey(ClinicalAnalysisDBAdaptor.QueryParams.SOMATIC.key())) { MyResource<File> resource = catalogManager.getFileManager() .getUid(query.getString(ClinicalAnalysisDBAdaptor.QueryParams.SOMATIC.key()), study.getFqn(), sessionId); query.put(ClinicalAnalysisDBAdaptor.QueryParams.SOMATIC_UID.key(), resource.getResource().getUid()); query.remove(ClinicalAnalysisDBAdaptor.QueryParams.SOMATIC.key());
public QueryResult<Interpretation> create(String studyStr, String clinicalAnalysisStr, Interpretation interpretation, QueryOptions options, String sessionId) throws CatalogException { // We check if the user can create interpretations in the clinical analysis MyResource<ClinicalAnalysis> resource = catalogManager.getClinicalAnalysisManager() .getUid(clinicalAnalysisStr, studyStr, sessionId); authorizationManager.checkClinicalAnalysisPermission(resource.getStudy().getUid(), resource.getResource().getUid(), resource.getUser(), ClinicalAnalysisAclEntry.ClinicalAnalysisPermissions.UPDATE); options = ParamUtils.defaultObject(options, QueryOptions::new); ParamUtils.checkObj(interpretation, "clinicalAnalysis"); ParamUtils.checkAlias(interpretation.getInterpretation().getId(), "id"); interpretation.getInterpretation().setCreationDate(TimeUtils.getTime()); interpretation.getInterpretation().setDescription( ParamUtils.defaultString(interpretation.getInterpretation().getDescription(), "")); interpretation.getInterpretation().setStatus(Status.READY); interpretation.getInterpretation().setAttributes( ParamUtils.defaultObject(interpretation.getInterpretation().getAttributes(), Collections.emptyMap())); interpretation.setUuid(UUIDUtils.generateOpenCGAUUID(UUIDUtils.Entity.INTERPRETATION)); QueryResult<Interpretation> queryResult = interpretationDBAdaptor.insert(resource.getStudy().getUid(), interpretation, options); // Now, we add the interpretation to the clinical analysis ObjectMap parameters = new ObjectMap(); parameters.put(ClinicalAnalysisDBAdaptor.QueryParams.INTERPRETATIONS.key(), Arrays.asList(interpretation)); Map<String, Object> actionMap = new HashMap<>(); actionMap.put(ClinicalAnalysisDBAdaptor.QueryParams.INTERPRETATIONS.key(), ParamUtils.UpdateAction.ADD.name()); parameters.put(Constants.ACTIONS, actionMap); catalogManager.getClinicalAnalysisManager().update(resource.getStudy().getFqn(), clinicalAnalysisStr, parameters, null, sessionId); return queryResult; }
@Override public void checkClinicalAnalysisPermission(long studyId, long analysisId, String userId, ClinicalAnalysisAclEntry.ClinicalAnalysisPermissions permission) throws CatalogException { Query query = new Query() .append(ClinicalAnalysisDBAdaptor.QueryParams.UID.key(), analysisId) .append(ClinicalAnalysisDBAdaptor.QueryParams.STUDY_UID.key(), studyId); StudyAclEntry.StudyPermissions studyPermission; switch (permission) { case VIEW: studyPermission = StudyAclEntry.StudyPermissions.VIEW_CLINICAL_ANALYSIS; break; case UPDATE: studyPermission = StudyAclEntry.StudyPermissions.WRITE_CLINICAL_ANALYSIS; break; case DELETE: studyPermission = StudyAclEntry.StudyPermissions.DELETE_CLINICAL_ANALYSIS; break; default: throw new CatalogAuthorizationException("Permission " + permission.toString() + " not found"); } if (checkUserPermission(userId, query, studyPermission, clinicalAnalysisDBAdaptor)) { return; } throw CatalogAuthorizationException.deny(userId, permission.toString(), "ClinicalAnalysis", analysisId, null); }
private MongoCursor<Document> getMongoCursor(Query query, QueryOptions options, Document studyDocument, String user) throws CatalogDBException, CatalogAuthorizationException { Document queryForAuthorisedEntries = null; if (studyDocument != null && user != null) { // Get the document query needed to check the permissions as well queryForAuthorisedEntries = getQueryForAuthorisedEntries(studyDocument, user, StudyAclEntry.StudyPermissions.VIEW_CLINICAL_ANALYSIS.name(), ClinicalAnalysisAclEntry.ClinicalAnalysisPermissions.VIEW.name(), Entity.CLINICAL_ANALYSIS.name()); } filterOutDeleted(query); Bson bson = parseQuery(query, false, queryForAuthorisedEntries); QueryOptions qOptions; if (options != null) { qOptions = new QueryOptions(options); } else { qOptions = new QueryOptions(); } qOptions = removeInnerProjections(qOptions, QueryParams.PROBAND.key()); qOptions = removeInnerProjections(qOptions, QueryParams.FAMILY.key()); logger.debug("Clinical analysis query : {}", bson.toBsonDocument(Document.class, MongoClient.getDefaultCodecRegistry())); return clinicalCollection.nativeQuery().find(bson, qOptions).iterator(); }
public void validateProbandToUpdate(Document document) { Document member = (Document) document.get(ClinicalAnalysisDBAdaptor.QueryParams.PROBAND.key()); if (member != null) { member.put("uid", getLongValue(member, "uid")); member.remove("studyUid"); Document father = (Document) member.get(IndividualDBAdaptor.QueryParams.FATHER.key()); if (father != null) { father.put("uid", getLongValue(father, "uid")); father.remove("studyUid"); } Document mother = (Document) member.get(IndividualDBAdaptor.QueryParams.MOTHER.key()); if (mother != null) { mother.put("uid", getLongValue(mother, "uid")); mother.remove("studyUid"); } List<Document> samples = (List<Document>) member.get(IndividualDBAdaptor.QueryParams.SAMPLES.key()); if (ListUtils.isNotEmpty(samples)) { for (Document sample : samples) { sample.put("uid", getLongValue(sample, "uid")); sample.remove("studyUid"); } } } }
@Override public QueryResult<Long> count(final Query query, final String user, final StudyAclEntry.StudyPermissions studyPermissions) throws CatalogDBException, CatalogAuthorizationException { filterOutDeleted(query); StudyAclEntry.StudyPermissions studyPermission = studyPermissions; if (studyPermission == null) { studyPermission = StudyAclEntry.StudyPermissions.VIEW_CLINICAL_ANALYSIS; } // Get the study document Query studyQuery = new Query(StudyDBAdaptor.QueryParams.UID.key(), query.getLong(QueryParams.STUDY_UID.key())); QueryResult queryResult = dbAdaptorFactory.getCatalogStudyDBAdaptor().nativeGet(studyQuery, QueryOptions.empty()); if (queryResult.getNumResults() == 0) { throw new CatalogDBException("Study " + query.getLong(QueryParams.STUDY_UID.key()) + " not found"); } // Get the document query needed to check the permissions as well Document queryForAuthorisedEntries = getQueryForAuthorisedEntries((Document) queryResult.first(), user, studyPermission.name(), studyPermission.getClinicalAnalysisPermission().name(), Entity.CLINICAL_ANALYSIS.name()); Bson bson = parseQuery(query, false, queryForAuthorisedEntries); logger.debug("Clinical count: query : {}, dbTime: {}", bson.toBsonDocument(Document.class, MongoClient.getDefaultCodecRegistry())); return clinicalCollection.count(bson); }
@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()); }
@Override public QueryResult<ClinicalAnalysis> update(long id, ObjectMap parameters, QueryOptions options) throws CatalogDBException { long startTime = startQuery(); Query query = new Query(QueryParams.UID.key(), id); UpdateDocument updateDocument = parseAndValidateUpdateParams(parameters, query, options); Document updateOperation = updateDocument.toFinalUpdateDocument(); if (!updateOperation.isEmpty()) { Bson bsonQuery = Filters.eq(PRIVATE_UID, id); logger.debug("Update clinical analysis. Query: {}, Update: {}", bsonQuery.toBsonDocument(Document.class, MongoClient.getDefaultCodecRegistry()), updateDocument); QueryResult<UpdateResult> update = clinicalCollection.update(bsonQuery, updateOperation, null); if (update.getResult().isEmpty() || update.getResult().get(0).getMatchedCount() == 0) { throw CatalogDBException.uidNotFound("Clinical Analysis", id); } } return endQuery("Modify clinical analysis", startTime, get(id, options)); }
@Override public QueryResult<ClinicalAnalysis> get(String studyStr, Query query, QueryOptions options, String sessionId) throws CatalogException { query = ParamUtils.defaultObject(query, Query::new); options = ParamUtils.defaultObject(options, QueryOptions::new); String userId = catalogManager.getUserManager().getUserId(sessionId); Study study = catalogManager.getStudyManager().resolveId(studyStr, userId); query.append(ClinicalAnalysisDBAdaptor.QueryParams.STUDY_UID.key(), study.getUid()); QueryResult<ClinicalAnalysis> queryResult = clinicalDBAdaptor.get(query, options, userId); if (queryResult.getNumResults() == 0 && query.containsKey(ClinicalAnalysisDBAdaptor.QueryParams.UID.key())) { List<Long> analysisList = query.getAsLongList(ClinicalAnalysisDBAdaptor.QueryParams.UID.key()); for (Long analysisId : analysisList) { authorizationManager.checkClinicalAnalysisPermission(study.getUid(), analysisId, userId, ClinicalAnalysisAclEntry.ClinicalAnalysisPermissions.VIEW); } } return queryResult; }
public ClinicalAnalysisMongoDBIterator(MongoCursor mongoCursor, GenericDocumentComplexConverter<E> converter, DBAdaptorFactory dbAdaptorFactory, long studyUid, String user, QueryOptions options) { super(mongoCursor, converter); this.user = user; this.studyUid = studyUid; this.options = options; this.familyDBAdaptor = dbAdaptorFactory.getCatalogFamilyDBAdaptor(); this.familyQueryOptions = createInnerQueryOptions(ClinicalAnalysisDBAdaptor.QueryParams.FAMILY.key(), false); this.individualDBAdaptor = dbAdaptorFactory.getCatalogIndividualDBAdaptor(); this.individualQueryOptions = createInnerQueryOptions(ClinicalAnalysisDBAdaptor.QueryParams.PROBAND.key(), false); this.fileDBAdaptor = dbAdaptorFactory.getCatalogFileDBAdaptor(); this.somaticQueryOptions = createInnerQueryOptions(ClinicalAnalysisDBAdaptor.QueryParams.SOMATIC.key(), true); this.germlineQueryOptions = createInnerQueryOptions(ClinicalAnalysisDBAdaptor.QueryParams.GERMLINE.key(), true); this.clinicalAnalysisListBuffer= new LinkedList<>(); this.logger = LoggerFactory.getLogger(ClinicalAnalysisMongoDBIterator.class); }
@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()); }
public void validateFamilyToUpdate(Document document) { Document family = (Document) document.get(ClinicalAnalysisDBAdaptor.QueryParams.FAMILY.key()); if (family != null) { // Store the uid as a long value family.put("uid", getLongValue(family, "uid")); family.remove("studyUid"); // Check if family contains members List<Document> members = (List<Document>) family.get(FamilyDBAdaptor.QueryParams.MEMBERS.key()); if (ListUtils.isNotEmpty(members)) { for (Document member : members) { validateProbandToUpdate(member); } } } }
private void checkInterpretationPermissions(String study, long interpretationId, String token) throws CatalogException, ClinicalVariantException { // Get user ID from token and study numeric ID String userId = catalogManager.getUserManager().getUserId(token); String studyId = catalogManager.getStudyManager().resolveId(study, userId).getFqn(); // This checks that the user has permission to this interpretation Query query = new Query(ClinicalAnalysisDBAdaptor.QueryParams.INTERPRETATIONS_ID.key(), interpretationId); QueryResult<ClinicalAnalysis> clinicalAnalysisQueryResult = catalogManager.getClinicalAnalysisManager() .get(studyId, query, QueryOptions.empty(), token); if (clinicalAnalysisQueryResult.getResult().isEmpty()) { throw new ClinicalVariantException("Either the interpretation ID (" + interpretationId + ") does not exist or the user does" + " not have access permissions"); } }