private ClinicalAnalysis getClinicalAnalysis() throws CatalogException { assert(null != catalogManager); if (StringUtils.isNotEmpty(clinicalAnalysisId)) { final ClinicalAnalysisManager clinicalAnalysisManager = catalogManager.getClinicalAnalysisManager(); // have to convert session QueryResult<ClinicalAnalysis> clinicalAnalyses = clinicalAnalysisManager.get( studyStr, clinicalAnalysisId, QueryOptions.empty(), sessionId ); clinicalAnalysis = clinicalAnalyses.first(); return clinicalAnalysis; } return null; }
MyResources<ClinicalAnalysis> resource = getUids(clinicalList, studyStr, sessionId); authorizationManager.checkCanAssignOrSeePermissions(resource.getStudy().getUid(), resource.getUser()); checkMembers(resource.getStudy().getUid(), members);
@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 = catalogManager.getUserManager().getUserId(sessionId); Study study = catalogManager.getStudyManager().resolveId(studyStr, userId); fixQueryObject(query, study, sessionId); // Add study id to the query query.put(FamilyDBAdaptor.QueryParams.STUDY_UID.key(), study.getUid()); QueryResult queryResult = clinicalDBAdaptor.groupBy(query, fields, options, userId); return ParamUtils.defaultObject(queryResult, QueryResult::new); }
@Override public QueryResult<ClinicalAnalysis> update(String studyStr, String entryStr, ObjectMap parameters, QueryOptions options, String sessionId) throws CatalogException { MyResource<ClinicalAnalysis> resource = getUid(entryStr, studyStr, sessionId); authorizationManager.checkClinicalAnalysisPermission(resource.getStudy().getUid(), resource.getResource().getUid(), resource.getUser(), ClinicalAnalysisAclEntry.ClinicalAnalysisPermissions.UPDATE); QueryResult<ClinicalAnalysis> clinicalAnalysisQueryResult = get(studyStr, query, new QueryOptions(), sessionId); ClinicalAnalysis clinicalAnalysis = clinicalAnalysisQueryResult.first(); family = getFullValidatedFamily(family, resource.getStudy(), sessionId); clinicalAnalysis.setFamily(family); parameters.put(ClinicalAnalysisDBAdaptor.QueryParams.FAMILY.key(), family); proband = getFullValidatedMember(proband, resource.getStudy(), sessionId); clinicalAnalysis.setProband(proband); parameters.put(ClinicalAnalysisDBAdaptor.QueryParams.PROBAND.key(), proband); validateClinicalAnalysisFields(clinicalAnalysis, resource.getStudy(), sessionId); if (parameters.containsKey(ClinicalAnalysisDBAdaptor.QueryParams.FILES.key())) { parameters.put(ClinicalAnalysisDBAdaptor.QueryParams.FILES.key(), clinicalAnalysis.getFiles());
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 QueryResult<ClinicalAnalysis> create(String studyStr, ClinicalAnalysis clinicalAnalysis, QueryOptions options, String sessionId) throws CatalogException { String userId = catalogManager.getUserManager().getUserId(sessionId); Study study = catalogManager.getStudyManager().resolveId(studyStr, userId); authorizationManager.checkStudyPermission(study.getUid(), userId, StudyAclEntry.StudyPermissions.WRITE_CLINICAL_ANALYSIS); options = ParamUtils.defaultObject(options, QueryOptions::new); ParamUtils.checkObj(clinicalAnalysis, "clinicalAnalysis"); ParamUtils.checkAlias(clinicalAnalysis.getId(), "id"); ParamUtils.checkObj(clinicalAnalysis.getType(), "type"); ParamUtils.checkObj(clinicalAnalysis.getDueDate(), "dueDate"); if (TimeUtils.toDate(clinicalAnalysis.getDueDate()) == null) { throw new CatalogException("Unrecognised due date. Accepted format is: yyyyMMddHHmmss"); } clinicalAnalysis.setProband(getFullValidatedMember(clinicalAnalysis.getProband(), study, sessionId)); clinicalAnalysis.setFamily(getFullValidatedFamily(clinicalAnalysis.getFamily(), study, sessionId)); validateClinicalAnalysisFields(clinicalAnalysis, study, sessionId); clinicalAnalysis.setCreationDate(TimeUtils.getTime()); clinicalAnalysis.setDescription(ParamUtils.defaultString(clinicalAnalysis.getDescription(), "")); clinicalAnalysis.setStatus(new ClinicalAnalysis.ClinicalStatus()); clinicalAnalysis.setRelease(catalogManager.getStudyManager().getCurrentRelease(study, userId)); clinicalAnalysis.setAttributes(ParamUtils.defaultObject(clinicalAnalysis.getAttributes(), Collections.emptyMap())); clinicalAnalysis.setInterpretations(ParamUtils.defaultObject(clinicalAnalysis.getInterpretations(), ArrayList::new)); clinicalAnalysis.setPriority(ParamUtils.defaultObject(clinicalAnalysis.getPriority(), ClinicalAnalysis.Priority.MEDIUM)); clinicalAnalysis.setUuid(UUIDUtils.generateOpenCGAUUID(UUIDUtils.Entity.CLINICAL)); QueryResult<ClinicalAnalysis> queryResult = clinicalDBAdaptor.insert(study.getUid(), clinicalAnalysis, options); return queryResult; }
@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 List<QueryResult<ClinicalAnalysisAclEntry>> getAcls(String studyStr, List<String> clinicalList, String member, boolean silent, String sessionId) throws CatalogException { List<QueryResult<ClinicalAnalysisAclEntry>> clinicalAclList = new ArrayList<>(clinicalList.size()); for (String clinicalAnalysis : clinicalList) { try { MyResource<ClinicalAnalysis> resource = getUid(clinicalAnalysis, studyStr, sessionId); QueryResult<ClinicalAnalysisAclEntry> allClinicalAcls; if (StringUtils.isNotEmpty(member)) { allClinicalAcls = authorizationManager.getClinicalAnalysisAcl(resource.getStudy().getUid(), resource.getResource().getUid(), resource.getUser(), member); } else { allClinicalAcls = authorizationManager.getAllClinicalAnalysisAcls(resource.getStudy().getUid(), resource.getResource().getUid(), resource.getUser()); } allClinicalAcls.setId(clinicalAnalysis); clinicalAclList.add(allClinicalAcls); } catch (CatalogException e) { if (silent) { clinicalAclList.add(new QueryResult<>(clinicalAnalysis, 0, 0, 0, "", e.toString(), new ArrayList<>(0))); } else { throw e; } } } return clinicalAclList; }
finalMembers.add(getFullValidatedMember(fullMember, study, sessionId));
panelManager = new PanelManager(authorizationManager, auditManager, this, catalogDBAdaptorFactory, catalogIOManagerFactory, configuration); clinicalAnalysisManager = new ClinicalAnalysisManager(authorizationManager, auditManager, this, catalogDBAdaptorFactory, catalogIOManagerFactory, configuration); interpretationManager = new InterpretationManager(authorizationManager, auditManager, this, catalogDBAdaptorFactory,
private QueryResult<ClinicalAnalysis> createDummyEnvironment(boolean createFamily) throws CatalogException { createDummyFamily(); ClinicalAnalysis clinicalAnalysis = new ClinicalAnalysis() .setId("analysis").setDescription("My description").setType(ClinicalAnalysis.Type.FAMILY) .setDueDate("20180510100000") .setProband(new Individual().setId("child1").setSamples(Arrays.asList(new Sample().setId("sample2")))); if (createFamily) { clinicalAnalysis.setFamily(new Family().setId("family")); } return catalogManager.getClinicalAnalysisManager().create(STUDY, clinicalAnalysis, QueryOptions.empty(), sessionIdUser); }
@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()); }
.getUid(resource.getResource().getInterpretation().getClinicalAnalysisId(), studyStr, sessionId); authorizationManager.checkClinicalAnalysisPermission(resource.getStudy().getUid(), clinicalAnalysisResource.getResource().getUid(), resource.getUser(), ClinicalAnalysisAclEntry.ClinicalAnalysisPermissions.UPDATE);
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"); } }
public QueryResult<ClinicalAnalysis> search(String studyStr, Query query, QueryOptions options, String sessionId) throws CatalogException { String userId = catalogManager.getUserManager().getUserId(sessionId); Study study = catalogManager.getStudyManager().resolveId(studyStr, userId); fixQueryObject(query, study, sessionId); query.append(ClinicalAnalysisDBAdaptor.QueryParams.STUDY_UID.key(), study.getUid()); QueryResult<ClinicalAnalysis> queryResult = clinicalDBAdaptor.get(query, options, userId); // authorizationManager.filterClinicalAnalysis(userId, studyId, queryResultAux.getResult()); return queryResult; }
.get(studyIds.get(0), query, QueryOptions.empty(), token);
public QueryResult<ClinicalAnalysis> count(String studyStr, Query query, String sessionId) throws CatalogException { String userId = catalogManager.getUserManager().getUserId(sessionId); Study study = catalogManager.getStudyManager().resolveId(studyStr, userId); fixQueryObject(query, study, sessionId); query.append(ClinicalAnalysisDBAdaptor.QueryParams.STUDY_UID.key(), study.getUid()); QueryResult<Long> queryResultAux = clinicalDBAdaptor.count(query, userId, StudyAclEntry.StudyPermissions.VIEW_CLINICAL_ANALYSIS); return new QueryResult<>("count", queryResultAux.getDbTime(), 0, queryResultAux.first(), queryResultAux.getWarningMsg(), queryResultAux.getErrorMsg(), Collections.emptyList()); }
QueryResult<ClinicalAnalysis> clinicalAnalysisQueryResult = catalogManager.getClinicalAnalysisManager().get(studyStr, clinicalAnalysisId, QueryOptions.empty(), token); if (clinicalAnalysisQueryResult.getNumResults() == 0) {
QueryResult<ClinicalAnalysis> clinicalAnalysisQueryResult = catalogManager.getClinicalAnalysisManager().get(studyStr, clinicalAnalysisId, QueryOptions.empty(), token); if (clinicalAnalysisQueryResult.getNumResults() == 0) {