Java tutorial
/* * Copyright 2015 Observational Health Data Sciences and Informatics [OHDSI.org]. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package org.ohdsi.webapi.service; import com.fasterxml.jackson.annotation.JsonFormat; import com.fasterxml.jackson.annotation.JsonInclude; import com.fasterxml.jackson.databind.ObjectMapper; import java.math.BigDecimal; import java.math.RoundingMode; import java.sql.ResultSet; import java.sql.SQLException; import java.util.ArrayList; import java.util.Arrays; import java.util.Calendar; import java.util.Collection; import java.util.Collections; import java.util.Date; import java.util.HashMap; import java.util.Iterator; import java.util.List; import java.util.Map; import java.util.Set; import javax.servlet.ServletContext; import javax.ws.rs.Consumes; import javax.ws.rs.DELETE; import javax.ws.rs.GET; import javax.ws.rs.PUT; import javax.ws.rs.Path; import javax.ws.rs.PathParam; import javax.ws.rs.Produces; import javax.ws.rs.core.Context; import javax.ws.rs.core.MediaType; import org.apache.commons.lang3.StringUtils; import org.ohdsi.sql.SqlTranslate; import org.ohdsi.webapi.feasibility.InclusionRule; import org.ohdsi.webapi.feasibility.FeasibilityStudy; import org.ohdsi.webapi.feasibility.PerformFeasibilityTasklet; import org.ohdsi.webapi.feasibility.StudyGenerationInfo; import org.ohdsi.webapi.feasibility.FeasibilityReport; import org.ohdsi.webapi.cohortdefinition.CohortDefinition; import org.ohdsi.webapi.cohortdefinition.CohortDefinitionRepository; import org.ohdsi.webapi.TerminateJobStepExceptionHandler; import org.ohdsi.webapi.cohortdefinition.CohortDefinitionDetails; import org.ohdsi.webapi.cohortdefinition.CohortExpression; import org.ohdsi.webapi.cohortdefinition.CohortGenerationInfo; import org.ohdsi.webapi.cohortdefinition.CriteriaGroup; import org.ohdsi.webapi.cohortdefinition.ExpressionType; import org.ohdsi.webapi.feasibility.FeasibilityStudyRepository; import org.ohdsi.webapi.cohortdefinition.GenerateCohortTasklet; import org.ohdsi.webapi.GenerationStatus; import org.ohdsi.webapi.job.JobExecutionResource; import org.ohdsi.webapi.job.JobTemplate; import org.ohdsi.webapi.shiro.management.Security; import org.ohdsi.webapi.source.Source; import org.ohdsi.webapi.source.SourceDaimon; import org.ohdsi.webapi.util.SessionUtils; import org.springframework.batch.core.Job; import org.springframework.batch.core.JobParameters; import org.springframework.batch.core.JobParametersBuilder; import org.springframework.batch.core.Step; import org.springframework.batch.core.configuration.annotation.JobBuilderFactory; import org.springframework.batch.core.configuration.annotation.StepBuilderFactory; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.jdbc.core.JdbcTemplate; import org.springframework.jdbc.core.RowMapper; import org.springframework.stereotype.Component; import org.springframework.transaction.TransactionDefinition; import org.springframework.transaction.TransactionStatus; import org.springframework.transaction.annotation.Transactional; import org.springframework.transaction.support.DefaultTransactionDefinition; /** * * @author Chris Knoll <cknoll@ohdsi.org> */ @Path("/feasibility/") @Component public class FeasibilityService extends AbstractDaoService { @Autowired private CohortDefinitionRepository cohortDefinitionRepository; @Autowired private FeasibilityStudyRepository feasibilityStudyRepository; @Autowired private CohortDefinitionService definitionService; @Autowired private JobBuilderFactory jobBuilders; @Autowired private StepBuilderFactory stepBuilders; @Autowired private JobTemplate jobTemplate; @Autowired private Security security; @Context ServletContext context; private StudyGenerationInfo findStudyGenerationInfoBySourceId(Collection<StudyGenerationInfo> infoList, Integer sourceId) { for (StudyGenerationInfo info : infoList) { if (info.getId().getSourceId() == sourceId) { return info; } } return null; } private CohortGenerationInfo findCohortGenerationInfoBySourceId(Collection<CohortGenerationInfo> infoList, Integer sourceId) { for (CohortGenerationInfo info : infoList) { if (info.getId().getSourceId() == sourceId) { return info; } } return null; } public static class FeasibilityStudyListItem { public Integer id; public String name; public String description; public String createdBy; public Integer indexCohortId; public Integer matchingCohortId; @JsonFormat(shape = JsonFormat.Shape.STRING, pattern = "yyyy-MM-dd, HH:mm") public Date createdDate; public String modifiedBy; @JsonFormat(shape = JsonFormat.Shape.STRING, pattern = "yyyy-MM-dd, HH:mm") public Date modifiedDate; } public static class FeasibilityStudyDTO extends FeasibilityStudyListItem { public String indexRule; public String indexDescription; public List<InclusionRule> inclusionRules; } public static class StudyInfoDTO { public StudyGenerationInfo generationInfo; public FeasibilityReport.Summary summary; } private final RowMapper<FeasibilityReport.Summary> summaryMapper = new RowMapper<FeasibilityReport.Summary>() { @Override public FeasibilityReport.Summary mapRow(ResultSet rs, int rowNum) throws SQLException { FeasibilityReport.Summary summary = new FeasibilityReport.Summary(); summary.totalPersons = rs.getLong("person_count"); summary.matchingPersons = rs.getLong("match_count"); double matchRatio = (summary.totalPersons > 0) ? ((double) summary.matchingPersons / (double) summary.totalPersons) : 0.0; summary.percentMatched = new BigDecimal(matchRatio * 100.0).setScale(2, RoundingMode.HALF_UP) .toPlainString() + "%"; return summary; } }; private FeasibilityReport.Summary getSimulationSummary(int id, Source source) { String resultsTableQualifier = source.getTableQualifier(SourceDaimon.DaimonType.Results); String summaryQuery = String.format( "select person_count, match_count from %s.feas_study_index_stats where study_id = %d", resultsTableQualifier, id); String translatedSql = SqlTranslate.translateSql(summaryQuery, "sql server", source.getSourceDialect(), SessionUtils.sessionId(), resultsTableQualifier); List<FeasibilityReport.Summary> summaryList = this.getSourceJdbcTemplate(source).query(translatedSql, summaryMapper); if (summaryList.size() > 0) return summaryList.get(0); return null; } private final RowMapper<FeasibilityReport.InclusionRuleStatistic> inclusionRuleStatisticMapper = new RowMapper<FeasibilityReport.InclusionRuleStatistic>() { @Override public FeasibilityReport.InclusionRuleStatistic mapRow(ResultSet rs, int rowNum) throws SQLException { FeasibilityReport.InclusionRuleStatistic statistic = new FeasibilityReport.InclusionRuleStatistic(); statistic.id = rs.getInt("rule_sequence"); statistic.name = rs.getString("name"); statistic.countSatisfying = rs.getLong("person_count"); long personTotal = rs.getLong("person_total"); long gainCount = rs.getLong("gain_count"); double excludeRatio = personTotal > 0 ? (double) gainCount / (double) personTotal : 0.0; String percentExcluded = new BigDecimal(excludeRatio * 100.0).setScale(2, RoundingMode.HALF_UP) .toPlainString(); statistic.percentExcluded = percentExcluded + "%"; long satisfyCount = rs.getLong("person_count"); double satisfyRatio = personTotal > 0 ? (double) satisfyCount / (double) personTotal : 0.0; String percentSatisfying = new BigDecimal(satisfyRatio * 100.0).setScale(2, RoundingMode.HALF_UP) .toPlainString(); statistic.percentSatisfying = percentSatisfying + "%"; return statistic; } }; private String getMatchingCriteriaExpression(FeasibilityStudy p) { if (p.getInclusionRules().size() == 0) { throw new RuntimeException("Study must have at least 1 inclusion rule"); } try { // all resultRule repository objects are initalized; create 'all criteria' cohort definition from index rule + inclusion rules ObjectMapper mapper = new ObjectMapper().setSerializationInclusion(JsonInclude.Include.NON_NULL); CohortExpression indexRuleExpression = mapper.readValue(p.getIndexRule().getDetails().getExpression(), CohortExpression.class); if (indexRuleExpression.additionalCriteria == null) { CriteriaGroup additionalCriteria = new CriteriaGroup(); additionalCriteria.type = "ALL"; indexRuleExpression.additionalCriteria = additionalCriteria; } else { if (!"ALL".equalsIgnoreCase(indexRuleExpression.additionalCriteria.type)) { // move this CriteriaGroup inside a new parent CriteriaGroup where the parent CriteriaGroup.type == "ALL" CriteriaGroup parentGroup = new CriteriaGroup(); parentGroup.type = "ALL"; parentGroup.groups = new CriteriaGroup[1]; parentGroup.groups[0] = indexRuleExpression.additionalCriteria; indexRuleExpression.additionalCriteria = parentGroup; } } // place each inclusion rule (which is a CriteriaGroup) in the indexRuleExpression.additionalCriteria.group array to create the 'allCriteriaExpression' ArrayList<CriteriaGroup> additionalCriteriaGroups = new ArrayList<>(); if (indexRuleExpression.additionalCriteria.groups != null) { additionalCriteriaGroups.addAll(Arrays.asList(indexRuleExpression.additionalCriteria.groups)); } for (InclusionRule inclusionRule : p.getInclusionRules()) { String inclusionRuleJSON = inclusionRule.getExpression(); CriteriaGroup inclusionRuleGroup = mapper.readValue(inclusionRuleJSON, CriteriaGroup.class); additionalCriteriaGroups.add(inclusionRuleGroup); } // overwrite indexRule additional criteria groups with the new list of groups with inclusion rules indexRuleExpression.additionalCriteria.groups = additionalCriteriaGroups.toArray(new CriteriaGroup[0]); String allCriteriaExpression = mapper.writeValueAsString(indexRuleExpression); // index rule expression now contains all inclusion criteria as additional criteria return allCriteriaExpression; } catch (Exception e) { throw new RuntimeException(e); } } private List<FeasibilityReport.InclusionRuleStatistic> getSimulationInclusionRuleStatistics(int id, Source source) { String resultsTableQualifier = source.getTableQualifier(SourceDaimon.DaimonType.Results); String statisticsQuery = String.format( "select rule_sequence, name, person_count, gain_count, person_total from %s.feas_study_inclusion_stats where study_id = %d ORDER BY rule_sequence", resultsTableQualifier, id); String translatedSql = SqlTranslate.translateSql(statisticsQuery, "sql server", source.getSourceDialect(), SessionUtils.sessionId(), resultsTableQualifier); return this.getSourceJdbcTemplate(source).query(translatedSql, inclusionRuleStatisticMapper); } private int countSetBits(long n) { int count = 0; while (n > 0) { n &= (n - 1); count++; } return count; } private String formatBitMask(Long n, int size) { return StringUtils.reverse(StringUtils.leftPad(Long.toBinaryString(n), size, "0")); } private final RowMapper<Long[]> simulationResultItemMapper = new RowMapper<Long[]>() { @Override public Long[] mapRow(ResultSet rs, int rowNum) throws SQLException { Long[] resultItem = new Long[2]; resultItem[0] = rs.getLong("inclusion_rule_mask"); resultItem[1] = rs.getLong("person_count"); return resultItem; } }; private String getInclusionRuleTreemapData(int id, int inclusionRuleCount, Source source) { String resultsTableQualifier = source.getTableQualifier(SourceDaimon.DaimonType.Results); String smulationResultsQuery = String.format( "select inclusion_rule_mask, person_count from %s.feas_study_result where study_id = %d", resultsTableQualifier, id); String translatedSql = SqlTranslate.translateSql(smulationResultsQuery, "sql server", source.getSourceDialect(), SessionUtils.sessionId(), resultsTableQualifier); // [0] is the inclusion rule bitmask, [1] is the count of the match List<Long[]> items = this.getSourceJdbcTemplate(source).query(translatedSql, simulationResultItemMapper); Map<Integer, List<Long[]>> groups = new HashMap<>(); for (Long[] item : items) { int bitsSet = countSetBits(item[0]); if (!groups.containsKey(bitsSet)) { groups.put(bitsSet, new ArrayList<Long[]>()); } groups.get(bitsSet).add(item); } StringBuilder treemapData = new StringBuilder("{\"name\" : \"Everyone\", \"children\" : ["); List<Integer> groupKeys = new ArrayList<Integer>(groups.keySet()); Collections.sort(groupKeys); Collections.reverse(groupKeys); int groupCount = 0; // create a nested treemap data where more matches (more bits set in string) appear higher in the hierarchy) for (Integer groupKey : groupKeys) { if (groupCount > 0) { treemapData.append(","); } treemapData.append(String.format("{\"name\" : \"Group %d\", \"children\" : [", groupKey)); int groupItemCount = 0; for (Long[] groupItem : groups.get(groupKey)) { if (groupItemCount > 0) { treemapData.append(","); } //sb_treemap.Append("{\"name\": \"" + cohort_identifer + "\", \"size\": " + cohorts[cohort_identifer].ToString() + "}"); treemapData.append(String.format("{\"name\": \"%s\", \"size\": %d}", formatBitMask(groupItem[0], inclusionRuleCount), groupItem[1])); groupItemCount++; } groupCount++; } treemapData.append(StringUtils.repeat("]}", groupCount + 1)); return treemapData.toString(); } public FeasibilityStudyDTO feasibilityStudyToDTO(FeasibilityStudy study) { FeasibilityStudyDTO pDTO = new FeasibilityStudyDTO(); pDTO.id = study.getId(); pDTO.name = study.getName(); pDTO.description = study.getDescription(); pDTO.indexCohortId = study.getIndexRule().getId(); pDTO.matchingCohortId = study.getResultRule() != null ? study.getResultRule().getId() : null; pDTO.createdBy = study.getCreatedBy(); pDTO.createdDate = study.getCreatedDate(); pDTO.modifiedBy = study.getModifiedBy(); pDTO.modifiedDate = study.getModifiedDate(); pDTO.indexRule = study.getIndexRule().getDetails().getExpression(); pDTO.indexDescription = study.getIndexRule().getDescription(); pDTO.inclusionRules = study.getInclusionRules(); return pDTO; } /** * Returns all cohort definitions in the cohort schema * * @return List of cohort_definition */ @GET @Path("/") @Produces(MediaType.APPLICATION_JSON) public List<FeasibilityService.FeasibilityStudyListItem> getFeasibilityStudyList() { ArrayList<FeasibilityService.FeasibilityStudyListItem> result = new ArrayList<>(); Iterable<FeasibilityStudy> studies = this.feasibilityStudyRepository.findAll(); for (FeasibilityStudy p : studies) { FeasibilityService.FeasibilityStudyListItem item = new FeasibilityService.FeasibilityStudyListItem(); item.id = p.getId(); item.name = p.getName(); item.description = p.getDescription(); item.indexCohortId = p.getIndexRule().getId(); item.matchingCohortId = p.getResultRule() != null ? p.getResultRule().getId() : null; item.createdBy = p.getCreatedBy(); item.createdDate = p.getCreatedDate(); item.modifiedBy = p.getModifiedBy(); item.modifiedDate = p.getModifiedDate(); result.add(item); } return result; } /** * Creates the feasibility study * * @param study The study to create. * @return The new FeasibilityStudy */ @PUT @Path("/") @Produces(MediaType.APPLICATION_JSON) @Consumes(MediaType.APPLICATION_JSON) @Transactional public FeasibilityService.FeasibilityStudyDTO createStudy(FeasibilityService.FeasibilityStudyDTO study) { Date currentTime = Calendar.getInstance().getTime(); //create definition in 2 saves, first to get the generated ID for the new cohort definition (the index rule) // then to associate the new definition with the index rule of the study FeasibilityStudy newStudy = new FeasibilityStudy(); newStudy.setName(study.name).setDescription(study.description).setCreatedBy(security.getSubject()) .setCreatedDate(currentTime).setInclusionRules(new ArrayList<InclusionRule>(study.inclusionRules)); // create index cohort CohortDefinition indexRule = new CohortDefinition() .setName("Index Population for Study: " + newStudy.getName()).setDescription(study.indexDescription) .setCreatedBy(security.getSubject()).setCreatedDate(currentTime) .setExpressionType(ExpressionType.SIMPLE_EXPRESSION); CohortDefinitionDetails indexDetails = new CohortDefinitionDetails(); indexDetails.setCohortDefinition(indexRule).setExpression(study.indexRule); indexRule.setDetails(indexDetails); newStudy.setIndexRule(indexRule); // build matching cohort from inclusion rules if inclusion rules exist if (newStudy.getInclusionRules().size() > 0) { CohortDefinition resultDef = new CohortDefinition() .setName("Matching Population for Study: " + newStudy.getName()) .setDescription(newStudy.getDescription()).setCreatedBy(security.getSubject()) .setCreatedDate(currentTime).setExpressionType(ExpressionType.SIMPLE_EXPRESSION); CohortDefinitionDetails resultDetails = new CohortDefinitionDetails(); resultDetails.setCohortDefinition(resultDef).setExpression(getMatchingCriteriaExpression(newStudy)); resultDef.setDetails(resultDetails); newStudy.setResultRule(resultDef); } FeasibilityStudy createdStudy = this.feasibilityStudyRepository.save(newStudy); return feasibilityStudyToDTO(createdStudy); } @GET @Path("/{id}") @Produces(MediaType.APPLICATION_JSON) @Consumes(MediaType.APPLICATION_JSON) @Transactional(readOnly = true) public FeasibilityService.FeasibilityStudyDTO getStudy(@PathParam("id") final int id) { FeasibilityStudy s = this.feasibilityStudyRepository.findOneWithDetail(id); return feasibilityStudyToDTO(s); } @PUT @Path("/{id}") @Produces(MediaType.APPLICATION_JSON) @Transactional public FeasibilityService.FeasibilityStudyDTO saveStudy(@PathParam("id") final int id, FeasibilityStudyDTO study) { Date currentTime = Calendar.getInstance().getTime(); FeasibilityStudy updatedStudy = this.feasibilityStudyRepository.findOne(id); updatedStudy.setName(study.name).setDescription(study.description).setModifiedBy(security.getSubject()) .setModifiedDate(currentTime).setInclusionRules(study.inclusionRules); updatedStudy.getIndexRule().setModifiedBy(security.getSubject()).setModifiedDate(currentTime) .setName("Index Population for Study: " + updatedStudy.getName()) .setDescription(study.indexDescription).getDetails().setExpression(study.indexRule); CohortDefinition resultRule = updatedStudy.getResultRule(); if (updatedStudy.getInclusionRules().size() > 0) { if (resultRule == null) { resultRule = new CohortDefinition(); resultRule.setName("Matching Population for Study: " + updatedStudy.getName()) .setCreatedBy(security.getSubject()).setCreatedDate(currentTime) .setExpressionType(ExpressionType.SIMPLE_EXPRESSION); CohortDefinitionDetails resultDetails = new CohortDefinitionDetails(); resultDetails.setCohortDefinition(resultRule); resultRule.setDetails(resultDetails); updatedStudy.setResultRule(resultRule); } resultRule.setModifiedBy(security.getSubject()).setModifiedDate(currentTime) .setName("Matching Population for Study: " + updatedStudy.getName()) .setDescription(updatedStudy.getDescription()).setModifiedBy(security.getSubject()) .setModifiedDate(currentTime).getDetails() .setExpression(getMatchingCriteriaExpression(updatedStudy)); } else { updatedStudy.setResultRule(null); if (resultRule != null) { cohortDefinitionRepository.delete(resultRule); } } this.feasibilityStudyRepository.save(updatedStudy); return getStudy(id); } @GET @Path("/{study_id}/generate/{sourceKey}") @Produces(MediaType.APPLICATION_JSON) @Consumes(MediaType.APPLICATION_JSON) public JobExecutionResource performStudy(@PathParam("study_id") final int study_id, @PathParam("sourceKey") final String sourceKey) { Date startTime = Calendar.getInstance().getTime(); Source source = this.getSourceRepository().findBySourceKey(sourceKey); String resultsTableQualifier = source.getTableQualifier(SourceDaimon.DaimonType.Results); String cdmTableQualifier = source.getTableQualifier(SourceDaimon.DaimonType.CDM); DefaultTransactionDefinition requresNewTx = new DefaultTransactionDefinition(); requresNewTx.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW); TransactionStatus initStatus = this.getTransactionTemplate().getTransactionManager() .getTransaction(requresNewTx); FeasibilityStudy study = this.feasibilityStudyRepository.findOne(study_id); CohortDefinition indexRule = this.cohortDefinitionRepository.findOne(study.getIndexRule().getId()); CohortGenerationInfo indexInfo = findCohortGenerationInfoBySourceId(indexRule.getGenerationInfoList(), source.getSourceId()); if (indexInfo == null) { indexInfo = new CohortGenerationInfo(indexRule, source.getSourceId()); indexRule.getGenerationInfoList().add(indexInfo); } indexInfo.setStatus(GenerationStatus.PENDING).setStartTime(startTime).setExecutionDuration(null); this.cohortDefinitionRepository.save(indexRule); if (study.getResultRule() != null) { CohortDefinition resultRule = this.cohortDefinitionRepository.findOne(study.getResultRule().getId()); CohortGenerationInfo resultInfo = findCohortGenerationInfoBySourceId(resultRule.getGenerationInfoList(), source.getSourceId()); if (resultInfo == null) { resultInfo = new CohortGenerationInfo(resultRule, source.getSourceId()); resultRule.getGenerationInfoList().add(resultInfo); } resultInfo.setStatus(GenerationStatus.PENDING).setStartTime(startTime).setExecutionDuration(null); this.cohortDefinitionRepository.save(resultRule); } StudyGenerationInfo studyInfo = findStudyGenerationInfoBySourceId(study.getStudyGenerationInfoList(), source.getSourceId()); if (studyInfo == null) { studyInfo = new StudyGenerationInfo(study, source); study.getStudyGenerationInfoList().add(studyInfo); } studyInfo.setStatus(GenerationStatus.PENDING).setStartTime(startTime).setExecutionDuration(null); this.feasibilityStudyRepository.save(study); this.getTransactionTemplate().getTransactionManager().commit(initStatus); JobParametersBuilder builder = new JobParametersBuilder(); builder.addString("jobName", "performing feasibility study on " + indexRule.getName() + " : " + source.getSourceName() + " (" + source.getSourceKey() + ")"); builder.addString("cdm_database_schema", cdmTableQualifier); builder.addString("results_database_schema", resultsTableQualifier); builder.addString("target_database_schema", resultsTableQualifier); builder.addString("target_dialect", source.getSourceDialect()); builder.addString("target_table", "cohort"); builder.addString("cohort_definition_id", ("" + indexRule.getId())); builder.addString("study_id", ("" + study_id)); builder.addString("source_id", ("" + source.getSourceId())); builder.addString("generate_stats", Boolean.TRUE.toString()); final JobParameters jobParameters = builder.toJobParameters(); final JdbcTemplate sourceJdbcTemplate = getSourceJdbcTemplate(source); GenerateCohortTasklet indexRuleTasklet = new GenerateCohortTasklet(sourceJdbcTemplate, getTransactionTemplate(), cohortDefinitionRepository); Step generateCohortStep = stepBuilders.get("performStudy.generateIndexCohort").tasklet(indexRuleTasklet) .exceptionHandler(new TerminateJobStepExceptionHandler()).build(); PerformFeasibilityTasklet simulateTasket = new PerformFeasibilityTasklet(sourceJdbcTemplate, getTransactionTemplate(), feasibilityStudyRepository, cohortDefinitionRepository); Step performStudyStep = stepBuilders.get("performStudy.performStudy").tasklet(simulateTasket).build(); Job performStudyJob = jobBuilders.get("performStudy").start(generateCohortStep).next(performStudyStep) .build(); JobExecutionResource jobExec = this.jobTemplate.launch(performStudyJob, jobParameters); return jobExec; } @GET @Path("/{id}/info") @Produces(MediaType.APPLICATION_JSON) @Transactional(readOnly = true) public List<StudyInfoDTO> getSimulationInfo(@PathParam("id") final int id) { FeasibilityStudy study = this.feasibilityStudyRepository.findOne(id); List<StudyInfoDTO> result = new ArrayList<>(); for (StudyGenerationInfo generationInfo : study.getStudyGenerationInfoList()) { StudyInfoDTO info = new StudyInfoDTO(); info.generationInfo = generationInfo; info.summary = getSimulationSummary(id, generationInfo.getSource()); result.add(info); } return result; } @GET @Path("/{id}/report/{sourceKey}") @Produces(MediaType.APPLICATION_JSON) @Transactional public FeasibilityReport getSimulationReport(@PathParam("id") final int id, @PathParam("sourceKey") final String sourceKey) { Source source = this.getSourceRepository().findBySourceKey(sourceKey); FeasibilityReport.Summary summary = getSimulationSummary(id, source); List<FeasibilityReport.InclusionRuleStatistic> inclusionRuleStats = getSimulationInclusionRuleStatistics(id, source); String treemapData = getInclusionRuleTreemapData(id, inclusionRuleStats.size(), source); FeasibilityReport report = new FeasibilityReport(); report.summary = summary; report.inclusionRuleStats = inclusionRuleStats; report.treemapData = treemapData; return report; } /** * Copies the specified cohort definition * * @param id - the Cohort Definition ID to copy * @return the copied cohort definition as a CohortDefinitionDTO */ @GET @Produces(MediaType.APPLICATION_JSON) @Path("/{id}/copy") @javax.transaction.Transactional public FeasibilityStudyDTO copy(@PathParam("id") final int id) { FeasibilityStudyDTO sourceStudy = getStudy(id); sourceStudy.id = null; // clear the ID sourceStudy.name = "COPY OF: " + sourceStudy.name; FeasibilityStudyDTO copyStudy = createStudy(sourceStudy); return copyStudy; } /** * Deletes the specified cohort definition * * @param id - the Cohort Definition ID to copy */ @DELETE @Produces(MediaType.APPLICATION_JSON) @Path("/{id}") public void delete(@PathParam("id") final int id) { feasibilityStudyRepository.delete(id); } /** * Deletes the specified cohort definition * * @param id - the Cohort Definition ID to copy */ @DELETE @Produces(MediaType.APPLICATION_JSON) @Path("/{id}/info/{sourceKey}") @Transactional public void deleteInfo(@PathParam("id") final int id, @PathParam("sourceKey") final String sourceKey) { FeasibilityStudy study = feasibilityStudyRepository.findOne(id); StudyGenerationInfo itemToRemove = null; for (StudyGenerationInfo info : study.getStudyGenerationInfoList()) { if (info.getSource().getSourceKey().equals(sourceKey)) itemToRemove = info; } if (itemToRemove != null) study.getStudyGenerationInfoList().remove(itemToRemove); feasibilityStudyRepository.save(study); } }