From 5464709fdc37e2f5cd6a51293952e28e8bfe325c Mon Sep 17 00:00:00 2001 From: Jon Duke Date: Mon, 1 Feb 2021 12:04:55 -0500 Subject: [PATCH 01/55] Added Annotation Code --- .../annotation/annotation/Annotation.java | 138 ++++++++++++++ .../annotation/AnnotationController.java | 97 ++++++++++ .../annotation/annotation/AnnotationDto.java | 102 ++++++++++ .../annotation/AnnotationRepository.java | 13 ++ .../annotation/AnnotationService.java | 98 ++++++++++ .../webapi/annotation/answer/Answer.java | 109 +++++++++++ .../annotation/answer/AnswerController.java | 27 +++ .../annotation/answer/AnswerRepository.java | 6 + .../annotation/answer/AnswerService.java | 18 ++ .../annotation/navigation/Navigation.java | 83 ++++++++ .../navigation/NavigationController.java | 52 +++++ .../navigation/NavigationService.java | 60 ++++++ .../webapi/annotation/question/Question.java | 174 +++++++++++++++++ .../question/QuestionController.java | 41 ++++ .../question/QuestionRepository.java | 6 + .../annotation/question/QuestionService.java | 27 +++ .../webapi/annotation/result/Result.java | 177 ++++++++++++++++++ .../webapi/annotation/result/ResultDto.java | 82 ++++++++ .../annotation/result/ResultRepository.java | 15 ++ .../webapi/annotation/set/QuestionSet.java | 135 +++++++++++++ .../annotation/set/QuestionSetController.java | 50 +++++ .../annotation/set/QuestionSetRepository.java | 13 ++ .../annotation/set/QuestionSetService.java | 34 ++++ .../webapi/cohortsample/CohortSample.java | 8 + .../postgresql/V2.5.1__annotation.sql | 93 +++++++++ 25 files changed, 1658 insertions(+) create mode 100644 src/main/java/org/ohdsi/webapi/annotation/annotation/Annotation.java create mode 100644 src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationController.java create mode 100644 src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationDto.java create mode 100644 src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationRepository.java create mode 100644 src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationService.java create mode 100644 src/main/java/org/ohdsi/webapi/annotation/answer/Answer.java create mode 100644 src/main/java/org/ohdsi/webapi/annotation/answer/AnswerController.java create mode 100644 src/main/java/org/ohdsi/webapi/annotation/answer/AnswerRepository.java create mode 100644 src/main/java/org/ohdsi/webapi/annotation/answer/AnswerService.java create mode 100644 src/main/java/org/ohdsi/webapi/annotation/navigation/Navigation.java create mode 100644 src/main/java/org/ohdsi/webapi/annotation/navigation/NavigationController.java create mode 100644 src/main/java/org/ohdsi/webapi/annotation/navigation/NavigationService.java create mode 100644 src/main/java/org/ohdsi/webapi/annotation/question/Question.java create mode 100644 src/main/java/org/ohdsi/webapi/annotation/question/QuestionController.java create mode 100644 src/main/java/org/ohdsi/webapi/annotation/question/QuestionRepository.java create mode 100644 src/main/java/org/ohdsi/webapi/annotation/question/QuestionService.java create mode 100644 src/main/java/org/ohdsi/webapi/annotation/result/Result.java create mode 100644 src/main/java/org/ohdsi/webapi/annotation/result/ResultDto.java create mode 100644 src/main/java/org/ohdsi/webapi/annotation/result/ResultRepository.java create mode 100644 src/main/java/org/ohdsi/webapi/annotation/set/QuestionSet.java create mode 100644 src/main/java/org/ohdsi/webapi/annotation/set/QuestionSetController.java create mode 100644 src/main/java/org/ohdsi/webapi/annotation/set/QuestionSetRepository.java create mode 100644 src/main/java/org/ohdsi/webapi/annotation/set/QuestionSetService.java create mode 100644 src/main/resources/db/migration/postgresql/V2.5.1__annotation.sql diff --git a/src/main/java/org/ohdsi/webapi/annotation/annotation/Annotation.java b/src/main/java/org/ohdsi/webapi/annotation/annotation/Annotation.java new file mode 100644 index 0000000000..e615fe9b07 --- /dev/null +++ b/src/main/java/org/ohdsi/webapi/annotation/annotation/Annotation.java @@ -0,0 +1,138 @@ +package org.ohdsi.webapi.annotation.annotation; + +import java.util.HashSet; +import java.util.Set; +import javax.persistence.Column; +import javax.persistence.Entity; +import javax.persistence.GeneratedValue; +import javax.persistence.CascadeType; +import javax.persistence.FetchType; +import javax.persistence.OneToMany; +import javax.persistence.ManyToOne; +import javax.persistence.JoinColumn; +import javax.persistence.Id; +import javax.persistence.Table; +import org.ohdsi.webapi.annotation.result.Result; +import org.ohdsi.webapi.annotation.set.QuestionSet; +import com.fasterxml.jackson.annotation.JsonIgnore; + +@Entity(name = "Annotation") +@Table( + name = "annotation" +) +public class Annotation { + + @Id + @GeneratedValue + @Column(name = "annotation_id") + private Long id; + + @Column(name = "subject_id") + private Long subjectId; + + @Column(name = "cohort_id") + private Long cohortId; + + // @Column(name = "sample_name") + // private String sampleName; + + @JsonIgnore + @ManyToOne + @JoinColumn(name = "set_id") + private QuestionSet set; + + @OneToMany( + fetch = FetchType.EAGER, + mappedBy = "annotation", + cascade = CascadeType.ALL, + orphanRemoval = true + ) + private Set results = new HashSet(); + + //***** GETTERS/SETTERS ****** + + /** + * @return the id + */ + public Long getId() { + return id; + } + + /** + * @param id the id to set + */ + public void setId(Long id) { + this.id = id; + } + + /** + * @return the subjectId + */ + public Long getSubjectId() { + return subjectId; + } + + /** + * @param subjectId the subjectId to set + */ + public void setSubjectId(Long subjectId) { + this.subjectId = subjectId; + } + + /** + * @return the cohortId + */ + public Long getCohortId() { + return cohortId; + } + + /** + * @param cohortId the cohortId to set + */ + public void setCohortId(Long cohortId) { + this.cohortId = cohortId; + } + + /** + * @return the set + */ + public QuestionSet getSet() { + return set; + } + + /** + * @param set the set to set + */ + public void setSet(QuestionSet set) { + this.set = set; + } + + /** + * @return the results + */ + public Set getResults() { + return new HashSet(results); + } + + /** + * @param results the results to set + */ + protected void setResults(Set results) { + this.results = results; + } + + public void addToResults(Result result) { + result.setAnnotation(this); + this.results.add(result); + } + + +// public void setSampleName(String name) { +// this.sampleName = name; +// } + +// public String getSampleName() { +// return this.sampleName; +// } + +} diff --git a/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationController.java b/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationController.java new file mode 100644 index 0000000000..07137cf662 --- /dev/null +++ b/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationController.java @@ -0,0 +1,97 @@ +package org.ohdsi.webapi.annotation.annotation; + +import java.util.List; +import javax.ws.rs.GET; +import javax.ws.rs.POST; +import javax.ws.rs.Path; +import javax.ws.rs.Consumes; +import javax.ws.rs.Produces; +import javax.ws.rs.core.MediaType; +import javax.ws.rs.QueryParam; +import javax.ws.rs.PathParam; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.stereotype.Component; +import org.ohdsi.webapi.annotation.annotation.AnnotationService; +import org.ohdsi.webapi.annotation.annotation.Annotation; +import org.ohdsi.webapi.annotation.set.QuestionSetRepository; +import org.ohdsi.webapi.annotation.set.QuestionSet; +import org.ohdsi.webapi.annotation.result.Result; + + + +@Path("annotations") +@Component +public class AnnotationController { + + @Autowired + private AnnotationService annotationService; + + @Autowired + private QuestionSetRepository questionSetRepository; + + @GET + @Path("/") + @Produces(MediaType.APPLICATION_JSON) + public List getAnnotations( + @QueryParam("cohortId") final Long cohortId, + @QueryParam("subjectId") final Long subjectId, + @QueryParam("setId") final Long setId + ) { + + + if (cohortId != null && subjectId != null && setId != null) { + return annotationService.getAnnotationByCohortIdAndBySubjectIdAndBySetId(cohortId, subjectId, setId); + } + + return annotationService.getAnnotations(); + } + + @POST + @Path("/") + @Consumes(MediaType.APPLICATION_JSON) + @Produces(MediaType.APPLICATION_JSON) + public void addAnnotation(AnnotationDto annotationDto) { + + Annotation annotation = new Annotation(); + annotation.setId(annotationDto.getId()); + annotation.setSubjectId(annotationDto.getSubjectId()); + annotation.setCohortId(annotationDto.getCohortId()); + QuestionSet set = questionSetRepository.findById(annotationDto.getSetId()); + annotation.setSet(set); + + annotationDto.getResults().forEach((resultDto) -> { + Result result = new Result(); + result.setQuestionId(resultDto.getQuestionId()); + result.setAnswerId(resultDto.getAnswerId()); + result.setSetId(set.getId()); + result.setSubjectId(annotationDto.getSubjectId()); + result.setValue(resultDto.getValue()); + result.setType(resultDto.getType()); + result.setSampleName(annotationDto.getSampleName()); + annotation.addToResults(result); + }); + + annotationService.addAnnotation(annotation, annotationDto.getSampleName()); + } + + @Path("/csvData") + @GET + @Produces(MediaType.APPLICATION_JSON) + public List getAnnotationCSV( + @QueryParam("cohortID") Long cohortID, + @QueryParam("sourceKey") String sourceKey, + @QueryParam("sampleName") String sampleName + ) { + + if (sampleName.indexOf("_") != -1) { + sampleName = sampleName.replaceAll("_", " "); + } + + if (cohortID == null || sourceKey == null || sampleName == null) { + return null; + } + + return annotationService.getAnnotationCSVData(cohortID, sourceKey, sampleName); + + } +} diff --git a/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationDto.java b/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationDto.java new file mode 100644 index 0000000000..23996fba81 --- /dev/null +++ b/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationDto.java @@ -0,0 +1,102 @@ +package org.ohdsi.webapi.annotation.annotation; + +import java.util.HashSet; +import java.util.Set; +import org.ohdsi.webapi.annotation.result.ResultDto; + +public class AnnotationDto { + + private Long id; + private Long subjectId; + private Long cohortId; + private Long setId; + private String name; + private Set results = new HashSet(); + + //***** GETTERS/SETTERS ****** + + /** + * @return the id + */ + public Long getId() { + return id; + } + + /** + * @param id the id to set + */ + public void setId(Long id) { + this.id = id; + } + + /** + * @return the subjectId + */ + public Long getSubjectId() { + return subjectId; + } + + /** + * @param subjectId the subjectId to set + */ + public void setSubjectId(Long subjectId) { + this.subjectId = subjectId; + } + + /** + * @return the cohortId + */ + public Long getCohortId() { + return cohortId; + } + + /** + * @param cohortId the cohortId to set + */ + public void setCohortId(Long cohortId) { + this.cohortId = cohortId; + } + + /** + * @return the setId + */ + public Long getSetId() { + return setId; + } + + /** + * @param setId the setId to set + */ + public void setSetId(Long setId) { + this.setId = setId; + } + + /** + * @return the results + */ + public Set getResults() { + return new HashSet(results); + } + + /** + * @param results the results to set + */ + protected void setResults(Set results) { + this.results = results; + } + + /** + * @return the sample name + */ + public String getSampleName() { + return name; + } + + /** + * @param name to the slected sample name + */ + public void setSampleName(String name) { + this.name = name; + } + +} diff --git a/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationRepository.java b/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationRepository.java new file mode 100644 index 0000000000..e972fba1b6 --- /dev/null +++ b/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationRepository.java @@ -0,0 +1,13 @@ +package org.ohdsi.webapi.annotation.annotation; + +import org.springframework.data.jpa.repository.JpaRepository; +import java.util.List; +import java.util.Set; +import org.ohdsi.webapi.annotation.annotation.Annotation; + +public interface AnnotationRepository extends JpaRepository { + + public Set findOneByCohortIdAndSubjectIdAndSetId(Long cohortId, Long subjectId, Long setId); + public List findByCohortIdAndSetId(Long cohortId, Long setId); + +} diff --git a/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationService.java b/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationService.java new file mode 100644 index 0000000000..fb76c26656 --- /dev/null +++ b/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationService.java @@ -0,0 +1,98 @@ +package org.ohdsi.webapi.annotation.annotation; + +import org.springframework.stereotype.Service; +import org.springframework.beans.factory.annotation.Autowired; +import java.util.ArrayList; +import java.util.List; +import java.util.Set; +import org.ohdsi.webapi.annotation.annotation.AnnotationRepository; +import org.ohdsi.webapi.annotation.set.QuestionSet; +import org.ohdsi.webapi.annotation.question.Question; +import org.ohdsi.webapi.annotation.result.Result; +import org.ohdsi.webapi.annotation.result.ResultRepository; +import org.ohdsi.webapi.annotation.set.QuestionSetRepository; +// import org.aspectj.weaver.patterns.TypePatternQuestions.Question; +import org.ohdsi.webapi.annotation.annotation.Annotation; +import org.ohdsi.webapi.cohortsample.CohortSampleRepository; +import org.ohdsi.webapi.cohortsample.Sample; + + +@Service +public class AnnotationService { + + @Autowired + private AnnotationRepository annotationRepository; + + @Autowired + private CohortSampleRepository cohortSampleRepository; + + @Autowired + private QuestionSetRepository questionSetRepository; + + @Autowired + private ResultRepository resultRepository; + + public List getAnnotations() { + List annotations = new ArrayList(); + annotationRepository.findAll() + .forEach(annotations::add); + return annotations; + } + + public List getAnnotationByCohortIdAndBySubjectIdAndBySetId(Long cohortId, Long subjectId, Long setId) { + List annotations = new ArrayList(); + annotationRepository.findOneByCohortIdAndSubjectIdAndSetId(cohortId, subjectId, setId) + .forEach(annotations::add); + return annotations; + } + + public List getAnnotationByCohortIdAndBySetId(Long cohortId, Long setId) { + List annotations = new ArrayList(); + annotationRepository.findByCohortIdAndSetId(cohortId, setId) + .forEach(annotations::add); + return annotations; + } + + public Annotation addAnnotation(Annotation annotation, String name) { + cohortSampleRepository.annotated(name, annotation.getSubjectId(), annotation.getCohortId()); + return annotationRepository.save(annotation); + } + + public List getAnnotationCSVData(Long cohortID, String source, String sampleName) { + List results = new ArrayList(); + List samples = cohortSampleRepository.getSampleMembership(sampleName, cohortID); + Set questionSet = questionSetRepository.findByCohortId(cohortID.intValue()); + List qs = new ArrayList(questionSet); + List qIDs = new ArrayList(); + + for (Question q: qs.get(0).getQuestions()) { + qIDs.add(q.getId()); + } + + Object[] metaData = new Object[3]; + metaData[0] = source; + metaData[1] = cohortID; + metaData[2] = questionSet; + + results.add(metaData); + + + for (int i = 0; i answers = new ArrayList<>(); + for (int j = 0; j < qIDs.size(); j++) { + answers.add(resultRepository.getAnswers(sampleName, qIDs.get(j), samples.get(i))); + } + + row[1] = answers; + + + results.add(row); + } + + return results; + } + +} diff --git a/src/main/java/org/ohdsi/webapi/annotation/answer/Answer.java b/src/main/java/org/ohdsi/webapi/annotation/answer/Answer.java new file mode 100644 index 0000000000..f3ad65870c --- /dev/null +++ b/src/main/java/org/ohdsi/webapi/annotation/answer/Answer.java @@ -0,0 +1,109 @@ +package org.ohdsi.webapi.annotation.answer; + +import javax.persistence.Column; +import javax.persistence.Entity; +import javax.persistence.Id; +import javax.persistence.Table; +import javax.persistence.ManyToOne; +import javax.persistence.FetchType; +import javax.persistence.GeneratedValue; +import javax.persistence.JoinColumn; +import org.ohdsi.webapi.annotation.question.Question; +import com.fasterxml.jackson.annotation.JsonIgnore; + + +@Entity(name = "Answer") +@Table(name = "annotation_answer") +public class Answer { + + @Id + @GeneratedValue + @Column(name = "answer_id") + private Long id; + + @JsonIgnore + @ManyToOne(fetch = FetchType.LAZY) + @JoinColumn(name = "question_id") + private Question question; + + @Column(name = "text") + private String text; + + @Column(name = "value") + private String value; + + @Column(name = "help_text") + private String helpText; + + //***** GETTERS/SETTERS ****** + + /** + * @return the id + */ + public Long getId() { + return id; + } + + /** + * @param id the id to set + */ + public void setId(Long id) { + this.id = id; + } + + /** + * @return the question + */ + public Question getQuestion() { + return question; + } + + /** + * @param question the question to set + */ + public void setQuestion(Question question) { + this.question = question; + } + + /** + * @return the text + */ + public String getText() { + return text; + } + + /** + * @param text the text to set + */ + public void setText(String text) { + this.text = text; + } + + /** + * @return the value + */ + public String getValue() { + return value; + } + + /** + * @param value the value to set + */ + public void setValue(String value) { + this.value = value; + } + + /** + * @return the helpText + */ + public String getHelpText() { + return helpText; + } + + /** + * @param helpText the helpText to set + */ + public void setHelpText(String helpText) { + this.helpText = helpText; + } +} diff --git a/src/main/java/org/ohdsi/webapi/annotation/answer/AnswerController.java b/src/main/java/org/ohdsi/webapi/annotation/answer/AnswerController.java new file mode 100644 index 0000000000..f85f7b84fd --- /dev/null +++ b/src/main/java/org/ohdsi/webapi/annotation/answer/AnswerController.java @@ -0,0 +1,27 @@ +package org.ohdsi.webapi.annotation.answer; + +import javax.ws.rs.POST; +import javax.ws.rs.Path; +import javax.ws.rs.Consumes; +import javax.ws.rs.Produces; +import javax.ws.rs.core.MediaType; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.stereotype.Component; +import org.ohdsi.webapi.annotation.answer.AnswerService; +import org.ohdsi.webapi.annotation.answer.Answer; + +@Path("annotation/") +@Component +public class AnswerController { + + @Autowired + private AnswerService answerService; + + @POST + @Path("answers") + @Consumes(MediaType.APPLICATION_JSON) + @Produces(MediaType.APPLICATION_JSON) + public void addQuestion(Answer answer) { + answerService.addAnswer(answer); + } +} diff --git a/src/main/java/org/ohdsi/webapi/annotation/answer/AnswerRepository.java b/src/main/java/org/ohdsi/webapi/annotation/answer/AnswerRepository.java new file mode 100644 index 0000000000..65157ed9d2 --- /dev/null +++ b/src/main/java/org/ohdsi/webapi/annotation/answer/AnswerRepository.java @@ -0,0 +1,6 @@ +package org.ohdsi.webapi.annotation.answer; + +import org.springframework.data.jpa.repository.JpaRepository; +import org.ohdsi.webapi.annotation.answer.Answer; + +public interface AnswerRepository extends JpaRepository {} diff --git a/src/main/java/org/ohdsi/webapi/annotation/answer/AnswerService.java b/src/main/java/org/ohdsi/webapi/annotation/answer/AnswerService.java new file mode 100644 index 0000000000..b2cf3db7b8 --- /dev/null +++ b/src/main/java/org/ohdsi/webapi/annotation/answer/AnswerService.java @@ -0,0 +1,18 @@ +package org.ohdsi.webapi.annotation.answer; + +import org.springframework.stereotype.Service; +import org.springframework.beans.factory.annotation.Autowired; +import org.ohdsi.webapi.annotation.answer.AnswerRepository; +import org.ohdsi.webapi.annotation.answer.Answer; + +@Service +public class AnswerService { + + @Autowired + private AnswerRepository answerRepository; + + public void addAnswer(Answer answer) { + answerRepository.save(answer); + } + +} diff --git a/src/main/java/org/ohdsi/webapi/annotation/navigation/Navigation.java b/src/main/java/org/ohdsi/webapi/annotation/navigation/Navigation.java new file mode 100644 index 0000000000..32b7a80a24 --- /dev/null +++ b/src/main/java/org/ohdsi/webapi/annotation/navigation/Navigation.java @@ -0,0 +1,83 @@ +package org.ohdsi.webapi.annotation.navigation; +import java.util.List; +public class Navigation { + + private Long prevSubjectId; + private Long nextSubjectId; + private Long nextUnannotatedSubjectId; + private int numProfileSamples; + private int numAnnotations; + + //***** GETTERS/SETTERS ****** + + /** + * @return the prevSubjectId + */ + public Long getPrevSubjectId() { + return prevSubjectId; + } + + /** + * @param prevSubjectId the prevSubjectId to set + */ + public void setPrevSubjectId(Long prevSubjectId) { + this.prevSubjectId = prevSubjectId; + } + + /** + * @return the nextSubjectId + */ + public Long getNextSubjectId() { + return nextSubjectId; + } + + /** + * @param nextSubjectId the nextSubjectId to set + */ + public void setNextSubjectId(Long nextSubjectId) { + this.nextSubjectId = nextSubjectId; + } + + /** + * @return the nextUnannotatedSubjectId + */ + public Long getNextUnannotatedSubjectId() { + return nextUnannotatedSubjectId; + } + + /** + * @param nextUnannotatedSubjectId the nextUnannotatedSubjectId to set + */ + public void setNextUnannotatedSubjectId(Long nextUnannotatedSubjectId) { + this.nextUnannotatedSubjectId = nextUnannotatedSubjectId; + } + + /** + * @return the numProfileSamples + */ + public int getNumProfileSamples() { + return numProfileSamples; + } + + /** + * @param numProfileSamples the numProfileSamples to set + */ + public void setNumProfileSamples(int numProfileSamples) { + this.numProfileSamples = numProfileSamples; + } + + /** + * @return the numAnnotations + */ + public int getNumAnnotations() { + return numAnnotations; + } + + /** + * @param numAnnotations the numAnnotations to set + */ + public void setNumAnnotations(int numAnnotations) { + this.numAnnotations = numAnnotations; + } + +} diff --git a/src/main/java/org/ohdsi/webapi/annotation/navigation/NavigationController.java b/src/main/java/org/ohdsi/webapi/annotation/navigation/NavigationController.java new file mode 100644 index 0000000000..2bfeafbc22 --- /dev/null +++ b/src/main/java/org/ohdsi/webapi/annotation/navigation/NavigationController.java @@ -0,0 +1,52 @@ +package org.ohdsi.webapi.annotation.navigation; + +import java.util.List; +import javax.ws.rs.GET; +import javax.ws.rs.Path; +import javax.ws.rs.Consumes; +import javax.ws.rs.Produces; +import javax.ws.rs.core.MediaType; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.stereotype.Component; +import org.ohdsi.webapi.cohortresults.ProfileSampleRecord; +import javax.ws.rs.QueryParam; +import org.ohdsi.webapi.source.Source; +import org.ohdsi.webapi.service.AbstractDaoService; +import org.ohdsi.webapi.cohortresults.*; +import javax.annotation.PostConstruct; +import org.ohdsi.webapi.annotation.annotation.AnnotationService; +import com.fasterxml.jackson.databind.ObjectMapper; + +@Path("annotations/") +@Component +public class NavigationController extends AbstractDaoService { + + @Autowired + private VisualizationDataRepository visualizationDataRepository; + + @Autowired + private AnnotationService annotationService; + + + @Autowired + private NavigationService ns; + + private CohortResultsAnalysisRunner queryRunner = null; + + + @GET + @Path("navigation") + @Produces(MediaType.APPLICATION_JSON) + public Navigation getNavigation( + @QueryParam("cohortId") final int cohortId, + @QueryParam("subjectId") final Long subjectId, + @QueryParam("sampleName") final String sampleName, + @QueryParam("sourceKey") final String sourceKey + ) { + Source source = getSourceRepository().findBySourceKey(sourceKey); + Navigation nav = ns.navData(new Navigation(), subjectId, sampleName, cohortId, source); + + return nav; + } + +} diff --git a/src/main/java/org/ohdsi/webapi/annotation/navigation/NavigationService.java b/src/main/java/org/ohdsi/webapi/annotation/navigation/NavigationService.java new file mode 100644 index 0000000000..b73266e167 --- /dev/null +++ b/src/main/java/org/ohdsi/webapi/annotation/navigation/NavigationService.java @@ -0,0 +1,60 @@ +package org.ohdsi.webapi.annotation.navigation; + +import java.util.Collection; +import org.ohdsi.webapi.util.PreparedStatementRenderer; +import static org.ohdsi.webapi.util.SecurityUtils.whitelist; +import org.springframework.jdbc.core.RowMapper; +import org.ohdsi.webapi.source.SourceDaimon; +import org.ohdsi.webapi.util.SessionUtils; +import org.ohdsi.webapi.source.Source; +import java.util.List; +import java.util.ArrayList; +import org.springframework.stereotype.Service; +import org.ohdsi.webapi.cohortsample.CohortSampleRepository; +import org.springframework.beans.factory.annotation.Autowired; +import java.sql.ResultSet; +import java.sql.SQLException; +import org.ohdsi.webapi.service.AbstractDaoService; +import org.ohdsi.webapi.annotation.navigation.Navigation; +import org.ohdsi.webapi.cohortsample.CohortSample; + + + + +@Service +public class NavigationService extends AbstractDaoService { + private final String BASE_SQL_PATH = "/resources/navigation/"; + + @Autowired + private CohortSampleRepository cohortSampleRepository; + + + public Navigation navData(Navigation nav, Long subjectId, String sampleName, int cohortId, Source source) + { + if (sampleName.indexOf("_") != -1) { + sampleName = sampleName.replaceAll("_", " "); + } + List sample = cohortSampleRepository.getNavSample(sampleName); + int annCount = 0; + boolean foundNext = false; + for(int i = 0; i < sample.size(); i++) { + if((long) sample.get(i)[0] == subjectId) { + nav.setPrevSubjectId(i == 0 ? (long) sample.get(sample.size() - 1)[0] : (long) sample.get(i-1)[0]); + nav.setNextSubjectId(sample.size() == i + 1 ? (long) sample.get(0)[0] : (long) sample.get(i+1)[0]); + } + if ((boolean) sample.get(i)[1] == true) { + annCount++; + } + if (!foundNext && (boolean) sample.get(i)[1] == true) { + nav.setNextUnannotatedSubjectId((long) sample.get(i)[0]); + foundNext = true; + } + + } + nav.setNumProfileSamples(sample.size()); + nav.setNumAnnotations(annCount); + System.out.println(nav.getNumAnnotations()); + return nav; + } + +} \ No newline at end of file diff --git a/src/main/java/org/ohdsi/webapi/annotation/question/Question.java b/src/main/java/org/ohdsi/webapi/annotation/question/Question.java new file mode 100644 index 0000000000..ece372b9a4 --- /dev/null +++ b/src/main/java/org/ohdsi/webapi/annotation/question/Question.java @@ -0,0 +1,174 @@ +package org.ohdsi.webapi.annotation.question; + +import java.util.List; +import java.util.ArrayList; +import javax.persistence.Column; +import javax.persistence.Entity; +import javax.persistence.GeneratedValue; +import javax.persistence.CascadeType; +import javax.persistence.FetchType; +import javax.persistence.OneToMany; +import javax.persistence.ManyToOne; +import javax.persistence.JoinColumn; +import javax.persistence.Id; +import javax.persistence.Table; +import org.ohdsi.webapi.annotation.answer.Answer; +import org.ohdsi.webapi.annotation.set.QuestionSet; +import com.fasterxml.jackson.annotation.JsonIgnore; + +@Entity(name = "Question") +@Table(name = "annotation_question") +public class Question { + + @Id + @GeneratedValue + @Column(name = "question_id") + private Long id; + + @Column(name = "question_name") + private String text; + + @Column(name = "question_type") + private String type; + + @Column(name = "help_text") + private String helpText; + + @Column(name = "case_question") + private Boolean caseQuestion = false; + + @Column(name = "required") + private Boolean required = true; + + @JsonIgnore + @ManyToOne + @JoinColumn(name = "set_id") + private QuestionSet set; + + @OneToMany( + fetch = FetchType.EAGER, + mappedBy = "question", + cascade = CascadeType.ALL, + orphanRemoval = true + ) + private List answers = new ArrayList<>(); + + //***** GETTERS/SETTERS ****** + + /** + * @return the id + */ + public Long getId() { + return id; + } + + /** + * @param id the id to set + */ + public void setId(Long id) { + this.id = id; + } + + /** + * @return the text + */ + public String getText() { + return text; + } + + /** + * @param text the text to set + */ + public void setText(String text) { + this.text = text; + } + + /** + * @return the type + */ + public String getType() { + return type; + } + + /** + * @param type the type to set + */ + public void setType(String type) { + this.type = type; + } + + /** + * @return the helpText + */ + public String getHelpText() { + return helpText; + } + + /** + * @param helpText the helpText to set + */ + public void setHelpText(String helpText) { + this.helpText = helpText; + } + + /** + * @return the set + */ + public QuestionSet getSet() { + return set; + } + + /** + * @param set the set to set + */ + public void setSet(QuestionSet set) { + this.set = set; + } + + /** + * @return the answers + */ + public List getAnswers() { + return new ArrayList(answers); + } + + /** + * @param answers the answers to set + */ + protected void setAnswers(List answers) { + this.answers = answers; + } + + public void addToAnswers(Answer answer) { + answer.setQuestion(this); + this.answers.add(answer); + } + + /** + * @return caseQuestion + */ + public Boolean getCaseQuestion() { + return caseQuestion; + } + + /** + * @param caseQuestion caseQuestion to set + */ + public void setCaseQuestion(Boolean caseQuestion) { + this.caseQuestion = caseQuestion; + } + + /** + * @return required + */ + public Boolean getRequired() { + return required; + } + + /** + * @param required required to set + */ + public void setRequired(Boolean required) { + this.required = required; + } +} diff --git a/src/main/java/org/ohdsi/webapi/annotation/question/QuestionController.java b/src/main/java/org/ohdsi/webapi/annotation/question/QuestionController.java new file mode 100644 index 0000000000..d2a0fea45a --- /dev/null +++ b/src/main/java/org/ohdsi/webapi/annotation/question/QuestionController.java @@ -0,0 +1,41 @@ +package org.ohdsi.webapi.annotation.question; + +import java.util.List; +import javax.ws.rs.GET; +import javax.ws.rs.POST; +import javax.ws.rs.Path; +import javax.ws.rs.Consumes; +import javax.ws.rs.Produces; +import javax.ws.rs.core.MediaType; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.stereotype.Component; +import org.ohdsi.webapi.annotation.question.QuestionService; +import org.ohdsi.webapi.annotation.question.Question; + +@Path("annotations/") +@Component +public class QuestionController { + + @Autowired + private QuestionService questionService; + + @GET + @Path("questions") + @Produces(MediaType.APPLICATION_JSON) + public List getAllQuestions() { + return questionService.getAllQuestions(); + } + + @POST + @Path("questions") + @Consumes(MediaType.APPLICATION_JSON) + @Produces(MediaType.APPLICATION_JSON) + public void addQuestion(Question question) { + + question.getAnswers().forEach((answer) -> { + question.addToAnswers(answer); + }); + + questionService.addQuestion(question); + } +} diff --git a/src/main/java/org/ohdsi/webapi/annotation/question/QuestionRepository.java b/src/main/java/org/ohdsi/webapi/annotation/question/QuestionRepository.java new file mode 100644 index 0000000000..b381a69fff --- /dev/null +++ b/src/main/java/org/ohdsi/webapi/annotation/question/QuestionRepository.java @@ -0,0 +1,6 @@ +package org.ohdsi.webapi.annotation.question; + +import org.springframework.data.jpa.repository.JpaRepository; +import org.ohdsi.webapi.annotation.question.Question; + +public interface QuestionRepository extends JpaRepository {} diff --git a/src/main/java/org/ohdsi/webapi/annotation/question/QuestionService.java b/src/main/java/org/ohdsi/webapi/annotation/question/QuestionService.java new file mode 100644 index 0000000000..35dd319063 --- /dev/null +++ b/src/main/java/org/ohdsi/webapi/annotation/question/QuestionService.java @@ -0,0 +1,27 @@ +package org.ohdsi.webapi.annotation.question; + +import org.springframework.stereotype.Service; +import org.springframework.beans.factory.annotation.Autowired; +import java.util.ArrayList; +import java.util.List; +import org.ohdsi.webapi.annotation.question.QuestionRepository; +import org.ohdsi.webapi.annotation.question.Question; + +@Service +public class QuestionService { + + @Autowired + private QuestionRepository questionRepository; + + public List getAllQuestions() { + List questions = new ArrayList(); + questionRepository.findAll() + .forEach(questions::add); + return questions; + } + + public void addQuestion(Question question) { + questionRepository.save(question); + } + +} diff --git a/src/main/java/org/ohdsi/webapi/annotation/result/Result.java b/src/main/java/org/ohdsi/webapi/annotation/result/Result.java new file mode 100644 index 0000000000..16a17257ee --- /dev/null +++ b/src/main/java/org/ohdsi/webapi/annotation/result/Result.java @@ -0,0 +1,177 @@ +package org.ohdsi.webapi.annotation.result; + +import javax.persistence.Column; +import javax.persistence.Entity; +import javax.persistence.Id; +import javax.persistence.Table; +import javax.persistence.ManyToOne; +import javax.persistence.FetchType; +import javax.persistence.GeneratedValue; +import javax.persistence.JoinColumn; +import org.ohdsi.webapi.annotation.annotation.Annotation; +import com.fasterxml.jackson.annotation.JsonIgnore; + +@Entity(name = "Result") +@Table(name = "annotation_result") +public class Result { + + @Id + @GeneratedValue + @Column(name = "result_id") + private Long id; + + @JsonIgnore + @ManyToOne(fetch = FetchType.LAZY) + @JoinColumn(name = "annotation_id") + private Annotation annotation; + + @JsonIgnore + @Column(name = "set_id") + private Long setId; + + @Column(name = "question_id") + private Long questionId; + + @Column(name = "answer_id") + private Long answerId; + + @Column(name = "sample_name") + private String sampleName; + + @JsonIgnore + @Column(name = "subject_id") + private Long subjectId; + + @Column(name = "value") + private String value; + + @Column(name = "type") + private String type; + + //***** GETTERS/SETTERS ****** + + /** + * @return the id + */ + public Long getId() { + return id; + } + + /** + * @param id the id to set + */ + public void setId(Long id) { + this.id = id; + } + + /** + * @return the annotation + */ + public Annotation getAnnotation() { + return annotation; + } + + /** + * @param annotation the annotation to set + */ + public void setAnnotation(Annotation annotation) { + this.annotation = annotation; + } + + /** + * @return the subjectId + */ + public Long getSubjectId() { + return subjectId; + } + + /** + * @param subjectId the subjectId to set + */ + public void setSubjectId(Long subjectId) { + this.subjectId = subjectId; + } + + /** + * @return the answerId + */ + public Long getAnswerId() { + return answerId; + } + + /** + * @param answerId the answerId to set + */ + public void setAnswerId(Long answerId) { + this.answerId = answerId; + } + + /** + * @return the setId + */ + public Long getSetId() { + return setId; + } + + /** + * @param setId the setId to set + */ + public void setSetId(Long setId) { + this.setId = setId; + } + + /** + * @return the questionId + */ + public Long getQuestionId() { + return questionId; + } + + /** + * @param questionId the questionId to set + */ + public void setQuestionId(Long questionId) { + this.questionId = questionId; + } + + /** + * @return the type + */ + public String getType() { + return type; + } + + /** + * @param type the type to set + */ + public void setType(String type) { + this.type = type; + } + + /** + * @return the value + */ + public String getValue() { + return value; + } + + /** + * @param value the value to set + */ + public void setValue(String value) { + this.value = value; + } + /** + * @return the type + */ + public String getSampleName() { + return sampleName; + } + + /** + * @param type the type to set + */ + public void setSampleName(String name) { + this.sampleName = name; + } +} diff --git a/src/main/java/org/ohdsi/webapi/annotation/result/ResultDto.java b/src/main/java/org/ohdsi/webapi/annotation/result/ResultDto.java new file mode 100644 index 0000000000..2fe3d2a231 --- /dev/null +++ b/src/main/java/org/ohdsi/webapi/annotation/result/ResultDto.java @@ -0,0 +1,82 @@ +package org.ohdsi.webapi.annotation.result; + +public class ResultDto { + + private Long answerId; + private Long questionId; + private String value; + private String type; + private String sampleName; + + //***** GETTERS/SETTERS ****** + + /** + * @return the answerId + */ + public Long getAnswerId() { + return answerId; + } + + /** + * @param answerId the answerId to set + */ + public void setAnswerId(Long answerId) { + this.answerId = answerId; + } + + /** + * @return the questionId + */ + public Long getQuestionId() { + return questionId; + } + + /** + * @param questionId the questionId to set + */ + public void setQuestionId(Long questionId) { + this.questionId = questionId; + } + + /** + * @return the value + */ + public String getValue() { + return value; + } + + /** + * @param value the value to set + */ + public void setValue(String value) { + this.value = value; + } + + /** + * @return the type + */ + public String getType() { + return type; + } + + /** + * @param type the type to set + */ + public void setType(String type) { + this.type = type; + } + + /** + * @return the type + */ + public String getSampleName() { + return sampleName; + } + + /** + * @param type the type to set + */ + public void setSampleName(String name) { + this.sampleName = name; + } +} diff --git a/src/main/java/org/ohdsi/webapi/annotation/result/ResultRepository.java b/src/main/java/org/ohdsi/webapi/annotation/result/ResultRepository.java new file mode 100644 index 0000000000..616e3c9326 --- /dev/null +++ b/src/main/java/org/ohdsi/webapi/annotation/result/ResultRepository.java @@ -0,0 +1,15 @@ +package org.ohdsi.webapi.annotation.result; + +import org.springframework.data.jpa.repository.JpaRepository; +import org.ohdsi.webapi.annotation.result.Result; +import java.util.Set; +import org.springframework.transaction.annotation.Transactional; +import org.springframework.data.jpa.repository.Query; + +@Transactional +public interface ResultRepository extends JpaRepository { + public Set findBySampleNameAndSubjectId(String sampleName, Long subject_id); + + @Query("select s.value from Result s where s.sampleName=?1 and s.questionId = ?2 and s.subjectId=?3") + public Set getAnswers(String name, Long cohortID, Long subjectID); +} diff --git a/src/main/java/org/ohdsi/webapi/annotation/set/QuestionSet.java b/src/main/java/org/ohdsi/webapi/annotation/set/QuestionSet.java new file mode 100644 index 0000000000..c80584949f --- /dev/null +++ b/src/main/java/org/ohdsi/webapi/annotation/set/QuestionSet.java @@ -0,0 +1,135 @@ +package org.ohdsi.webapi.annotation.set; + +import java.util.HashSet; +import java.util.Set; +import javax.persistence.Column; +import javax.persistence.Entity; +import javax.persistence.GeneratedValue; +import javax.persistence.CascadeType; +import javax.persistence.FetchType; +import javax.persistence.OneToMany; +import javax.persistence.Id; +import javax.persistence.Table; +import org.ohdsi.webapi.annotation.question.Question; + +@Entity(name = "QuestionSet") +@Table(name = "annotation_set") +public class QuestionSet { + + @Id + @GeneratedValue + @Column(name = "set_id") + private Long id; + + @Column(name = "cohort_name") + private String cohortName; + + @Column(name = "cohort_source") + private String cohortSource; + + @Column(name = "cohort_id") + private int cohortId; + + private String name; + + @OneToMany( + fetch = FetchType.EAGER, + mappedBy = "set", + cascade = CascadeType.ALL, + orphanRemoval = true + ) + private Set questions = new HashSet(); + + //***** GETTERS/SETTERS ****** + + /** + * @return the id + */ + public Long getId() { + return id; + } + + /** + * @param id the id to set + */ + public void setId(Long id) { + this.id = id; + } + + /** + * @return the cohortName + */ + public String getCohortName() { + return cohortName; + } + + /** + * @param cohortName the cohortName to set + */ + public void setCohortName(String cohortName) { + this.cohortName = cohortName; + } + + /** + * @return the cohortSource + */ + public String getCohortSource() { + return cohortSource; + } + + /** + * @param cohortSource the cohortSource to set + */ + public void setCohortSource(String cohortSource) { + this.cohortSource = cohortSource; + } + + /** + * @return the cohortId + */ + public int getCohortId() { + return cohortId; + } + + /** + * @param cohortId the cohortId to set + */ + public void setCohortId(int cohortId) { + this.cohortId = cohortId; + } + + + /** + * @return the name + */ + public String getName() { + return name; + } + + /** + * @param name the name to set + */ + public void setName(String name) { + this.name = name; + } + + /** + * @return the questions + */ + public Set getQuestions() { + return new HashSet(questions); + } + + /** + * @param questions the questions to set + */ + protected void setQuestions(Set questions) { + this.questions = questions; + } + + public void addToQuestions(Question question) { + question.setSet(this); + this.questions.add(question); + } + +} diff --git a/src/main/java/org/ohdsi/webapi/annotation/set/QuestionSetController.java b/src/main/java/org/ohdsi/webapi/annotation/set/QuestionSetController.java new file mode 100644 index 0000000000..f5b7fc0b5d --- /dev/null +++ b/src/main/java/org/ohdsi/webapi/annotation/set/QuestionSetController.java @@ -0,0 +1,50 @@ +package org.ohdsi.webapi.annotation.set; + +import java.util.List; +import javax.ws.rs.GET; +import javax.ws.rs.POST; +import javax.ws.rs.Path; +import javax.ws.rs.Consumes; +import javax.ws.rs.Produces; +import javax.ws.rs.core.MediaType; +import javax.ws.rs.QueryParam; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.stereotype.Component; +import org.ohdsi.webapi.annotation.set.QuestionSetService; +import org.ohdsi.webapi.annotation.set.QuestionSet; + +@Path("annotations/") +@Component +public class QuestionSetController { + + @Autowired + private QuestionSetService questionSetService; + + @GET + @Path("sets") + @Produces(MediaType.APPLICATION_JSON) + public List getSets(@QueryParam("cohortId") final Integer cohortId) { + + if (cohortId != null) { + return questionSetService.getSetsByCohortId(cohortId); + } + + return questionSetService.getSets(); + } + + @POST + @Path("sets") + @Consumes(MediaType.APPLICATION_JSON) + @Produces(MediaType.APPLICATION_JSON) + public void addSet(QuestionSet set) { + + set.getQuestions().forEach((question) -> { + set.addToQuestions(question); + question.getAnswers().forEach((answer) -> { + question.addToAnswers(answer); + }); + }); + + questionSetService.addSet(set); + } +} diff --git a/src/main/java/org/ohdsi/webapi/annotation/set/QuestionSetRepository.java b/src/main/java/org/ohdsi/webapi/annotation/set/QuestionSetRepository.java new file mode 100644 index 0000000000..063c048821 --- /dev/null +++ b/src/main/java/org/ohdsi/webapi/annotation/set/QuestionSetRepository.java @@ -0,0 +1,13 @@ +package org.ohdsi.webapi.annotation.set; + +import org.springframework.data.jpa.repository.JpaRepository; +import java.util.Set; +import org.ohdsi.webapi.annotation.set.QuestionSet; + + +public interface QuestionSetRepository extends JpaRepository { + + public Set findByCohortId(Integer cohortId); + public QuestionSet findById(Long id); + +} diff --git a/src/main/java/org/ohdsi/webapi/annotation/set/QuestionSetService.java b/src/main/java/org/ohdsi/webapi/annotation/set/QuestionSetService.java new file mode 100644 index 0000000000..457a7a38a5 --- /dev/null +++ b/src/main/java/org/ohdsi/webapi/annotation/set/QuestionSetService.java @@ -0,0 +1,34 @@ +package org.ohdsi.webapi.annotation.set; + +import org.springframework.stereotype.Service; +import org.springframework.beans.factory.annotation.Autowired; +import java.util.ArrayList; +import java.util.List; +import org.ohdsi.webapi.annotation.set.QuestionSetRepository; +import org.ohdsi.webapi.annotation.set.QuestionSet; + +@Service +public class QuestionSetService { + + @Autowired + private QuestionSetRepository questionSetRepository; + + public List getSets() { + List sets = new ArrayList(); + questionSetRepository.findAll() + .forEach(sets::add); + return sets; + } + + public List getSetsByCohortId(Integer cohortId) { + List sets = new ArrayList(); + questionSetRepository.findByCohortId(cohortId) + .forEach(sets::add); + return sets; + } + + public void addSet(QuestionSet set) { + questionSetRepository.save(set); + } + +} diff --git a/src/main/java/org/ohdsi/webapi/cohortsample/CohortSample.java b/src/main/java/org/ohdsi/webapi/cohortsample/CohortSample.java index a5a105603c..7350d2141b 100644 --- a/src/main/java/org/ohdsi/webapi/cohortsample/CohortSample.java +++ b/src/main/java/org/ohdsi/webapi/cohortsample/CohortSample.java @@ -53,6 +53,9 @@ public class CohortSample extends CommonEntity { @Column(name = "\"size\"") private int size; + + @Column(name = "annotated") + private boolean annotated; @Transient private List elements; @@ -136,4 +139,9 @@ public String getAgeMode() { public void setAgeMode(String ageMode) { this.ageMode = ageMode; } + + public boolean setAnnotated() { + return annotated; + } + } diff --git a/src/main/resources/db/migration/postgresql/V2.5.1__annotation.sql b/src/main/resources/db/migration/postgresql/V2.5.1__annotation.sql new file mode 100644 index 0000000000..7a15054c6d --- /dev/null +++ b/src/main/resources/db/migration/postgresql/V2.5.1__annotation.sql @@ -0,0 +1,93 @@ +CREATE TABLE annotation_set ( + set_id integer NOT NULL, + cohort_name character varying(150) NOT NULL, + cohort_source character varying(25) NOT NULL, + cohort_id integer NOT NULL, + name character varying(150) NOT NULL, + -- date_created date NOT NULL, + -- date_updated date, + CONSTRAINT annotation_set_pkey PRIMARY KEY (set_id) +); + +ALTER TABLE annotation_set OWNER TO ohdsi_admin; + +CREATE TABLE annotation ( + annotation_id integer NOT NULL, + subject_id integer NOT NULL, + cohort_id integer NOT NULL, + set_id integer NOT NULL, + user_id integer, + CONSTRAINT annotation_pkey PRIMARY KEY (annotation_id), + CONSTRAINT annotation_set_fk FOREIGN KEY (set_id) REFERENCES annotation_set(set_id), + CONSTRAINT unq_subject_cohort_set UNIQUE(subject_id, cohort_id, set_id) +); + +ALTER TABLE annotation OWNER TO ohdsi_admin; + + +CREATE TABLE annotation_question ( + question_id integer NOT NULL, + set_id integer NOT NULL, + question_name character varying(250) NOT NULL, + question_type character varying(25) NOT NULL, + required Boolean NOT NULL, + case_question Boolean NOT NULL, + help_text text, + -- date_created date NOT NULL, + -- date_updated date, + CONSTRAINT annotation_questions_pkey PRIMARY KEY (question_id), + CONSTRAINT annotation_question_set_fk FOREIGN KEY (set_id) REFERENCES annotation_set(set_id) +); + +ALTER TABLE annotation_question OWNER TO ohdsi_admin; + + +CREATE TABLE annotation_answer ( + answer_id integer NOT NULL, + question_id integer NOT NULL, + -- set_id integer NOT NULL, + text character varying(250) NOT NULL, + value character varying(250) NOT NULL, + help_text text, + -- date_created date NOT NULL, + -- date_updated date, + CONSTRAINT annotation_answer_pkey PRIMARY KEY (answer_id), + CONSTRAINT annotation_answer_fk FOREIGN KEY (question_id) REFERENCES annotation_question(question_id) + -- CONSTRAINT annotation_answer_set_fk FOREIGN KEY (set_id) REFERENCES annotation_set(set_id) +); + +ALTER TABLE annotation_answer OWNER TO ohdsi_admin; + + +CREATE TABLE annotation_result ( + result_id integer NOT NULL, + annotation_id integer NOT NULL, + set_id integer NOT NULL, + question_id integer NOT NULL, + answer_id bigint NOT NULL, + subject_id integer NOT NULL, + sample_name character varying(100) NOT NULL, + value character varying(250) NOT NULL, + type character varying(50) NOT NULL, + -- author_id integer NOT NULL, + -- date_reviewed date NOT NULL, + CONSTRAINT annotation_result_pkey PRIMARY KEY (result_id), + CONSTRAINT annotation_result_question_fk FOREIGN KEY (question_id) + REFERENCES annotation_question (question_id) MATCH SIMPLE + ON UPDATE NO ACTION + ON DELETE NO ACTION, + -- CONSTRAINT annotation_result_author_fk FOREIGN KEY (author_id) + -- REFERENCES annotation_author (author_id) MATCH SIMPLE + -- ON UPDATE NO ACTION + -- ON DELETE NO ACTION, + CONSTRAINT annotation_result_as_fk FOREIGN KEY (set_id) + REFERENCES annotation_set(set_id) + ON UPDATE NO ACTION + ON DELETE NO ACTION, + CONSTRAINT annotation_result_ans_fk FOREIGN KEY (answer_id) + REFERENCES annotation_answer(answer_id) + ON UPDATE NO ACTION + ON DELETE NO ACTION +); + +ALTER TABLE annotation_result OWNER TO ohdsi_admin; From 6735945cb0bcf5babd143e5cdb178a6eda86405c Mon Sep 17 00:00:00 2001 From: Saul Crumpton Date: Tue, 2 Mar 2021 11:03:42 -0500 Subject: [PATCH 02/55] updating annotation code to test build. --- .../webapi/annotation/annotation/AnnotationService.java | 8 +++++--- .../webapi/annotation/navigation/NavigationService.java | 6 ++++-- 2 files changed, 9 insertions(+), 5 deletions(-) diff --git a/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationService.java b/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationService.java index fb76c26656..14cd4b7bf3 100644 --- a/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationService.java +++ b/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationService.java @@ -14,7 +14,7 @@ // import org.aspectj.weaver.patterns.TypePatternQuestions.Question; import org.ohdsi.webapi.annotation.annotation.Annotation; import org.ohdsi.webapi.cohortsample.CohortSampleRepository; -import org.ohdsi.webapi.cohortsample.Sample; +import org.ohdsi.webapi.cohortsample.CohortSample; @Service @@ -54,13 +54,15 @@ public List getAnnotationByCohortIdAndBySetId(Long cohortId, Long se } public Annotation addAnnotation(Annotation annotation, String name) { - cohortSampleRepository.annotated(name, annotation.getSubjectId(), annotation.getCohortId()); +// cohortSampleRepository.annotated(name, annotation.getSubjectId(), annotation.getCohortId()); +// TODO implement above function and getSampleMembership return annotationRepository.save(annotation); } public List getAnnotationCSVData(Long cohortID, String source, String sampleName) { List results = new ArrayList(); - List samples = cohortSampleRepository.getSampleMembership(sampleName, cohortID); +// List samples = cohortSampleRepository.getSampleMembership(sampleName, cohortID); + List samples = new ArrayList(); Set questionSet = questionSetRepository.findByCohortId(cohortID.intValue()); List qs = new ArrayList(questionSet); List qIDs = new ArrayList(); diff --git a/src/main/java/org/ohdsi/webapi/annotation/navigation/NavigationService.java b/src/main/java/org/ohdsi/webapi/annotation/navigation/NavigationService.java index b73266e167..1b00f53bae 100644 --- a/src/main/java/org/ohdsi/webapi/annotation/navigation/NavigationService.java +++ b/src/main/java/org/ohdsi/webapi/annotation/navigation/NavigationService.java @@ -34,7 +34,9 @@ public Navigation navData(Navigation nav, Long subjectId, String sampleName, int if (sampleName.indexOf("_") != -1) { sampleName = sampleName.replaceAll("_", " "); } - List sample = cohortSampleRepository.getNavSample(sampleName); +// List sample = cohortSampleRepository.getNavSample(sampleName); +// TODO impmlement above funtion + List sample = new ArrayList(); int annCount = 0; boolean foundNext = false; for(int i = 0; i < sample.size(); i++) { @@ -57,4 +59,4 @@ public Navigation navData(Navigation nav, Long subjectId, String sampleName, int return nav; } -} \ No newline at end of file +} From f1203ec2f06e6b59bd4d788ab14c4c52d016b1ec Mon Sep 17 00:00:00 2001 From: "Duke, Jon D" Date: Wed, 31 Mar 2021 15:13:36 -0400 Subject: [PATCH 03/55] New Annotation Tables --- .../annotation/annotation/Annotation.java | 12 +-- .../annotation/AnnotationController.java | 8 +- .../annotation/annotation/AnnotationDto.java | 12 +-- .../webapi/annotation/result/Result.java | 9 +- .../webapi/annotation/set/QuestionSet.java | 36 +------ .../postgresql/V2.5.1__annotation.sql | 102 ++++++------------ .../ddl/results/annotation_result.sql | 9 ++ 7 files changed, 66 insertions(+), 122 deletions(-) create mode 100644 src/main/resources/ddl/results/annotation_result.sql diff --git a/src/main/java/org/ohdsi/webapi/annotation/annotation/Annotation.java b/src/main/java/org/ohdsi/webapi/annotation/annotation/Annotation.java index e615fe9b07..565fc67d4a 100644 --- a/src/main/java/org/ohdsi/webapi/annotation/annotation/Annotation.java +++ b/src/main/java/org/ohdsi/webapi/annotation/annotation/Annotation.java @@ -30,8 +30,8 @@ public class Annotation { @Column(name = "subject_id") private Long subjectId; - @Column(name = "cohort_id") - private Long cohortId; + @Column(name = "cohort_sample_id") + private Long cohortSampleId; // @Column(name = "sample_name") // private String sampleName; @@ -82,15 +82,15 @@ public void setSubjectId(Long subjectId) { /** * @return the cohortId */ - public Long getCohortId() { - return cohortId; + public Long getCohortSampleId() { + return cohortSampleId; } /** * @param cohortId the cohortId to set */ - public void setCohortId(Long cohortId) { - this.cohortId = cohortId; + public void setCohortSampleId(Long cohortSampleId) { + this.cohortSampleId = cohortSampleId; } /** diff --git a/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationController.java b/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationController.java index 07137cf662..0963e06574 100644 --- a/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationController.java +++ b/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationController.java @@ -55,7 +55,7 @@ public void addAnnotation(AnnotationDto annotationDto) { Annotation annotation = new Annotation(); annotation.setId(annotationDto.getId()); annotation.setSubjectId(annotationDto.getSubjectId()); - annotation.setCohortId(annotationDto.getCohortId()); + annotation.setCohortSampleId(annotationDto.getCohortSampleId()); QuestionSet set = questionSetRepository.findById(annotationDto.getSetId()); annotation.setSet(set); @@ -75,10 +75,10 @@ public void addAnnotation(AnnotationDto annotationDto) { } @Path("/csvData") - @GET + @GET @Produces(MediaType.APPLICATION_JSON) public List getAnnotationCSV( - @QueryParam("cohortID") Long cohortID, + @QueryParam("cohortID") Long cohortID, @QueryParam("sourceKey") String sourceKey, @QueryParam("sampleName") String sampleName ) { @@ -90,7 +90,7 @@ public List getAnnotationCSV( if (cohortID == null || sourceKey == null || sampleName == null) { return null; } - + return annotationService.getAnnotationCSVData(cohortID, sourceKey, sampleName); } diff --git a/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationDto.java b/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationDto.java index 23996fba81..dc5517cc51 100644 --- a/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationDto.java +++ b/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationDto.java @@ -8,7 +8,7 @@ public class AnnotationDto { private Long id; private Long subjectId; - private Long cohortId; + private Long cohortSampleId; private Long setId; private String name; private Set results = new HashSet(); @@ -46,15 +46,15 @@ public void setSubjectId(Long subjectId) { /** * @return the cohortId */ - public Long getCohortId() { - return cohortId; + public Long getCohortSampleId() { + return cohortSampleId; } /** * @param cohortId the cohortId to set */ - public void setCohortId(Long cohortId) { - this.cohortId = cohortId; + public void setCohortSampleId(Long cohortSampleId) { + this.cohortSampleId = cohortSampleId; } /** @@ -84,7 +84,7 @@ public Set getResults() { protected void setResults(Set results) { this.results = results; } - + /** * @return the sample name */ diff --git a/src/main/java/org/ohdsi/webapi/annotation/result/Result.java b/src/main/java/org/ohdsi/webapi/annotation/result/Result.java index 16a17257ee..6b971bd041 100644 --- a/src/main/java/org/ohdsi/webapi/annotation/result/Result.java +++ b/src/main/java/org/ohdsi/webapi/annotation/result/Result.java @@ -25,16 +25,17 @@ public class Result { @JoinColumn(name = "annotation_id") private Annotation annotation; - @JsonIgnore - @Column(name = "set_id") - private Long setId; - @Column(name = "question_id") private Long questionId; @Column(name = "answer_id") private Long answerId; +//need charity's help here! these can all be retrieved from the annotation_id + @JsonIgnore + @Column(name = "set_id") + private Long setId; + @Column(name = "sample_name") private String sampleName; diff --git a/src/main/java/org/ohdsi/webapi/annotation/set/QuestionSet.java b/src/main/java/org/ohdsi/webapi/annotation/set/QuestionSet.java index c80584949f..33c35dba1c 100644 --- a/src/main/java/org/ohdsi/webapi/annotation/set/QuestionSet.java +++ b/src/main/java/org/ohdsi/webapi/annotation/set/QuestionSet.java @@ -21,13 +21,7 @@ public class QuestionSet { @Column(name = "set_id") private Long id; - @Column(name = "cohort_name") - private String cohortName; - - @Column(name = "cohort_source") - private String cohortSource; - - @Column(name = "cohort_id") + @Column(name = "cohort_definition_id") private int cohortId; private String name; @@ -56,34 +50,6 @@ public void setId(Long id) { this.id = id; } - /** - * @return the cohortName - */ - public String getCohortName() { - return cohortName; - } - - /** - * @param cohortName the cohortName to set - */ - public void setCohortName(String cohortName) { - this.cohortName = cohortName; - } - - /** - * @return the cohortSource - */ - public String getCohortSource() { - return cohortSource; - } - - /** - * @param cohortSource the cohortSource to set - */ - public void setCohortSource(String cohortSource) { - this.cohortSource = cohortSource; - } - /** * @return the cohortId */ diff --git a/src/main/resources/db/migration/postgresql/V2.5.1__annotation.sql b/src/main/resources/db/migration/postgresql/V2.5.1__annotation.sql index 7a15054c6d..8120352051 100644 --- a/src/main/resources/db/migration/postgresql/V2.5.1__annotation.sql +++ b/src/main/resources/db/migration/postgresql/V2.5.1__annotation.sql @@ -1,93 +1,61 @@ -CREATE TABLE annotation_set ( +CREATE TABLE ${ohdsiSchema}.annotation_set ( set_id integer NOT NULL, - cohort_name character varying(150) NOT NULL, - cohort_source character varying(25) NOT NULL, - cohort_id integer NOT NULL, - name character varying(150) NOT NULL, - -- date_created date NOT NULL, - -- date_updated date, + name VARCHAR(255) NOT NULL, + cohort_definition_id integer NOT NULL, + date_created TIMESTAMP WITH TIME ZONE NOT NULL DEFAULT (now()), + date_updated TIMESTAMP WITH TIME ZONE, + CONSTRAINT fk_annotation_set_cohor_definition_id FOREIGN KEY (cohort_definition_id) + REFERENCES ${ohdsiSchema}.cohort_definition (id) ON DELETE CASCADE, CONSTRAINT annotation_set_pkey PRIMARY KEY (set_id) ); -ALTER TABLE annotation_set OWNER TO ohdsi_admin; +CREATE INDEX idx_cohort_annotation_set ON ${ohdsiSchema}.annotation_set (cohort_definition_id); -CREATE TABLE annotation ( - annotation_id integer NOT NULL, - subject_id integer NOT NULL, - cohort_id integer NOT NULL, - set_id integer NOT NULL, - user_id integer, - CONSTRAINT annotation_pkey PRIMARY KEY (annotation_id), - CONSTRAINT annotation_set_fk FOREIGN KEY (set_id) REFERENCES annotation_set(set_id), - CONSTRAINT unq_subject_cohort_set UNIQUE(subject_id, cohort_id, set_id) -); - -ALTER TABLE annotation OWNER TO ohdsi_admin; - - -CREATE TABLE annotation_question ( +CREATE TABLE ${ohdsiSchema}.annotation_question ( question_id integer NOT NULL, set_id integer NOT NULL, - question_name character varying(250) NOT NULL, - question_type character varying(25) NOT NULL, + question_name VARCHAR(255) NOT NULL, + question_type VARCHAR(50) NOT NULL, required Boolean NOT NULL, case_question Boolean NOT NULL, help_text text, - -- date_created date NOT NULL, - -- date_updated date, + date_created TIMESTAMP WITH TIME ZONE NOT NULL DEFAULT (now()), + date_updated TIMESTAMP WITH TIME ZONE, CONSTRAINT annotation_questions_pkey PRIMARY KEY (question_id), - CONSTRAINT annotation_question_set_fk FOREIGN KEY (set_id) REFERENCES annotation_set(set_id) + CONSTRAINT annotation_question_set_fk FOREIGN KEY (set_id) + REFERENCES ${ohdsiSchema}.annotation_set(set_id) ON DELETE CASCADE ); -ALTER TABLE annotation_question OWNER TO ohdsi_admin; +CREATE INDEX idx_annotation_set_question ON ${ohdsiSchema}.annotation_question (set_id); -CREATE TABLE annotation_answer ( +CREATE TABLE ${ohdsiSchema}.annotation_answer ( answer_id integer NOT NULL, question_id integer NOT NULL, - -- set_id integer NOT NULL, text character varying(250) NOT NULL, value character varying(250) NOT NULL, help_text text, - -- date_created date NOT NULL, - -- date_updated date, CONSTRAINT annotation_answer_pkey PRIMARY KEY (answer_id), - CONSTRAINT annotation_answer_fk FOREIGN KEY (question_id) REFERENCES annotation_question(question_id) - -- CONSTRAINT annotation_answer_set_fk FOREIGN KEY (set_id) REFERENCES annotation_set(set_id) + CONSTRAINT annotation_answer_fk FOREIGN KEY (question_id) + REFERENCES ${ohdsiSchema}.annotation_question(question_id) ON DELETE CASCADE ); -ALTER TABLE annotation_answer OWNER TO ohdsi_admin; - +CREATE INDEX idx_annotation_answer_question ON ${ohdsiSchema}.annotation_question (question_id); -CREATE TABLE annotation_result ( - result_id integer NOT NULL, - annotation_id integer NOT NULL, - set_id integer NOT NULL, - question_id integer NOT NULL, - answer_id bigint NOT NULL, - subject_id integer NOT NULL, - sample_name character varying(100) NOT NULL, - value character varying(250) NOT NULL, - type character varying(50) NOT NULL, - -- author_id integer NOT NULL, - -- date_reviewed date NOT NULL, - CONSTRAINT annotation_result_pkey PRIMARY KEY (result_id), - CONSTRAINT annotation_result_question_fk FOREIGN KEY (question_id) - REFERENCES annotation_question (question_id) MATCH SIMPLE - ON UPDATE NO ACTION - ON DELETE NO ACTION, - -- CONSTRAINT annotation_result_author_fk FOREIGN KEY (author_id) - -- REFERENCES annotation_author (author_id) MATCH SIMPLE - -- ON UPDATE NO ACTION - -- ON DELETE NO ACTION, - CONSTRAINT annotation_result_as_fk FOREIGN KEY (set_id) - REFERENCES annotation_set(set_id) - ON UPDATE NO ACTION - ON DELETE NO ACTION, - CONSTRAINT annotation_result_ans_fk FOREIGN KEY (answer_id) - REFERENCES annotation_answer(answer_id) - ON UPDATE NO ACTION - ON DELETE NO ACTION +CREATE TABLE ${ohdsiSchema}.annotation ( + annotation_id integer NOT NULL, + subject_id integer NOT NULL, + cohort_sample_id integer NOT NULL, + set_id integer NOT NULL, + date_created TIMESTAMP WITH TIME ZONE NOT NULL DEFAULT (now()), + --user_id integer, + CONSTRAINT annotation_pkey PRIMARY KEY (annotation_id), + CONSTRAINT annotation_set_fk FOREIGN KEY (set_id) + REFERENCES ${ohdsiSchema}.annotation_set(set_id), + CONSTRAINT annotation_sample_fk FOREIGN KEY (cohort_sample_id) + REFERENCES ${ohdsiSchema}.cohort_sample(id), + CONSTRAINT unq_subject_sample_set UNIQUE(subject_id, cohort_sample_id, set_id) ); -ALTER TABLE annotation_result OWNER TO ohdsi_admin; +CREATE INDEX idx_annotation_sample_subject ON ${ohdsiSchema}.annotation (cohort_sample_id,subject_id); +CREATE INDEX idx_annotation_set ON ${ohdsiSchema}.annotation (set_id); diff --git a/src/main/resources/ddl/results/annotation_result.sql b/src/main/resources/ddl/results/annotation_result.sql new file mode 100644 index 0000000000..eced18c5d0 --- /dev/null +++ b/src/main/resources/ddl/results/annotation_result.sql @@ -0,0 +1,9 @@ +IF OBJECT_ID('@results_schema.annotation_result', 'U') IS NULL +CREATE TABLE @results_schema.annotation_result( + result_id integer NOT NULL, + annotation_id integer NOT NULL, + question_id integer NOT NULL, + answer_id bigint NOT NULL, + value VARCHAR(255) NOT NULL, + type VARCHAR(255) NOT NULL +); From 704b5a2e811655930404682cdfed3f35e64b1618 Mon Sep 17 00:00:00 2001 From: "Duke, Jon D" Date: Thu, 1 Apr 2021 11:41:13 -0400 Subject: [PATCH 04/55] Updated Annotation --- .../annotation/AnnotationController.java | 7 ++++--- .../annotation/AnnotationRepository.java | 6 +++--- .../annotation/annotation/AnnotationService.java | 14 +++++++------- 3 files changed, 14 insertions(+), 13 deletions(-) diff --git a/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationController.java b/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationController.java index 0963e06574..b73866e928 100644 --- a/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationController.java +++ b/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationController.java @@ -33,14 +33,14 @@ public class AnnotationController { @Path("/") @Produces(MediaType.APPLICATION_JSON) public List getAnnotations( - @QueryParam("cohortId") final Long cohortId, + @QueryParam("cohortSampleId") final Long cohortSampleId, @QueryParam("subjectId") final Long subjectId, @QueryParam("setId") final Long setId ) { - if (cohortId != null && subjectId != null && setId != null) { - return annotationService.getAnnotationByCohortIdAndBySubjectIdAndBySetId(cohortId, subjectId, setId); + if (cohortSampleId != null && subjectId != null && setId != null) { + return annotationService.getAnnotationByCohortSampleIdAndBySubjectIdAndBySetId(cohortSampleId, subjectId, setId); } return annotationService.getAnnotations(); @@ -74,6 +74,7 @@ public void addAnnotation(AnnotationDto annotationDto) { annotationService.addAnnotation(annotation, annotationDto.getSampleName()); } +//just for testing @Path("/csvData") @GET @Produces(MediaType.APPLICATION_JSON) diff --git a/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationRepository.java b/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationRepository.java index e972fba1b6..6d7030fbee 100644 --- a/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationRepository.java +++ b/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationRepository.java @@ -7,7 +7,7 @@ public interface AnnotationRepository extends JpaRepository { - public Set findOneByCohortIdAndSubjectIdAndSetId(Long cohortId, Long subjectId, Long setId); - public List findByCohortIdAndSetId(Long cohortId, Long setId); - + public Set findOneByCohortSampleIdAndSubjectIdAndSetId(Long cohortSampleId, Long subjectId, Long setId); + public List findByCohortSampleIdAndSetId(Long cohortSampleId, Long setId); + } diff --git a/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationService.java b/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationService.java index 14cd4b7bf3..90326f578f 100644 --- a/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationService.java +++ b/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationService.java @@ -39,16 +39,16 @@ public List getAnnotations() { return annotations; } - public List getAnnotationByCohortIdAndBySubjectIdAndBySetId(Long cohortId, Long subjectId, Long setId) { + public List getAnnotationByCohortSampleIdAndBySubjectIdAndBySetId(Long cohortSampleId, Long subjectId, Long setId) { List annotations = new ArrayList(); - annotationRepository.findOneByCohortIdAndSubjectIdAndSetId(cohortId, subjectId, setId) + annotationRepository.findOneByCohortSampleIdAndSubjectIdAndSetId(cohortSampleId, subjectId, setId) .forEach(annotations::add); return annotations; } - public List getAnnotationByCohortIdAndBySetId(Long cohortId, Long setId) { + public List getAnnotationByCohortSampleIdAndBySetId(Long cohortSampleId, Long setId) { List annotations = new ArrayList(); - annotationRepository.findByCohortIdAndSetId(cohortId, setId) + annotationRepository.findByCohortSampleIdAndSetId(cohortSampleId, setId) .forEach(annotations::add); return annotations; } @@ -81,16 +81,16 @@ public List getAnnotationCSVData(Long cohortID, String source, String for (int i = 0; i answers = new ArrayList<>(); for (int j = 0; j < qIDs.size(); j++) { answers.add(resultRepository.getAnswers(sampleName, qIDs.get(j), samples.get(i))); } - + row[1] = answers; - + results.add(row); } From 8e4fc916d69bfa42f3bfea87d9d688d8cca6d0d9 Mon Sep 17 00:00:00 2001 From: "Duke, Jon D" Date: Sat, 8 May 2021 16:22:52 -0400 Subject: [PATCH 05/55] Update CohortSample.java --- .../java/org/ohdsi/webapi/cohortsample/CohortSample.java | 7 ------- 1 file changed, 7 deletions(-) diff --git a/src/main/java/org/ohdsi/webapi/cohortsample/CohortSample.java b/src/main/java/org/ohdsi/webapi/cohortsample/CohortSample.java index 7350d2141b..b2b05b7640 100644 --- a/src/main/java/org/ohdsi/webapi/cohortsample/CohortSample.java +++ b/src/main/java/org/ohdsi/webapi/cohortsample/CohortSample.java @@ -53,9 +53,6 @@ public class CohortSample extends CommonEntity { @Column(name = "\"size\"") private int size; - - @Column(name = "annotated") - private boolean annotated; @Transient private List elements; @@ -139,9 +136,5 @@ public String getAgeMode() { public void setAgeMode(String ageMode) { this.ageMode = ageMode; } - - public boolean setAnnotated() { - return annotated; - } } From de445db0ac3d60769d6fc67039bd989bbb09f7b8 Mon Sep 17 00:00:00 2001 From: Saul Crumpton Date: Tue, 18 May 2021 17:49:56 -0400 Subject: [PATCH 06/55] annotion link button now works --- .../annotation/AnnotationController.java | 60 ++++++++++++------- .../annotation/annotation/AnnotationDto.java | 20 +++---- 2 files changed, 48 insertions(+), 32 deletions(-) diff --git a/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationController.java b/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationController.java index b73866e928..d2132b9f0d 100644 --- a/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationController.java +++ b/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationController.java @@ -9,6 +9,9 @@ import javax.ws.rs.core.MediaType; import javax.ws.rs.QueryParam; import javax.ws.rs.PathParam; + +import org.ohdsi.webapi.cohortsample.CohortSamplingService; +import org.ohdsi.webapi.cohortsample.dto.SampleElementDTO; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Component; import org.ohdsi.webapi.annotation.annotation.AnnotationService; @@ -18,11 +21,13 @@ import org.ohdsi.webapi.annotation.result.Result; - @Path("annotations") @Component public class AnnotationController { + @Autowired + public CohortSamplingService cohortSamplingService; + @Autowired private AnnotationService annotationService; @@ -47,31 +52,42 @@ public List getAnnotations( } @POST - @Path("/") + @Path("/sample") @Consumes(MediaType.APPLICATION_JSON) @Produces(MediaType.APPLICATION_JSON) public void addAnnotation(AnnotationDto annotationDto) { + System.out.println("annotationDto: "+annotationDto); + System.out.println("annotationDtoGetId: "+annotationDto.getId()); + System.out.println("annotationDtoGesampleId"+annotationDto.getsampleId()); + System.out.println("annotationDtoGetAnnotationSetID"+annotationDto.getannotationSetId()); + List temp = cohortSamplingService.getSample(annotationDto.getsampleId().intValue(), false).getElements(); + System.out.println("SampleElementDTO"+temp); + for (SampleElementDTO element : temp){ + System.out.println("element"+element); + System.out.println("element GetPersonID"+element.getPersonId()); + Annotation annotation = new Annotation(); + annotation.setId(annotationDto.getId()); + annotation.setSubjectId(Long.parseLong(element.getPersonId())); + annotation.setCohortSampleId(annotationDto.getsampleId()); + QuestionSet set = questionSetRepository.findById(annotationDto.getannotationSetId()); + annotation.setSet(set); + annotationService.addAnnotation(annotation, annotationDto.getSampleName()); + } + + +// TODO: Add back in question set and answer linking - Annotation annotation = new Annotation(); - annotation.setId(annotationDto.getId()); - annotation.setSubjectId(annotationDto.getSubjectId()); - annotation.setCohortSampleId(annotationDto.getCohortSampleId()); - QuestionSet set = questionSetRepository.findById(annotationDto.getSetId()); - annotation.setSet(set); - - annotationDto.getResults().forEach((resultDto) -> { - Result result = new Result(); - result.setQuestionId(resultDto.getQuestionId()); - result.setAnswerId(resultDto.getAnswerId()); - result.setSetId(set.getId()); - result.setSubjectId(annotationDto.getSubjectId()); - result.setValue(resultDto.getValue()); - result.setType(resultDto.getType()); - result.setSampleName(annotationDto.getSampleName()); - annotation.addToResults(result); - }); - - annotationService.addAnnotation(annotation, annotationDto.getSampleName()); +// annotationDto.getResults().forEach((resultDto) -> { +// Result result = new Result(); +// result.setQuestionId(resultDto.getQuestionId()); +// result.setAnswerId(resultDto.getAnswerId()); +// result.setSetId(set.getId()); +// result.setSubjectId(annotationDto.getSubjectId()); +// result.setValue(resultDto.getValue()); +// result.setType(resultDto.getType()); +// result.setSampleName(annotationDto.getSampleName()); +// annotation.addToResults(result); +// }); } //just for testing diff --git a/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationDto.java b/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationDto.java index dc5517cc51..6e7e3acb86 100644 --- a/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationDto.java +++ b/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationDto.java @@ -8,8 +8,8 @@ public class AnnotationDto { private Long id; private Long subjectId; - private Long cohortSampleId; - private Long setId; + private Long sampleId; + private Long annotationSetId; private String name; private Set results = new HashSet(); @@ -46,29 +46,29 @@ public void setSubjectId(Long subjectId) { /** * @return the cohortId */ - public Long getCohortSampleId() { - return cohortSampleId; + public Long getsampleId() { + return sampleId; } /** * @param cohortId the cohortId to set */ - public void setCohortSampleId(Long cohortSampleId) { - this.cohortSampleId = cohortSampleId; + public void setsampleId(Long sampleId) { + this.sampleId = sampleId; } /** * @return the setId */ - public Long getSetId() { - return setId; + public Long getannotationSetId() { + return annotationSetId; } /** * @param setId the setId to set */ - public void setSetId(Long setId) { - this.setId = setId; + public void setannotationSetId(Long setId) { + this.annotationSetId = setId; } /** From 18319f8662ecb3f5f53bcac078d2b24bbb191126 Mon Sep 17 00:00:00 2001 From: Saul Crumpton Date: Wed, 19 May 2021 19:52:33 -0400 Subject: [PATCH 07/55] removing results from Annotation.java --- .../annotation/annotation/Annotation.java | 50 +++++++++---------- .../annotation/AnnotationRepository.java | 3 ++ .../annotation/AnnotationService.java | 3 +- 3 files changed, 29 insertions(+), 27 deletions(-) diff --git a/src/main/java/org/ohdsi/webapi/annotation/annotation/Annotation.java b/src/main/java/org/ohdsi/webapi/annotation/annotation/Annotation.java index 565fc67d4a..ea606919eb 100644 --- a/src/main/java/org/ohdsi/webapi/annotation/annotation/Annotation.java +++ b/src/main/java/org/ohdsi/webapi/annotation/annotation/Annotation.java @@ -41,13 +41,13 @@ public class Annotation { @JoinColumn(name = "set_id") private QuestionSet set; - @OneToMany( - fetch = FetchType.EAGER, - mappedBy = "annotation", - cascade = CascadeType.ALL, - orphanRemoval = true - ) - private Set results = new HashSet(); + // @OneToMany( + // fetch = FetchType.EAGER, + // mappedBy = "annotation", + // cascade = CascadeType.ALL, + // orphanRemoval = true + // ) + // private Set results = new HashSet(); //***** GETTERS/SETTERS ****** @@ -107,24 +107,24 @@ public void setSet(QuestionSet set) { this.set = set; } - /** - * @return the results - */ - public Set getResults() { - return new HashSet(results); - } - - /** - * @param results the results to set - */ - protected void setResults(Set results) { - this.results = results; - } - - public void addToResults(Result result) { - result.setAnnotation(this); - this.results.add(result); - } + // /** + // * @return the results + // */ + // public Set getResults() { + // return new HashSet(results); + // } + + // /** + // * @param results the results to set + // */ + // protected void setResults(Set results) { + // this.results = results; + // } + + // public void addToResults(Result result) { + // result.setAnnotation(this); + // this.results.add(result); + // } // public void setSampleName(String name) { diff --git a/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationRepository.java b/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationRepository.java index 6d7030fbee..deab379843 100644 --- a/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationRepository.java +++ b/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationRepository.java @@ -4,10 +4,13 @@ import java.util.List; import java.util.Set; import org.ohdsi.webapi.annotation.annotation.Annotation; +import org.springframework.data.jpa.repository.Query; public interface AnnotationRepository extends JpaRepository { public Set findOneByCohortSampleIdAndSubjectIdAndSetId(Long cohortSampleId, Long subjectId, Long setId); public List findByCohortSampleIdAndSetId(Long cohortSampleId, Long setId); +// @Query(value="SELECT * FROM ohdsi.annotation",nativeQuery = true) +// public List findAllAnnotations(); } diff --git a/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationService.java b/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationService.java index 90326f578f..02ef70a86b 100644 --- a/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationService.java +++ b/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationService.java @@ -34,8 +34,7 @@ public class AnnotationService { public List getAnnotations() { List annotations = new ArrayList(); - annotationRepository.findAll() - .forEach(annotations::add); + annotationRepository.findAll().forEach(annotations::add); return annotations; } From b6d5b077dc428a83b75b716c38c698bc49cf24be Mon Sep 17 00:00:00 2001 From: Saul Crumpton Date: Wed, 26 May 2021 21:17:43 -0400 Subject: [PATCH 08/55] trying to make saving results to annotation_results table work --- .../annotation/AnnotationController.java | 47 +++++++++++++------ 1 file changed, 32 insertions(+), 15 deletions(-) diff --git a/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationController.java b/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationController.java index d2132b9f0d..77c7105132 100644 --- a/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationController.java +++ b/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationController.java @@ -1,6 +1,7 @@ package org.ohdsi.webapi.annotation.annotation; import java.util.List; +import java.util.Map; import javax.ws.rs.GET; import javax.ws.rs.POST; import javax.ws.rs.Path; @@ -9,7 +10,10 @@ import javax.ws.rs.core.MediaType; import javax.ws.rs.QueryParam; import javax.ws.rs.PathParam; +import org.json.JSONObject; +import org.json.JSONArray; +import org.ohdsi.webapi.annotation.result.ResultRepository; import org.ohdsi.webapi.cohortsample.CohortSamplingService; import org.ohdsi.webapi.cohortsample.dto.SampleElementDTO; import org.springframework.beans.factory.annotation.Autowired; @@ -25,6 +29,9 @@ @Component public class AnnotationController { + @Autowired + private ResultRepository resultRepository; + @Autowired public CohortSamplingService cohortSamplingService; @@ -51,6 +58,31 @@ public List getAnnotations( return annotationService.getAnnotations(); } + @POST + @Path("/") + @Consumes(MediaType.APPLICATION_JSON) + @Produces(MediaType.APPLICATION_JSON) + public void addResult(Map payload) { + System.out.println(payload); + System.out.println(payload.get("results")); + System.out.printf("cohortId: %s\n",payload.get("cohortId").toString()); + System.out.printf("subjectId: %s\n",payload.get("subjectId").toString()); + System.out.printf("setId: %s\n",payload.get("setId").toString()); + Annotation tempAnnotation = annotationService.getAnnotationByCohortSampleIdAndBySubjectIdAndBySetId(Long.parseLong(payload.get("sampleName").toString()) + ,Long.parseLong(payload.get("subjectId").toString()),Long.parseLong(payload.get("setId").toString())).get(0); + JSONArray array = new JSONArray(payload.get("results")); + for(int i=0; i < array.length(); i++){ + JSONObject object = array.getJSONObject(i); + Result result = new Result(); + result.setQuestionId(Long.parseLong(object.get("questionId").toString())); + result.setAnswerId(Long.parseLong(object.get("answerId").toString())); + result.setValue(object.get("value").toString()); + result.setType(object.get("type").toString()); + result.setAnnotation(tempAnnotation); + resultRepository.save(result); + } + } + @POST @Path("/sample") @Consumes(MediaType.APPLICATION_JSON) @@ -73,21 +105,6 @@ public void addAnnotation(AnnotationDto annotationDto) { annotation.setSet(set); annotationService.addAnnotation(annotation, annotationDto.getSampleName()); } - - -// TODO: Add back in question set and answer linking - -// annotationDto.getResults().forEach((resultDto) -> { -// Result result = new Result(); -// result.setQuestionId(resultDto.getQuestionId()); -// result.setAnswerId(resultDto.getAnswerId()); -// result.setSetId(set.getId()); -// result.setSubjectId(annotationDto.getSubjectId()); -// result.setValue(resultDto.getValue()); -// result.setType(resultDto.getType()); -// result.setSampleName(annotationDto.getSampleName()); -// annotation.addToResults(result); -// }); } //just for testing From b82ef09b2855af37b6f89eaa408e3d4c85ed278e Mon Sep 17 00:00:00 2001 From: Saul Crumpton Date: Thu, 27 May 2021 11:45:39 -0400 Subject: [PATCH 09/55] working annotation_results saving --- .../annotation/AnnotationController.java | 22 +++++--- .../annotation/AnnotationService.java | 3 +- .../webapi/annotation/result/Result.java | 50 +++++++++---------- .../webapi/annotation/result/ResultDto.java | 14 +++--- .../annotation/result/ResultRepository.java | 7 +-- 5 files changed, 51 insertions(+), 45 deletions(-) diff --git a/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationController.java b/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationController.java index 77c7105132..bc23263dbc 100644 --- a/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationController.java +++ b/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationController.java @@ -23,6 +23,7 @@ import org.ohdsi.webapi.annotation.set.QuestionSetRepository; import org.ohdsi.webapi.annotation.set.QuestionSet; import org.ohdsi.webapi.annotation.result.Result; +import org.springframework.web.bind.annotation.RequestBody; @Path("annotations") @@ -52,6 +53,7 @@ public List getAnnotations( if (cohortSampleId != null && subjectId != null && setId != null) { + System.out.println("made it into the search function"); return annotationService.getAnnotationByCohortSampleIdAndBySubjectIdAndBySetId(cohortSampleId, subjectId, setId); } @@ -62,15 +64,19 @@ public List getAnnotations( @Path("/") @Consumes(MediaType.APPLICATION_JSON) @Produces(MediaType.APPLICATION_JSON) - public void addResult(Map payload) { + public void addResult(@RequestBody String payload) { System.out.println(payload); - System.out.println(payload.get("results")); - System.out.printf("cohortId: %s\n",payload.get("cohortId").toString()); - System.out.printf("subjectId: %s\n",payload.get("subjectId").toString()); - System.out.printf("setId: %s\n",payload.get("setId").toString()); - Annotation tempAnnotation = annotationService.getAnnotationByCohortSampleIdAndBySubjectIdAndBySetId(Long.parseLong(payload.get("sampleName").toString()) - ,Long.parseLong(payload.get("subjectId").toString()),Long.parseLong(payload.get("setId").toString())).get(0); - JSONArray array = new JSONArray(payload.get("results")); + JSONObject jsonpayload = new JSONObject(payload); + System.out.println(jsonpayload); + System.out.println(jsonpayload.get("results")); + System.out.printf("cohortId: %s\n",jsonpayload.get("cohortId").toString()); + System.out.printf("cohortSampleId: %s\n",jsonpayload.get("sampleName").toString()); + System.out.printf("subjectId: %s\n",jsonpayload.get("subjectId").toString()); + System.out.printf("setId: %s\n",jsonpayload.get("setId").toString()); + Annotation tempAnnotation = annotationService.getAnnotationByCohortSampleIdAndBySubjectIdAndBySetId(Long.parseLong(jsonpayload.get("sampleName").toString()) + ,Long.parseLong(jsonpayload.get("subjectId").toString()),Long.parseLong(jsonpayload.get("setId").toString())).get(0); + System.out.printf("annotationID:%d\n",tempAnnotation.getId()); + JSONArray array = jsonpayload.getJSONArray("results"); for(int i=0; i < array.length(); i++){ JSONObject object = array.getJSONObject(i); Result result = new Result(); diff --git a/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationService.java b/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationService.java index 02ef70a86b..8a83635f41 100644 --- a/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationService.java +++ b/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationService.java @@ -84,7 +84,8 @@ public List getAnnotationCSVData(Long cohortID, String source, String row[0] = samples.get(i); List answers = new ArrayList<>(); for (int j = 0; j < qIDs.size(); j++) { - answers.add(resultRepository.getAnswers(sampleName, qIDs.get(j), samples.get(i))); +// TODO fix if necessary +// answers.add(resultRepository.getAnswers(sampleName, qIDs.get(j), samples.get(i))); } row[1] = answers; diff --git a/src/main/java/org/ohdsi/webapi/annotation/result/Result.java b/src/main/java/org/ohdsi/webapi/annotation/result/Result.java index 6b971bd041..27e009a971 100644 --- a/src/main/java/org/ohdsi/webapi/annotation/result/Result.java +++ b/src/main/java/org/ohdsi/webapi/annotation/result/Result.java @@ -32,16 +32,16 @@ public class Result { private Long answerId; //need charity's help here! these can all be retrieved from the annotation_id - @JsonIgnore - @Column(name = "set_id") - private Long setId; +// @JsonIgnore +// @Column(name = "set_id") +// private Long setId; - @Column(name = "sample_name") - private String sampleName; +// @Column(name = "sample_name") +// private String sampleName; - @JsonIgnore - @Column(name = "subject_id") - private Long subjectId; +// @JsonIgnore +// @Column(name = "subject_id") +// private Long subjectId; @Column(name = "value") private String value; @@ -82,16 +82,16 @@ public void setAnnotation(Annotation annotation) { /** * @return the subjectId */ - public Long getSubjectId() { - return subjectId; - } +// public Long getSubjectId() { +// return subjectId; +// } /** * @param subjectId the subjectId to set */ - public void setSubjectId(Long subjectId) { - this.subjectId = subjectId; - } +// public void setSubjectId(Long subjectId) { +// this.subjectId = subjectId; +// } /** * @return the answerId @@ -110,16 +110,16 @@ public void setAnswerId(Long answerId) { /** * @return the setId */ - public Long getSetId() { - return setId; - } +// public Long getSetId() { +// return setId; +// } /** * @param setId the setId to set */ - public void setSetId(Long setId) { - this.setId = setId; - } +// public void setSetId(Long setId) { +// this.setId = setId; +// } /** * @return the questionId @@ -165,14 +165,12 @@ public void setValue(String value) { /** * @return the type */ - public String getSampleName() { - return sampleName; - } +// public String getSampleName() { +// return sampleName; +// } /** * @param type the type to set */ - public void setSampleName(String name) { - this.sampleName = name; - } +// public void setSampleName(String name) {this.sampleName = name;} } diff --git a/src/main/java/org/ohdsi/webapi/annotation/result/ResultDto.java b/src/main/java/org/ohdsi/webapi/annotation/result/ResultDto.java index 2fe3d2a231..8102e8663a 100644 --- a/src/main/java/org/ohdsi/webapi/annotation/result/ResultDto.java +++ b/src/main/java/org/ohdsi/webapi/annotation/result/ResultDto.java @@ -6,7 +6,7 @@ public class ResultDto { private Long questionId; private String value; private String type; - private String sampleName; +// private String sampleName; //***** GETTERS/SETTERS ****** @@ -69,14 +69,14 @@ public void setType(String type) { /** * @return the type */ - public String getSampleName() { - return sampleName; - } +// public String getSampleName() { +// return sampleName; +// } /** * @param type the type to set */ - public void setSampleName(String name) { - this.sampleName = name; - } +// public void setSampleName(String name) { +// this.sampleName = name; +// } } diff --git a/src/main/java/org/ohdsi/webapi/annotation/result/ResultRepository.java b/src/main/java/org/ohdsi/webapi/annotation/result/ResultRepository.java index 616e3c9326..c8f211dede 100644 --- a/src/main/java/org/ohdsi/webapi/annotation/result/ResultRepository.java +++ b/src/main/java/org/ohdsi/webapi/annotation/result/ResultRepository.java @@ -1,5 +1,6 @@ package org.ohdsi.webapi.annotation.result; +import org.ohdsi.webapi.annotation.annotation.Annotation; import org.springframework.data.jpa.repository.JpaRepository; import org.ohdsi.webapi.annotation.result.Result; import java.util.Set; @@ -8,8 +9,8 @@ @Transactional public interface ResultRepository extends JpaRepository { - public Set findBySampleNameAndSubjectId(String sampleName, Long subject_id); +// public Set findBySampleNameAndSubjectId(String sampleName, Long subject_id); - @Query("select s.value from Result s where s.sampleName=?1 and s.questionId = ?2 and s.subjectId=?3") - public Set getAnswers(String name, Long cohortID, Long subjectID); + @Query("select s.value from Result s where s.annotation=?1 and s.questionId = ?2") + public Set getAnswers(Annotation annotation, Long questionID); } From 65028fcab308fbbfda2fcfc740cd282e261d944b Mon Sep 17 00:00:00 2001 From: Saul Crumpton Date: Wed, 2 Jun 2021 18:06:49 -0400 Subject: [PATCH 10/55] initial commit for ResultController and ResultService --- .../annotation/result/ResultController.java | 33 +++++++++++++++++++ .../annotation/result/ResultService.java | 15 +++++++++ 2 files changed, 48 insertions(+) create mode 100644 src/main/java/org/ohdsi/webapi/annotation/result/ResultController.java create mode 100644 src/main/java/org/ohdsi/webapi/annotation/result/ResultService.java diff --git a/src/main/java/org/ohdsi/webapi/annotation/result/ResultController.java b/src/main/java/org/ohdsi/webapi/annotation/result/ResultController.java new file mode 100644 index 0000000000..971accda07 --- /dev/null +++ b/src/main/java/org/ohdsi/webapi/annotation/result/ResultController.java @@ -0,0 +1,33 @@ +package org.ohdsi.webapi.annotation.result; + +import javax.ws.rs.GET; +import javax.ws.rs.Path; +import javax.ws.rs.Consumes; +import javax.ws.rs.Produces; +import javax.ws.rs.core.MediaType; + +import org.ohdsi.webapi.annotation.annotation.Annotation; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.stereotype.Component; +import org.ohdsi.webapi.annotation.result.ResultService; +import org.springframework.web.bind.annotation.PathVariable; + +import java.util.ArrayList; +import java.util.List; + +@Path("annotation/results/") +@Component +public class ResultController { + + @Autowired + private ResultService resultService; + + @GET + @Path("/{annotationID}") + @Produces(MediaType.APPLICATION_JSON) + public ArrayList getResults(@PathVariable("annotationID") String annotationID) { + ArrayList al = new ArrayList(); + + return al; + } +} diff --git a/src/main/java/org/ohdsi/webapi/annotation/result/ResultService.java b/src/main/java/org/ohdsi/webapi/annotation/result/ResultService.java new file mode 100644 index 0000000000..97e88aa38a --- /dev/null +++ b/src/main/java/org/ohdsi/webapi/annotation/result/ResultService.java @@ -0,0 +1,15 @@ +package org.ohdsi.webapi.annotation.result; + +import org.ohdsi.webapi.annotation.result.Result; +import org.ohdsi.webapi.annotation.result.ResultRepository; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.stereotype.Service; + +@Service +public class ResultService { + + @Autowired + private ResultRepository resultRepository; + + +} From 7b02d1049d5c6f1246c7c33cfa2d85de6be8addf Mon Sep 17 00:00:00 2001 From: Saul Crumpton Date: Wed, 2 Jun 2021 20:59:18 -0400 Subject: [PATCH 11/55] can now query for all results of a certain annotation ID --- .../annotation/annotation/Annotation.java | 20 ++++++------- .../annotation/AnnotationController.java | 15 ++++++++-- .../annotation/annotation/AnnotationDto.java | 26 ++++++++--------- .../annotation/AnnotationRepository.java | 3 ++ .../annotation/AnnotationService.java | 4 +++ .../annotation/result/ResultController.java | 29 +++++++++++++------ .../annotation/result/ResultRepository.java | 8 +++++ .../annotation/result/ResultService.java | 6 ++++ .../webapi/annotation/set/QuestionSet.java | 6 ++-- .../annotation/set/QuestionSetRepository.java | 2 +- 10 files changed, 81 insertions(+), 38 deletions(-) diff --git a/src/main/java/org/ohdsi/webapi/annotation/annotation/Annotation.java b/src/main/java/org/ohdsi/webapi/annotation/annotation/Annotation.java index ea606919eb..c20e809b60 100644 --- a/src/main/java/org/ohdsi/webapi/annotation/annotation/Annotation.java +++ b/src/main/java/org/ohdsi/webapi/annotation/annotation/Annotation.java @@ -25,13 +25,13 @@ public class Annotation { @Id @GeneratedValue @Column(name = "annotation_id") - private Long id; + private int id; @Column(name = "subject_id") - private Long subjectId; + private int subjectId; @Column(name = "cohort_sample_id") - private Long cohortSampleId; + private int cohortSampleId; // @Column(name = "sample_name") // private String sampleName; @@ -54,42 +54,42 @@ public class Annotation { /** * @return the id */ - public Long getId() { + public int getId() { return id; } /** * @param id the id to set */ - public void setId(Long id) { + public void setId(int id) { this.id = id; } /** * @return the subjectId */ - public Long getSubjectId() { + public int getSubjectId() { return subjectId; } /** * @param subjectId the subjectId to set */ - public void setSubjectId(Long subjectId) { + public void setSubjectId(int subjectId) { this.subjectId = subjectId; } /** * @return the cohortId */ - public Long getCohortSampleId() { + public int getCohortSampleId() { return cohortSampleId; } /** - * @param cohortId the cohortId to set + * @param cohortSampleId the cohortId to set */ - public void setCohortSampleId(Long cohortSampleId) { + public void setCohortSampleId(int cohortSampleId) { this.cohortSampleId = cohortSampleId; } diff --git a/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationController.java b/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationController.java index bc23263dbc..0d5418c9e9 100644 --- a/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationController.java +++ b/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationController.java @@ -98,14 +98,14 @@ public void addAnnotation(AnnotationDto annotationDto) { System.out.println("annotationDtoGetId: "+annotationDto.getId()); System.out.println("annotationDtoGesampleId"+annotationDto.getsampleId()); System.out.println("annotationDtoGetAnnotationSetID"+annotationDto.getannotationSetId()); - List temp = cohortSamplingService.getSample(annotationDto.getsampleId().intValue(), false).getElements(); + List temp = cohortSamplingService.getSample(annotationDto.getsampleId(), false).getElements(); System.out.println("SampleElementDTO"+temp); for (SampleElementDTO element : temp){ System.out.println("element"+element); System.out.println("element GetPersonID"+element.getPersonId()); Annotation annotation = new Annotation(); annotation.setId(annotationDto.getId()); - annotation.setSubjectId(Long.parseLong(element.getPersonId())); + annotation.setSubjectId(Integer.parseInt(element.getPersonId())); annotation.setCohortSampleId(annotationDto.getsampleId()); QuestionSet set = questionSetRepository.findById(annotationDto.getannotationSetId()); annotation.setSet(set); @@ -113,6 +113,17 @@ public void addAnnotation(AnnotationDto annotationDto) { } } + @GET + @Path("/getsets") + @Produces(MediaType.APPLICATION_JSON) + public List getSets( + @QueryParam("cohortSampleId") final Long cohortSampleId, + @QueryParam("subjectId") final Long subjectId, + @QueryParam("setId") final Long setId + ) { + return annotationService.getAnnotations(); + } + //just for testing @Path("/csvData") @GET diff --git a/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationDto.java b/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationDto.java index 6e7e3acb86..915533a595 100644 --- a/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationDto.java +++ b/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationDto.java @@ -6,10 +6,10 @@ public class AnnotationDto { - private Long id; - private Long subjectId; - private Long sampleId; - private Long annotationSetId; + private int id; + private int subjectId; + private int sampleId; + private int annotationSetId; private String name; private Set results = new HashSet(); @@ -18,56 +18,56 @@ public class AnnotationDto { /** * @return the id */ - public Long getId() { + public int getId() { return id; } /** * @param id the id to set */ - public void setId(Long id) { + public void setId(int id) { this.id = id; } /** * @return the subjectId */ - public Long getSubjectId() { + public int getSubjectId() { return subjectId; } /** * @param subjectId the subjectId to set */ - public void setSubjectId(Long subjectId) { + public void setSubjectId(int subjectId) { this.subjectId = subjectId; } /** * @return the cohortId */ - public Long getsampleId() { + public int getsampleId() { return sampleId; } /** - * @param cohortId the cohortId to set + * @param sampleId the cohortId to set */ - public void setsampleId(Long sampleId) { + public void setsampleId(int sampleId) { this.sampleId = sampleId; } /** * @return the setId */ - public Long getannotationSetId() { + public int getannotationSetId() { return annotationSetId; } /** * @param setId the setId to set */ - public void setannotationSetId(Long setId) { + public void setannotationSetId(int setId) { this.annotationSetId = setId; } diff --git a/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationRepository.java b/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationRepository.java index deab379843..7e6d37a18e 100644 --- a/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationRepository.java +++ b/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationRepository.java @@ -5,12 +5,15 @@ import java.util.Set; import org.ohdsi.webapi.annotation.annotation.Annotation; import org.springframework.data.jpa.repository.Query; +import org.springframework.data.repository.query.Param; public interface AnnotationRepository extends JpaRepository { public Set findOneByCohortSampleIdAndSubjectIdAndSetId(Long cohortSampleId, Long subjectId, Long setId); public List findByCohortSampleIdAndSetId(Long cohortSampleId, Long setId); + @Query("Select a FROM Annotation a WHERE a.id = ?1") + public Annotation findByAnnotationId(int annotation_id); // @Query(value="SELECT * FROM ohdsi.annotation",nativeQuery = true) // public List findAllAnnotations(); } diff --git a/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationService.java b/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationService.java index 8a83635f41..3d8d11858f 100644 --- a/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationService.java +++ b/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationService.java @@ -38,6 +38,10 @@ public List getAnnotations() { return annotations; } + public Annotation getAnnotationsByAnnotationId(int annotationId) { + return annotationRepository.findByAnnotationId(annotationId); + } + public List getAnnotationByCohortSampleIdAndBySubjectIdAndBySetId(Long cohortSampleId, Long subjectId, Long setId) { List annotations = new ArrayList(); annotationRepository.findOneByCohortSampleIdAndSubjectIdAndSetId(cohortSampleId, subjectId, setId) diff --git a/src/main/java/org/ohdsi/webapi/annotation/result/ResultController.java b/src/main/java/org/ohdsi/webapi/annotation/result/ResultController.java index 971accda07..40c69aeba6 100644 --- a/src/main/java/org/ohdsi/webapi/annotation/result/ResultController.java +++ b/src/main/java/org/ohdsi/webapi/annotation/result/ResultController.java @@ -1,33 +1,44 @@ package org.ohdsi.webapi.annotation.result; -import javax.ws.rs.GET; -import javax.ws.rs.Path; -import javax.ws.rs.Consumes; -import javax.ws.rs.Produces; +import javax.ws.rs.*; import javax.ws.rs.core.MediaType; import org.ohdsi.webapi.annotation.annotation.Annotation; +import org.ohdsi.webapi.annotation.annotation.AnnotationService; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Component; import org.ohdsi.webapi.annotation.result.ResultService; import org.springframework.web.bind.annotation.PathVariable; +import org.springframework.web.bind.annotation.RequestMapping; -import java.util.ArrayList; -import java.util.List; +import java.util.*; -@Path("annotation/results/") +@Path("/annotations/results") @Component public class ResultController { @Autowired private ResultService resultService; + @Autowired + private AnnotationService annotationService; + @GET @Path("/{annotationID}") @Produces(MediaType.APPLICATION_JSON) - public ArrayList getResults(@PathVariable("annotationID") String annotationID) { + public ArrayList getResults(@PathParam("annotationID") String annotationID) { + int annotationIdInt=Integer.parseInt(annotationID); ArrayList al = new ArrayList(); - + Annotation ourAnno =annotationService.getAnnotationsByAnnotationId(annotationIdInt); + List tempResults = resultService.getResultsByAnnotationID(annotationIdInt); + for(Result tempResult : tempResults ){ + System.out.println(tempResult); + Map testDict =new HashMap(); + testDict.put("questionId",tempResult.getQuestionId().toString()); + testDict.put("answerId",tempResult.getAnswerId().toString()); + testDict.put("subjectId",Integer.toString(ourAnno.getSubjectId())); + al.add(testDict); + } return al; } } diff --git a/src/main/java/org/ohdsi/webapi/annotation/result/ResultRepository.java b/src/main/java/org/ohdsi/webapi/annotation/result/ResultRepository.java index c8f211dede..645e80b2d6 100644 --- a/src/main/java/org/ohdsi/webapi/annotation/result/ResultRepository.java +++ b/src/main/java/org/ohdsi/webapi/annotation/result/ResultRepository.java @@ -1,9 +1,14 @@ package org.ohdsi.webapi.annotation.result; import org.ohdsi.webapi.annotation.annotation.Annotation; +import org.ohdsi.webapi.cohortsample.CohortSample; import org.springframework.data.jpa.repository.JpaRepository; import org.ohdsi.webapi.annotation.result.Result; + +import java.util.List; import java.util.Set; + +import org.springframework.data.repository.query.Param; import org.springframework.transaction.annotation.Transactional; import org.springframework.data.jpa.repository.Query; @@ -13,4 +18,7 @@ public interface ResultRepository extends JpaRepository { @Query("select s.value from Result s where s.annotation=?1 and s.questionId = ?2") public Set getAnswers(Annotation annotation, Long questionID); + + @Query("select r FROM Result r WHERE r.annotation.id = ?1") + List findByAnnotationId(int annotationId); } diff --git a/src/main/java/org/ohdsi/webapi/annotation/result/ResultService.java b/src/main/java/org/ohdsi/webapi/annotation/result/ResultService.java index 97e88aa38a..0897ac43b8 100644 --- a/src/main/java/org/ohdsi/webapi/annotation/result/ResultService.java +++ b/src/main/java/org/ohdsi/webapi/annotation/result/ResultService.java @@ -1,15 +1,21 @@ package org.ohdsi.webapi.annotation.result; +import org.ohdsi.webapi.annotation.annotation.Annotation; import org.ohdsi.webapi.annotation.result.Result; import org.ohdsi.webapi.annotation.result.ResultRepository; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Service; +import java.util.List; + @Service public class ResultService { @Autowired private ResultRepository resultRepository; + public List getResultsByAnnotationID(int AnnotationID) { + return resultRepository.findByAnnotationId(AnnotationID); + } } diff --git a/src/main/java/org/ohdsi/webapi/annotation/set/QuestionSet.java b/src/main/java/org/ohdsi/webapi/annotation/set/QuestionSet.java index 33c35dba1c..a355f1dc4b 100644 --- a/src/main/java/org/ohdsi/webapi/annotation/set/QuestionSet.java +++ b/src/main/java/org/ohdsi/webapi/annotation/set/QuestionSet.java @@ -19,7 +19,7 @@ public class QuestionSet { @Id @GeneratedValue @Column(name = "set_id") - private Long id; + private int id; @Column(name = "cohort_definition_id") private int cohortId; @@ -39,14 +39,14 @@ public class QuestionSet { /** * @return the id */ - public Long getId() { + public int getId() { return id; } /** * @param id the id to set */ - public void setId(Long id) { + public void setId(int id) { this.id = id; } diff --git a/src/main/java/org/ohdsi/webapi/annotation/set/QuestionSetRepository.java b/src/main/java/org/ohdsi/webapi/annotation/set/QuestionSetRepository.java index 063c048821..7b8480a9d7 100644 --- a/src/main/java/org/ohdsi/webapi/annotation/set/QuestionSetRepository.java +++ b/src/main/java/org/ohdsi/webapi/annotation/set/QuestionSetRepository.java @@ -8,6 +8,6 @@ public interface QuestionSetRepository extends JpaRepository { public Set findByCohortId(Integer cohortId); - public QuestionSet findById(Long id); + public QuestionSet findById(int id); } From 45ffb5f2c95a0439f62a2e3da21b1711dd0bb37e Mon Sep 17 00:00:00 2001 From: Saul Crumpton Date: Wed, 2 Jun 2021 21:15:41 -0400 Subject: [PATCH 12/55] added todo in AnnotationController --- .../ohdsi/webapi/annotation/annotation/AnnotationController.java | 1 + 1 file changed, 1 insertion(+) diff --git a/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationController.java b/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationController.java index 0d5418c9e9..7a4678573f 100644 --- a/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationController.java +++ b/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationController.java @@ -73,6 +73,7 @@ public void addResult(@RequestBody String payload) { System.out.printf("cohortSampleId: %s\n",jsonpayload.get("sampleName").toString()); System.out.printf("subjectId: %s\n",jsonpayload.get("subjectId").toString()); System.out.printf("setId: %s\n",jsonpayload.get("setId").toString()); +// TODO: change this to use annotationService.getAnnotationsByAnnotationId potentially Annotation tempAnnotation = annotationService.getAnnotationByCohortSampleIdAndBySubjectIdAndBySetId(Long.parseLong(jsonpayload.get("sampleName").toString()) ,Long.parseLong(jsonpayload.get("subjectId").toString()),Long.parseLong(jsonpayload.get("setId").toString())).get(0); System.out.printf("annotationID:%d\n",tempAnnotation.getId()); From b2166a8954ebd04d4c36c7cf12db8e3f673b0d2a Mon Sep 17 00:00:00 2001 From: Saul Crumpton Date: Tue, 15 Jun 2021 19:42:41 -0400 Subject: [PATCH 13/55] default annotation GET now returns summary instead of full question entity. Also added additional param searches --- .../annotation/annotation/Annotation.java | 17 +++--- .../annotation/AnnotationController.java | 59 ++++++++++++++----- .../annotation/AnnotationRepository.java | 6 +- .../annotation/AnnotationService.java | 18 ++++-- .../annotation/AnnotationSummary.java | 18 ++++++ 5 files changed, 90 insertions(+), 28 deletions(-) create mode 100644 src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationSummary.java diff --git a/src/main/java/org/ohdsi/webapi/annotation/annotation/Annotation.java b/src/main/java/org/ohdsi/webapi/annotation/annotation/Annotation.java index c20e809b60..2ed0ad3127 100644 --- a/src/main/java/org/ohdsi/webapi/annotation/annotation/Annotation.java +++ b/src/main/java/org/ohdsi/webapi/annotation/annotation/Annotation.java @@ -12,6 +12,8 @@ import javax.persistence.JoinColumn; import javax.persistence.Id; import javax.persistence.Table; + +import com.fasterxml.jackson.annotation.JsonIgnoreProperties; import org.ohdsi.webapi.annotation.result.Result; import org.ohdsi.webapi.annotation.set.QuestionSet; import com.fasterxml.jackson.annotation.JsonIgnore; @@ -35,11 +37,10 @@ public class Annotation { // @Column(name = "sample_name") // private String sampleName; - - @JsonIgnore + @ManyToOne - @JoinColumn(name = "set_id") - private QuestionSet set; + @JoinColumn(name = "question_set_id") + private QuestionSet questionSet; // @OneToMany( // fetch = FetchType.EAGER, @@ -96,15 +97,15 @@ public void setCohortSampleId(int cohortSampleId) { /** * @return the set */ - public QuestionSet getSet() { - return set; + public QuestionSet getQuestionSet() { + return questionSet; } /** * @param set the set to set */ - public void setSet(QuestionSet set) { - this.set = set; + public void setQuestionSet(QuestionSet questionSet) { + this.questionSet = questionSet; } // /** diff --git a/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationController.java b/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationController.java index 7a4678573f..451586c9be 100644 --- a/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationController.java +++ b/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationController.java @@ -1,5 +1,6 @@ package org.ohdsi.webapi.annotation.annotation; +import java.util.ArrayList; import java.util.List; import java.util.Map; import javax.ws.rs.GET; @@ -45,19 +46,49 @@ public class AnnotationController { @GET @Path("/") @Produces(MediaType.APPLICATION_JSON) - public List getAnnotations( - @QueryParam("cohortSampleId") final Long cohortSampleId, - @QueryParam("subjectId") final Long subjectId, - @QueryParam("setId") final Long setId + public List getAnnotations( + @QueryParam("cohortSampleId") final int cohortSampleId, + @QueryParam("subjectId") final int subjectId, + @QueryParam("setId") final int setId ) { - - - if (cohortSampleId != null && subjectId != null && setId != null) { - System.out.println("made it into the search function"); - return annotationService.getAnnotationByCohortSampleIdAndBySubjectIdAndBySetId(cohortSampleId, subjectId, setId); + List returnAnnotations; + returnAnnotations = getFullAnnotations(cohortSampleId,subjectId,setId); + List summaries = new ArrayList(); + for(Annotation singleAnno : returnAnnotations){ + System.out.println(singleAnno); + AnnotationSummary tempAnnoSummary=new AnnotationSummary(singleAnno); + System.out.println(tempAnnoSummary); + summaries.add(tempAnnoSummary); } + return summaries; + } - return annotationService.getAnnotations(); + @GET + @Path("/fullquestion") + @Produces(MediaType.APPLICATION_JSON) + public List getFullAnnotations( + @QueryParam("cohortSampleId") final int cohortSampleId, + @QueryParam("subjectId") final int subjectId, + @QueryParam("setId") final int setId + ) { + List returnAnnotations=null; + if (cohortSampleId != 0 && subjectId != 0 && setId != 0) { + System.out.println("made it into the search function"); + returnAnnotations= annotationService.getAnnotationByCohortSampleIdAndBySubjectIdAndByQuestionSetId(cohortSampleId, subjectId, setId); + } + else if (cohortSampleId !=0 && setId!=0){ + returnAnnotations= annotationService.getAnnotationByCohortSampleIdAndByQuestionSetId(cohortSampleId,setId); + } + else if(cohortSampleId!=0){ + returnAnnotations= annotationService.getAnnotationsByCohortSampleId(cohortSampleId); + } + else if(setId !=0){ + returnAnnotations= annotationService.getAnnotationsByQuestionSetId(setId); + } + else{ + returnAnnotations=annotationService.getAnnotations(); + } + return returnAnnotations; } @POST @@ -74,8 +105,8 @@ public void addResult(@RequestBody String payload) { System.out.printf("subjectId: %s\n",jsonpayload.get("subjectId").toString()); System.out.printf("setId: %s\n",jsonpayload.get("setId").toString()); // TODO: change this to use annotationService.getAnnotationsByAnnotationId potentially - Annotation tempAnnotation = annotationService.getAnnotationByCohortSampleIdAndBySubjectIdAndBySetId(Long.parseLong(jsonpayload.get("sampleName").toString()) - ,Long.parseLong(jsonpayload.get("subjectId").toString()),Long.parseLong(jsonpayload.get("setId").toString())).get(0); + Annotation tempAnnotation = annotationService.getAnnotationByCohortSampleIdAndBySubjectIdAndByQuestionSetId(Integer.parseInt(jsonpayload.get("sampleName").toString()) + ,Integer.parseInt(jsonpayload.get("subjectId").toString()),Integer.parseInt(jsonpayload.get("setId").toString())).get(0); System.out.printf("annotationID:%d\n",tempAnnotation.getId()); JSONArray array = jsonpayload.getJSONArray("results"); for(int i=0; i < array.length(); i++){ @@ -108,8 +139,8 @@ public void addAnnotation(AnnotationDto annotationDto) { annotation.setId(annotationDto.getId()); annotation.setSubjectId(Integer.parseInt(element.getPersonId())); annotation.setCohortSampleId(annotationDto.getsampleId()); - QuestionSet set = questionSetRepository.findById(annotationDto.getannotationSetId()); - annotation.setSet(set); + QuestionSet questionSet = questionSetRepository.findById(annotationDto.getannotationSetId()); + annotation.setQuestionSet(questionSet); annotationService.addAnnotation(annotation, annotationDto.getSampleName()); } } diff --git a/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationRepository.java b/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationRepository.java index 7e6d37a18e..16addacff8 100644 --- a/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationRepository.java +++ b/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationRepository.java @@ -9,8 +9,10 @@ public interface AnnotationRepository extends JpaRepository { - public Set findOneByCohortSampleIdAndSubjectIdAndSetId(Long cohortSampleId, Long subjectId, Long setId); - public List findByCohortSampleIdAndSetId(Long cohortSampleId, Long setId); + public Set findOneByCohortSampleIdAndSubjectIdAndQuestionSetId(int cohortSampleId, int subjectId, int questionSetId); + public List findByCohortSampleIdAndQuestionSetId(int cohortSampleId, int questionSetId); + public List findByCohortSampleId(int cohortSampleId); + public List findByQuestionSetId(int questionSetId); @Query("Select a FROM Annotation a WHERE a.id = ?1") public Annotation findByAnnotationId(int annotation_id); diff --git a/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationService.java b/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationService.java index 3d8d11858f..83aa3d2669 100644 --- a/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationService.java +++ b/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationService.java @@ -42,16 +42,20 @@ public Annotation getAnnotationsByAnnotationId(int annotationId) { return annotationRepository.findByAnnotationId(annotationId); } - public List getAnnotationByCohortSampleIdAndBySubjectIdAndBySetId(Long cohortSampleId, Long subjectId, Long setId) { + public List getAnnotationByCohortSampleIdAndBySubjectIdAndByQuestionSetId(int cohortSampleId, int subjectId, int questionSetId) { + System.out.printf("cohortSampleId %d\n",cohortSampleId); + System.out.printf("subjectId %d\n",subjectId); + System.out.printf("questionSetId %d\n",questionSetId); + List annotations = new ArrayList(); - annotationRepository.findOneByCohortSampleIdAndSubjectIdAndSetId(cohortSampleId, subjectId, setId) + annotationRepository.findOneByCohortSampleIdAndSubjectIdAndQuestionSetId(cohortSampleId, subjectId, questionSetId) .forEach(annotations::add); return annotations; } - public List getAnnotationByCohortSampleIdAndBySetId(Long cohortSampleId, Long setId) { + public List getAnnotationByCohortSampleIdAndByQuestionSetId(int cohortSampleId, int setId) { List annotations = new ArrayList(); - annotationRepository.findByCohortSampleIdAndSetId(cohortSampleId, setId) + annotationRepository.findByCohortSampleIdAndQuestionSetId(cohortSampleId, setId) .forEach(annotations::add); return annotations; } @@ -101,4 +105,10 @@ public List getAnnotationCSVData(Long cohortID, String source, String return results; } + public List getAnnotationsByCohortSampleId(int cohortSampleId) { + return annotationRepository.findByCohortSampleId(cohortSampleId); + } + public List getAnnotationsByQuestionSetId(int questionSetId) { + return annotationRepository.findByQuestionSetId(questionSetId); + } } diff --git a/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationSummary.java b/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationSummary.java new file mode 100644 index 0000000000..2d0cc8bb14 --- /dev/null +++ b/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationSummary.java @@ -0,0 +1,18 @@ +package org.ohdsi.webapi.annotation.annotation; + +import com.fasterxml.jackson.annotation.JsonAutoDetect; + +@JsonAutoDetect(fieldVisibility = JsonAutoDetect.Visibility.ANY) +public class AnnotationSummary { + private int id; + private int subjectId; + private int cohortSampleId; + private int questionSetId; + + public AnnotationSummary(Annotation annotation) { + this.id = annotation.getId(); + this.subjectId= annotation.getSubjectId(); + this.cohortSampleId= annotation.getCohortSampleId(); + this.questionSetId=annotation.getQuestionSet().getId(); + } +} From 7b7ce8ec50a5814ab4e27a6fbc70a0d28d923304 Mon Sep 17 00:00:00 2001 From: Saul Crumpton Date: Tue, 15 Jun 2021 19:46:35 -0400 Subject: [PATCH 14/55] removed some printlines, also added todo about performance --- .../webapi/annotation/annotation/AnnotationController.java | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationController.java b/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationController.java index 451586c9be..1471c728f0 100644 --- a/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationController.java +++ b/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationController.java @@ -55,9 +55,8 @@ public List getAnnotations( returnAnnotations = getFullAnnotations(cohortSampleId,subjectId,setId); List summaries = new ArrayList(); for(Annotation singleAnno : returnAnnotations){ - System.out.println(singleAnno); +// TODO see about doing this in a more performant matter? AnnotationSummary tempAnnoSummary=new AnnotationSummary(singleAnno); - System.out.println(tempAnnoSummary); summaries.add(tempAnnoSummary); } return summaries; From d769a68a87345b14a0512d47fb2fce151f109348 Mon Sep 17 00:00:00 2001 From: Saul Crumpton Date: Wed, 28 Jul 2021 21:34:03 -0400 Subject: [PATCH 15/55] moving to prepared statements for annotation_results --- .../annotation/annotation/Annotation.java | 2 +- .../annotation/AnnotationController.java | 32 +++--- .../annotation/result/ResultController.java | 19 ++++ .../annotation/result/ResultRepository.java | 5 +- .../annotation/result/ResultService.java | 107 +++++++++++++++++- .../ddl/results/annotation_result.sql | 5 +- .../sql/findResultsByAnnotationId.sql | 6 + .../annotationresult/sql/insertResults.sql | 3 + 8 files changed, 161 insertions(+), 18 deletions(-) create mode 100644 src/main/resources/resources/annotationresult/sql/findResultsByAnnotationId.sql create mode 100644 src/main/resources/resources/annotationresult/sql/insertResults.sql diff --git a/src/main/java/org/ohdsi/webapi/annotation/annotation/Annotation.java b/src/main/java/org/ohdsi/webapi/annotation/annotation/Annotation.java index 2ed0ad3127..ac0fe9ad5d 100644 --- a/src/main/java/org/ohdsi/webapi/annotation/annotation/Annotation.java +++ b/src/main/java/org/ohdsi/webapi/annotation/annotation/Annotation.java @@ -37,7 +37,7 @@ public class Annotation { // @Column(name = "sample_name") // private String sampleName; - + @ManyToOne @JoinColumn(name = "question_set_id") private QuestionSet questionSet; diff --git a/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationController.java b/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationController.java index 1471c728f0..f2f77e34d2 100644 --- a/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationController.java +++ b/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationController.java @@ -14,9 +14,12 @@ import org.json.JSONObject; import org.json.JSONArray; -import org.ohdsi.webapi.annotation.result.ResultRepository; +import org.ohdsi.webapi.annotation.result.ResultService; +import org.ohdsi.webapi.cohortsample.CohortSample; +import org.ohdsi.webapi.cohortsample.CohortSampleRepository; import org.ohdsi.webapi.cohortsample.CohortSamplingService; import org.ohdsi.webapi.cohortsample.dto.SampleElementDTO; +import org.ohdsi.webapi.source.Source; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Component; import org.ohdsi.webapi.annotation.annotation.AnnotationService; @@ -25,6 +28,7 @@ import org.ohdsi.webapi.annotation.set.QuestionSet; import org.ohdsi.webapi.annotation.result.Result; import org.springframework.web.bind.annotation.RequestBody; +import org.ohdsi.webapi.service.AbstractDaoService; @Path("annotations") @@ -32,7 +36,7 @@ public class AnnotationController { @Autowired - private ResultRepository resultRepository; + private ResultService resultService; @Autowired public CohortSamplingService cohortSamplingService; @@ -55,7 +59,7 @@ public List getAnnotations( returnAnnotations = getFullAnnotations(cohortSampleId,subjectId,setId); List summaries = new ArrayList(); for(Annotation singleAnno : returnAnnotations){ -// TODO see about doing this in a more performant matter? +// TODO see about doing this in a more performant manner? AnnotationSummary tempAnnoSummary=new AnnotationSummary(singleAnno); summaries.add(tempAnnoSummary); } @@ -108,16 +112,18 @@ public void addResult(@RequestBody String payload) { ,Integer.parseInt(jsonpayload.get("subjectId").toString()),Integer.parseInt(jsonpayload.get("setId").toString())).get(0); System.out.printf("annotationID:%d\n",tempAnnotation.getId()); JSONArray array = jsonpayload.getJSONArray("results"); - for(int i=0; i < array.length(); i++){ - JSONObject object = array.getJSONObject(i); - Result result = new Result(); - result.setQuestionId(Long.parseLong(object.get("questionId").toString())); - result.setAnswerId(Long.parseLong(object.get("answerId").toString())); - result.setValue(object.get("value").toString()); - result.setType(object.get("type").toString()); - result.setAnnotation(tempAnnotation); - resultRepository.save(result); - } + + resultService.insertResults(tempAnnotation,array); +// for(int i=0; i < array.length(); i++){ +// JSONObject object = array.getJSONObject(i); +// Result result = new Result(); +// result.setQuestionId(Long.parseLong(object.get("questionId").toString())); +// result.setAnswerId(Long.parseLong(object.get("answerId").toString())); +// result.setValue(object.get("value").toString()); +// result.setType(object.get("type").toString()); +// result.setAnnotation(tempAnnotation); +// resultService.save(result); +// } } @POST diff --git a/src/main/java/org/ohdsi/webapi/annotation/result/ResultController.java b/src/main/java/org/ohdsi/webapi/annotation/result/ResultController.java index 40c69aeba6..348429d58e 100644 --- a/src/main/java/org/ohdsi/webapi/annotation/result/ResultController.java +++ b/src/main/java/org/ohdsi/webapi/annotation/result/ResultController.java @@ -5,6 +5,7 @@ import org.ohdsi.webapi.annotation.annotation.Annotation; import org.ohdsi.webapi.annotation.annotation.AnnotationService; +import org.ohdsi.webapi.annotation.annotation.AnnotationSummary; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Component; import org.ohdsi.webapi.annotation.result.ResultService; @@ -41,4 +42,22 @@ public ArrayList getResults(@PathParam("annotationID") String annotationID) { } return al; } + + @GET + @Path("/") + @Produces(MediaType.APPLICATION_JSON) + public List getResults( + @QueryParam("questionId") final int questionId + ) { + List results = null; + List blah = annotationService.getAnnotationsByQuestionSetId(questionId); + return results; + } + + @Path("/{cohortDefinitionId}/{sourceKey}") + @POST + @Consumes(MediaType.APPLICATION_JSON) + public void createResult(){ + + } } diff --git a/src/main/java/org/ohdsi/webapi/annotation/result/ResultRepository.java b/src/main/java/org/ohdsi/webapi/annotation/result/ResultRepository.java index 645e80b2d6..097f9971da 100644 --- a/src/main/java/org/ohdsi/webapi/annotation/result/ResultRepository.java +++ b/src/main/java/org/ohdsi/webapi/annotation/result/ResultRepository.java @@ -17,8 +17,11 @@ public interface ResultRepository extends JpaRepository { // public Set findBySampleNameAndSubjectId(String sampleName, Long subject_id); @Query("select s.value from Result s where s.annotation=?1 and s.questionId = ?2") - public Set getAnswers(Annotation annotation, Long questionID); + public Set getAnswers(Annotation annotation, int questionID); @Query("select r FROM Result r WHERE r.annotation.id = ?1") List findByAnnotationId(int annotationId); + + @Query("select r FROM Result r WHERE r.questionId = ?1") + List findByQuestionId(int questionId); } diff --git a/src/main/java/org/ohdsi/webapi/annotation/result/ResultService.java b/src/main/java/org/ohdsi/webapi/annotation/result/ResultService.java index 0897ac43b8..c64e8f1105 100644 --- a/src/main/java/org/ohdsi/webapi/annotation/result/ResultService.java +++ b/src/main/java/org/ohdsi/webapi/annotation/result/ResultService.java @@ -1,21 +1,126 @@ package org.ohdsi.webapi.annotation.result; +import org.json.JSONArray; +import org.json.JSONObject; import org.ohdsi.webapi.annotation.annotation.Annotation; +import org.ohdsi.webapi.annotation.annotation.AnnotationService; import org.ohdsi.webapi.annotation.result.Result; import org.ohdsi.webapi.annotation.result.ResultRepository; +import org.ohdsi.webapi.cohortsample.CohortSample; +import org.ohdsi.webapi.cohortsample.CohortSampleRepository; +import org.ohdsi.webapi.cohortsample.CohortSamplingService; +import org.ohdsi.webapi.cohortsample.SampleElement; +import org.ohdsi.webapi.service.AbstractDaoService; +import org.ohdsi.webapi.source.Source; +import org.ohdsi.webapi.source.SourceDaimon; import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.jdbc.core.JdbcTemplate; +import org.springframework.jdbc.core.RowMapper; import org.springframework.stereotype.Service; +import org.ohdsi.webapi.util.PreparedStatementRenderer; +import javax.ws.rs.Consumes; +import javax.ws.rs.POST; +import javax.ws.rs.Path; +import javax.ws.rs.core.MediaType; +import java.sql.ResultSet; +import java.sql.SQLException; +import java.util.ArrayList; +import java.util.Collection; +import java.util.Collections; import java.util.List; @Service -public class ResultService { +public class ResultService extends AbstractDaoService { + + @Autowired + private CohortSampleRepository sampleRepository; @Autowired private ResultRepository resultRepository; + @Autowired + private AnnotationService annotationService; + public List getResultsByAnnotationID(int AnnotationID) { return resultRepository.findByAnnotationId(AnnotationID); } + public Result getLatestResultByAnnotationID(int AnnotationID){ + Result result= null; + Annotation ourAnno =annotationService.getAnnotationsByAnnotationId(AnnotationID); + CohortSample sample = sampleRepository.findById(ourAnno.getCohortSampleId()); + Source source = getSourceRepository().findBySourceId(sample.getSourceId()); + JdbcTemplate jdbcTemplate = getSourceJdbcTemplate(source); + PreparedStatementRenderer renderer = new PreparedStatementRenderer(source, "/resources/annotationresult/sql/findResultsByAnnotationId.sql", + new String[]{"results_schema", "CDM_schema"}, + new String[]{source.getTableQualifier(SourceDaimon.DaimonType.Results), source.getTableQualifier(SourceDaimon.DaimonType.CDM)}, + "annotationId", AnnotationID); + Collection optionalFields = Collections.emptySet(); + return jdbcTemplate.query(renderer.getSql(), renderer.getOrderedParams(),new ResultRowMapper(optionalFields)).get(0); + } + + public List findByQuestionId(int questionID) { + return resultRepository.findByQuestionId(questionID); + } + + public void insertResults(Annotation annotation, JSONArray results) { +// might want to do a check- if the annotation ID+question ID already exists, update the existing row instead. Other option is just only query the latest instead + CohortSample sample = sampleRepository.findById(annotation.getCohortSampleId()); + Source source = getSourceRepository().findBySourceId(sample.getSourceId()); + JdbcTemplate jdbcTemplate = getSourceJdbcTemplate(source); + if (results.isNull(0)) { + return; + } + + String[] parameters = new String[] { "results_schema" }; + String[] parameterValues = new String[] { source.getTableQualifier(SourceDaimon.DaimonType.Results) }; + String[] sqlParameters = new String[] { "annotation_id", "question_id", "answer_id", "value", "type" }; + + String statement = null; + List variables = new ArrayList<>(results.length()); + for(int i=0; i < results.length(); i++){ + JSONObject object = results.getJSONObject(i); + Object[] sqlValues = new Object[] { + annotation.getId(), + Long.parseLong(object.get("questionId").toString()), + Long.parseLong(object.get("answerId").toString()), + object.get("value").toString(), + object.get("type").toString() }; + + PreparedStatementRenderer renderer = new PreparedStatementRenderer(source, "/resources/annotationresult/sql/insertResults.sql", parameters, parameterValues, sqlParameters, sqlValues); + + if (statement == null) { + statement = renderer.getSql(); + System.out.printf("statement: %s\n",statement); + } + + variables.add(renderer.getOrderedParams()); + } + System.out.printf("variables: %s\n",variables); + jdbcTemplate.batchUpdate(statement, variables); + } + + /** Maps a SQL result to a sample element. */ + private static class ResultRowMapper implements RowMapper { + private final Collection optionalFields; + + @Autowired + private AnnotationService annotationService; + + ResultRowMapper(Collection optionalFields) { + this.optionalFields = optionalFields; + } + + @Override + public Result mapRow(ResultSet rs, int rowNum) throws SQLException { + Result result = new Result(); + result.setAnnotation(annotationService.getAnnotationsByAnnotationId(rs.getInt("annotation_id"))); + result.setQuestionId(rs.getLong("question_id")); + result.setAnswerId(rs.getLong("answer_id")); + result.setValue(rs.getString("value")); + result.setType(rs.getString("type")); + return result; + } + } } diff --git a/src/main/resources/ddl/results/annotation_result.sql b/src/main/resources/ddl/results/annotation_result.sql index eced18c5d0..ab37468bf9 100644 --- a/src/main/resources/ddl/results/annotation_result.sql +++ b/src/main/resources/ddl/results/annotation_result.sql @@ -1,9 +1,10 @@ IF OBJECT_ID('@results_schema.annotation_result', 'U') IS NULL CREATE TABLE @results_schema.annotation_result( - result_id integer NOT NULL, + result_id integer NOT NULL AUTO_INCREMENT, annotation_id integer NOT NULL, question_id integer NOT NULL, answer_id bigint NOT NULL, value VARCHAR(255) NOT NULL, - type VARCHAR(255) NOT NULL + type VARCHAR(255) NOT NULL, + last_update_time datetime DEFAULT GETDATE() ); diff --git a/src/main/resources/resources/annotationresult/sql/findResultsByAnnotationId.sql b/src/main/resources/resources/annotationresult/sql/findResultsByAnnotationId.sql new file mode 100644 index 0000000000..40cfa30e31 --- /dev/null +++ b/src/main/resources/resources/annotationresult/sql/findResultsByAnnotationId.sql @@ -0,0 +1,6 @@ +SELECT * +FROM @results_schema.annotation_result s +WHERE s.annotation_id = @annotationId +ORDER BY last_update_time DESC +LIMIT 1 +; \ No newline at end of file diff --git a/src/main/resources/resources/annotationresult/sql/insertResults.sql b/src/main/resources/resources/annotationresult/sql/insertResults.sql new file mode 100644 index 0000000000..57ae8aa88a --- /dev/null +++ b/src/main/resources/resources/annotationresult/sql/insertResults.sql @@ -0,0 +1,3 @@ +INSERT INTO @results_schema.annotation_result (annotation_id, question_id, answer_id, value, type) +VALUES (@annotation_id, @question_id, @answer_id, @value, @type) +; From b002dfe488627197a52ba7e830417d75cbd6bb95 Mon Sep 17 00:00:00 2001 From: Saul Crumpton Date: Thu, 29 Jul 2021 18:40:25 -0400 Subject: [PATCH 16/55] working insertion and 'updating'. Tomorrow will change all QuestionID references to QuestionSetId --- .../annotation/AnnotationController.java | 11 +++ .../annotation/AnnotationService.java | 9 +- .../webapi/annotation/result/Result.java | 18 ++-- .../annotation/result/ResultController.java | 4 +- .../annotation/result/ResultService.java | 91 +++++++++++++++---- ...leteResultsByAnnotationIdAndQuestionId.sql | 3 + .../sql/findResultsByAnnotationId.sql | 4 +- ...findResultsByAnnotationIdAndQuestionId.sql | 4 + .../sql/findResultsByQuestionSetId.sql | 4 + .../annotationresult/sql/updateResults.sql | 4 + 10 files changed, 116 insertions(+), 36 deletions(-) create mode 100644 src/main/resources/resources/annotationresult/sql/deleteResultsByAnnotationIdAndQuestionId.sql create mode 100644 src/main/resources/resources/annotationresult/sql/findResultsByAnnotationIdAndQuestionId.sql create mode 100644 src/main/resources/resources/annotationresult/sql/findResultsByQuestionSetId.sql create mode 100644 src/main/resources/resources/annotationresult/sql/updateResults.sql diff --git a/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationController.java b/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationController.java index f2f77e34d2..db9362e6f5 100644 --- a/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationController.java +++ b/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationController.java @@ -1,6 +1,7 @@ package org.ohdsi.webapi.annotation.annotation; import java.util.ArrayList; +import java.util.HashMap; import java.util.List; import java.util.Map; import javax.ws.rs.GET; @@ -182,4 +183,14 @@ public List getAnnotationCSV( return annotationService.getAnnotationCSVData(cohortID, sourceKey, sampleName); } + + @GET + @Path("/{annotationID}") + @Produces(MediaType.APPLICATION_JSON) + public Annotation getResults(@PathParam("annotationID") String annotationID) { + int annotationIdInt=Integer.parseInt(annotationID); + Annotation ourAnno =annotationService.getAnnotationsByAnnotationId(annotationIdInt); + return ourAnno; + } } + diff --git a/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationService.java b/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationService.java index 83aa3d2669..396c97c96d 100644 --- a/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationService.java +++ b/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationService.java @@ -38,9 +38,12 @@ public List getAnnotations() { return annotations; } - public Annotation getAnnotationsByAnnotationId(int annotationId) { - return annotationRepository.findByAnnotationId(annotationId); - } + public Annotation getAnnotationsByAnnotationId(int annotationId) { + System.out.printf("looking for annotation %s \n",annotationId); + Annotation result = annotationRepository.findByAnnotationId(annotationId); + System.out.printf("found annotation: %s \n",result.getId()); + return result; + } public List getAnnotationByCohortSampleIdAndBySubjectIdAndByQuestionSetId(int cohortSampleId, int subjectId, int questionSetId) { System.out.printf("cohortSampleId %d\n",cohortSampleId); diff --git a/src/main/java/org/ohdsi/webapi/annotation/result/Result.java b/src/main/java/org/ohdsi/webapi/annotation/result/Result.java index 27e009a971..4db11dcd71 100644 --- a/src/main/java/org/ohdsi/webapi/annotation/result/Result.java +++ b/src/main/java/org/ohdsi/webapi/annotation/result/Result.java @@ -18,7 +18,7 @@ public class Result { @Id @GeneratedValue @Column(name = "result_id") - private Long id; + private int id; @JsonIgnore @ManyToOne(fetch = FetchType.LAZY) @@ -26,10 +26,10 @@ public class Result { private Annotation annotation; @Column(name = "question_id") - private Long questionId; + private int questionId; @Column(name = "answer_id") - private Long answerId; + private int answerId; //need charity's help here! these can all be retrieved from the annotation_id // @JsonIgnore @@ -54,14 +54,14 @@ public class Result { /** * @return the id */ - public Long getId() { + public int getId() { return id; } /** * @param id the id to set */ - public void setId(Long id) { + public void setId(int id) { this.id = id; } @@ -96,14 +96,14 @@ public void setAnnotation(Annotation annotation) { /** * @return the answerId */ - public Long getAnswerId() { + public int getAnswerId() { return answerId; } /** * @param answerId the answerId to set */ - public void setAnswerId(Long answerId) { + public void setAnswerId(int answerId) { this.answerId = answerId; } @@ -124,14 +124,14 @@ public void setAnswerId(Long answerId) { /** * @return the questionId */ - public Long getQuestionId() { + public int getQuestionId() { return questionId; } /** * @param questionId the questionId to set */ - public void setQuestionId(Long questionId) { + public void setQuestionId(int questionId) { this.questionId = questionId; } diff --git a/src/main/java/org/ohdsi/webapi/annotation/result/ResultController.java b/src/main/java/org/ohdsi/webapi/annotation/result/ResultController.java index 348429d58e..268d326ed4 100644 --- a/src/main/java/org/ohdsi/webapi/annotation/result/ResultController.java +++ b/src/main/java/org/ohdsi/webapi/annotation/result/ResultController.java @@ -35,8 +35,8 @@ public ArrayList getResults(@PathParam("annotationID") String annotationID) { for(Result tempResult : tempResults ){ System.out.println(tempResult); Map testDict =new HashMap(); - testDict.put("questionId",tempResult.getQuestionId().toString()); - testDict.put("answerId",tempResult.getAnswerId().toString()); + testDict.put("questionId",String.valueOf(tempResult.getQuestionId())); + testDict.put("answerId",String.valueOf(tempResult.getAnswerId())); testDict.put("subjectId",Integer.toString(ourAnno.getSubjectId())); al.add(testDict); } diff --git a/src/main/java/org/ohdsi/webapi/annotation/result/ResultService.java b/src/main/java/org/ohdsi/webapi/annotation/result/ResultService.java index c64e8f1105..872a393af6 100644 --- a/src/main/java/org/ohdsi/webapi/annotation/result/ResultService.java +++ b/src/main/java/org/ohdsi/webapi/annotation/result/ResultService.java @@ -42,11 +42,11 @@ public class ResultService extends AbstractDaoService { @Autowired private AnnotationService annotationService; - public List getResultsByAnnotationID(int AnnotationID) { - return resultRepository.findByAnnotationId(AnnotationID); - } +// public List getResultsByAnnotationID(int AnnotationID) { +// return resultRepository.findByAnnotationId(AnnotationID); +// } - public Result getLatestResultByAnnotationID(int AnnotationID){ + public List getResultsByAnnotationID(int AnnotationID){ Result result= null; Annotation ourAnno =annotationService.getAnnotationsByAnnotationId(AnnotationID); CohortSample sample = sampleRepository.findById(ourAnno.getCohortSampleId()); @@ -55,15 +55,49 @@ public Result getLatestResultByAnnotationID(int AnnotationID){ PreparedStatementRenderer renderer = new PreparedStatementRenderer(source, "/resources/annotationresult/sql/findResultsByAnnotationId.sql", new String[]{"results_schema", "CDM_schema"}, new String[]{source.getTableQualifier(SourceDaimon.DaimonType.Results), source.getTableQualifier(SourceDaimon.DaimonType.CDM)}, - "annotationId", AnnotationID); + "annotation_id", AnnotationID); Collection optionalFields = Collections.emptySet(); - return jdbcTemplate.query(renderer.getSql(), renderer.getOrderedParams(),new ResultRowMapper(optionalFields)).get(0); + return jdbcTemplate.query(renderer.getSql(), renderer.getOrderedParams(),new ResultRowMapper(optionalFields)); } - public List findByQuestionId(int questionID) { - return resultRepository.findByQuestionId(questionID); + public Result getResultByAnnotationIDAndQuestionID(int AnnotationID,int QuestionID){ + System.out.printf("checking for result with questionID:%s and annotationID:%s \n",QuestionID,AnnotationID); + Annotation ourAnno =annotationService.getAnnotationsByAnnotationId(AnnotationID); + CohortSample sample = sampleRepository.findById(ourAnno.getCohortSampleId()); + Source source = getSourceRepository().findBySourceId(sample.getSourceId()); + JdbcTemplate jdbcTemplate = getSourceJdbcTemplate(source); + String[] sqlParameters = new String[] { "annotation_id", "question_id"}; + Object[] sqlValues = new Object[] {AnnotationID,QuestionID}; + PreparedStatementRenderer renderer = new PreparedStatementRenderer(source, "/resources/annotationresult/sql/findResultsByAnnotationIdAndQuestionId.sql", + new String[]{"results_schema", "CDM_schema"}, + new String[]{source.getTableQualifier(SourceDaimon.DaimonType.Results), source.getTableQualifier(SourceDaimon.DaimonType.CDM)}, + sqlParameters, sqlValues); + Collection optionalFields = Collections.emptySet(); + System.out.printf("Running query: %s with params: %s\n",renderer.getSql(),renderer.getOrderedParams().toString()); + List results= jdbcTemplate.query(renderer.getSql(), renderer.getOrderedParams(),new ResultRowMapper(optionalFields)); + if (results.isEmpty()){ + return null; + } + return results.get(0); } +// public List findByQuestionSetId(List questionIDs) { +// Result result= null; +// for(int question : questionIDs){ +// Annotation ourAnno =annotationService.getAnnotationsByQuestionSetId(question); +// } +// Annotation ourAnno =annotationService.getAnnotationsByAnnotationId(AnnotationID); +// CohortSample sample = sampleRepository.findById(ourAnno.getCohortSampleId()); +// Source source = getSourceRepository().findBySourceId(sample.getSourceId()); +// JdbcTemplate jdbcTemplate = getSourceJdbcTemplate(source); +// PreparedStatementRenderer renderer = new PreparedStatementRenderer(source, "/resources/annotationresult/sql/findResultsByQuestionSetId.sql", +// new String[]{"results_schema", "CDM_schema"}, +// new String[]{source.getTableQualifier(SourceDaimon.DaimonType.Results), source.getTableQualifier(SourceDaimon.DaimonType.CDM)}, +// "annotationId","questionId", AnnotationID); +// Collection optionalFields = Collections.emptySet(); +// return jdbcTemplate.query(renderer.getSql(), renderer.getOrderedParams(),new ResultRowMapper(optionalFields)).get(0); +// } + public void insertResults(Annotation annotation, JSONArray results) { // might want to do a check- if the annotation ID+question ID already exists, update the existing row instead. Other option is just only query the latest instead CohortSample sample = sampleRepository.findById(annotation.getCohortSampleId()); @@ -78,13 +112,25 @@ public void insertResults(Annotation annotation, JSONArray results) { String[] sqlParameters = new String[] { "annotation_id", "question_id", "answer_id", "value", "type" }; String statement = null; - List variables = new ArrayList<>(results.length()); + List variables = new ArrayList<>(); + List deleteVariables = new ArrayList<>(); + Boolean hasCleared=false; for(int i=0; i < results.length(); i++){ JSONObject object = results.getJSONObject(i); + if(!hasCleared && getResultByAnnotationIDAndQuestionID(annotation.getId(),Integer.parseInt(object.get("questionId").toString()))!=null){ +// this entry already exists, need to update here instead of adding to the pile + String[] deletesqlParameters = new String[] { "annotation_id", "question_id"}; + Object[] deletesqlValues = new Object[] {annotation.getId(),Integer.parseInt(object.get("questionId").toString())}; + PreparedStatementRenderer deleterenderer = new PreparedStatementRenderer(source, "/resources/annotationresult/sql/deleteResultsByAnnotationIdAndQuestionId.sql", parameters, parameterValues, deletesqlParameters, deletesqlValues); + String deleteStatement = deleterenderer.getSql(); + deleteVariables.add(deleterenderer.getOrderedParams()); + jdbcTemplate.batchUpdate(deleteStatement, deleteVariables); + hasCleared=true; + } Object[] sqlValues = new Object[] { annotation.getId(), - Long.parseLong(object.get("questionId").toString()), - Long.parseLong(object.get("answerId").toString()), + Integer.parseInt(object.get("questionId").toString()), + Integer.parseInt(object.get("answerId").toString()), object.get("value").toString(), object.get("type").toString() }; @@ -97,27 +143,34 @@ public void insertResults(Annotation annotation, JSONArray results) { variables.add(renderer.getOrderedParams()); } - System.out.printf("variables: %s\n",variables); + System.out.printf("variables: %s\n",variables.toArray().toString()); jdbcTemplate.batchUpdate(statement, variables); } /** Maps a SQL result to a sample element. */ - private static class ResultRowMapper implements RowMapper { + private class ResultRowMapper implements RowMapper { private final Collection optionalFields; - @Autowired - private AnnotationService annotationService; - ResultRowMapper(Collection optionalFields) { this.optionalFields = optionalFields; } @Override public Result mapRow(ResultSet rs, int rowNum) throws SQLException { + int AnnotationIdInt=rs.getInt("annotation_id"); + if(AnnotationIdInt == 0){ + System.out.println("Annotation was null, none found"); + return null; + } Result result = new Result(); - result.setAnnotation(annotationService.getAnnotationsByAnnotationId(rs.getInt("annotation_id"))); - result.setQuestionId(rs.getLong("question_id")); - result.setAnswerId(rs.getLong("answer_id")); + Annotation tempAnno = annotationService.getAnnotationsByAnnotationId(AnnotationIdInt); + if(tempAnno == null){ + System.out.println("Annotation was null, none found"); + return null; + } + result.setAnnotation(tempAnno); + result.setQuestionId(rs.getInt("question_id")); + result.setAnswerId(rs.getInt("answer_id")); result.setValue(rs.getString("value")); result.setType(rs.getString("type")); return result; diff --git a/src/main/resources/resources/annotationresult/sql/deleteResultsByAnnotationIdAndQuestionId.sql b/src/main/resources/resources/annotationresult/sql/deleteResultsByAnnotationIdAndQuestionId.sql new file mode 100644 index 0000000000..041c00cf27 --- /dev/null +++ b/src/main/resources/resources/annotationresult/sql/deleteResultsByAnnotationIdAndQuestionId.sql @@ -0,0 +1,3 @@ +DELETE FROM @results_schema.annotation_result +WHERE annotation_id = @annotation_id AND question_id = @question_id +; diff --git a/src/main/resources/resources/annotationresult/sql/findResultsByAnnotationId.sql b/src/main/resources/resources/annotationresult/sql/findResultsByAnnotationId.sql index 40cfa30e31..aa8cb669c5 100644 --- a/src/main/resources/resources/annotationresult/sql/findResultsByAnnotationId.sql +++ b/src/main/resources/resources/annotationresult/sql/findResultsByAnnotationId.sql @@ -1,6 +1,4 @@ SELECT * FROM @results_schema.annotation_result s -WHERE s.annotation_id = @annotationId -ORDER BY last_update_time DESC -LIMIT 1 +WHERE s.annotation_id = @annotation_id ; \ No newline at end of file diff --git a/src/main/resources/resources/annotationresult/sql/findResultsByAnnotationIdAndQuestionId.sql b/src/main/resources/resources/annotationresult/sql/findResultsByAnnotationIdAndQuestionId.sql new file mode 100644 index 0000000000..1e42dcda96 --- /dev/null +++ b/src/main/resources/resources/annotationresult/sql/findResultsByAnnotationIdAndQuestionId.sql @@ -0,0 +1,4 @@ +SELECT * +FROM @results_schema.annotation_result s +WHERE s.annotation_id = @annotation_id AND s.question_id = @question_id +; \ No newline at end of file diff --git a/src/main/resources/resources/annotationresult/sql/findResultsByQuestionSetId.sql b/src/main/resources/resources/annotationresult/sql/findResultsByQuestionSetId.sql new file mode 100644 index 0000000000..1200f5c516 --- /dev/null +++ b/src/main/resources/resources/annotationresult/sql/findResultsByQuestionSetId.sql @@ -0,0 +1,4 @@ +SELECT * +FROM @results_schema.annotation_result s +WHERE s.question_id in (@annotationId) +; \ No newline at end of file diff --git a/src/main/resources/resources/annotationresult/sql/updateResults.sql b/src/main/resources/resources/annotationresult/sql/updateResults.sql new file mode 100644 index 0000000000..ab4178888a --- /dev/null +++ b/src/main/resources/resources/annotationresult/sql/updateResults.sql @@ -0,0 +1,4 @@ +UPDATE @results_schema.annotation_result +SET answer_id = @answer_id, value = @value, last_update_time=GETDATE() +WHERE annotation_id = @annotation_id AND question_id = @question_id +; From 348e67c077f57ff2f1eace8b13141f315ea3df54 Mon Sep 17 00:00:00 2001 From: Saul Crumpton Date: Fri, 30 Jul 2021 13:31:42 -0400 Subject: [PATCH 17/55] working results by Question Set ID, albiet slow --- .../annotation/result/ResultController.java | 6 +- .../annotation/result/ResultService.java | 58 ++++++++++--------- 2 files changed, 34 insertions(+), 30 deletions(-) diff --git a/src/main/java/org/ohdsi/webapi/annotation/result/ResultController.java b/src/main/java/org/ohdsi/webapi/annotation/result/ResultController.java index 268d326ed4..aaa04868b9 100644 --- a/src/main/java/org/ohdsi/webapi/annotation/result/ResultController.java +++ b/src/main/java/org/ohdsi/webapi/annotation/result/ResultController.java @@ -47,11 +47,9 @@ public ArrayList getResults(@PathParam("annotationID") String annotationID) { @Path("/") @Produces(MediaType.APPLICATION_JSON) public List getResults( - @QueryParam("questionId") final int questionId + @QueryParam("questionSetId") final int questionId ) { - List results = null; - List blah = annotationService.getAnnotationsByQuestionSetId(questionId); - return results; + return resultService.getResultsByQuestionSetId(questionId); } @Path("/{cohortDefinitionId}/{sourceKey}") diff --git a/src/main/java/org/ohdsi/webapi/annotation/result/ResultService.java b/src/main/java/org/ohdsi/webapi/annotation/result/ResultService.java index 872a393af6..89c555d1f2 100644 --- a/src/main/java/org/ohdsi/webapi/annotation/result/ResultService.java +++ b/src/main/java/org/ohdsi/webapi/annotation/result/ResultService.java @@ -47,15 +47,18 @@ public class ResultService extends AbstractDaoService { // } public List getResultsByAnnotationID(int AnnotationID){ - Result result= null; Annotation ourAnno =annotationService.getAnnotationsByAnnotationId(AnnotationID); - CohortSample sample = sampleRepository.findById(ourAnno.getCohortSampleId()); + return getResultsByAnnotation(ourAnno); + } + + public List getResultsByAnnotation(Annotation annotation){ + CohortSample sample = sampleRepository.findById(annotation.getCohortSampleId()); Source source = getSourceRepository().findBySourceId(sample.getSourceId()); JdbcTemplate jdbcTemplate = getSourceJdbcTemplate(source); PreparedStatementRenderer renderer = new PreparedStatementRenderer(source, "/resources/annotationresult/sql/findResultsByAnnotationId.sql", new String[]{"results_schema", "CDM_schema"}, new String[]{source.getTableQualifier(SourceDaimon.DaimonType.Results), source.getTableQualifier(SourceDaimon.DaimonType.CDM)}, - "annotation_id", AnnotationID); + "annotation_id", annotation.getId()); Collection optionalFields = Collections.emptySet(); return jdbcTemplate.query(renderer.getSql(), renderer.getOrderedParams(),new ResultRowMapper(optionalFields)); } @@ -81,22 +84,30 @@ public Result getResultByAnnotationIDAndQuestionID(int AnnotationID,int Question return results.get(0); } -// public List findByQuestionSetId(List questionIDs) { -// Result result= null; -// for(int question : questionIDs){ -// Annotation ourAnno =annotationService.getAnnotationsByQuestionSetId(question); -// } -// Annotation ourAnno =annotationService.getAnnotationsByAnnotationId(AnnotationID); -// CohortSample sample = sampleRepository.findById(ourAnno.getCohortSampleId()); -// Source source = getSourceRepository().findBySourceId(sample.getSourceId()); -// JdbcTemplate jdbcTemplate = getSourceJdbcTemplate(source); -// PreparedStatementRenderer renderer = new PreparedStatementRenderer(source, "/resources/annotationresult/sql/findResultsByQuestionSetId.sql", -// new String[]{"results_schema", "CDM_schema"}, -// new String[]{source.getTableQualifier(SourceDaimon.DaimonType.Results), source.getTableQualifier(SourceDaimon.DaimonType.CDM)}, -// "annotationId","questionId", AnnotationID); -// Collection optionalFields = Collections.emptySet(); -// return jdbcTemplate.query(renderer.getSql(), renderer.getOrderedParams(),new ResultRowMapper(optionalFields)).get(0); -// } + public List getResultsByQuestionSetId(int questionSetId) { + List results = new ArrayList(); + List annos=annotationService.getAnnotationsByQuestionSetId(questionSetId); + + for(Annotation anno : annos){ + results.addAll(getResultsByAnnotation(anno)); + } + return results; + } + + public void deleteResultsByAnnotationIdAndQuestionId(Annotation annotation,int questionId){ + List deleteVariables = new ArrayList<>(); + CohortSample sample = sampleRepository.findById(annotation.getCohortSampleId()); + Source source = getSourceRepository().findBySourceId(sample.getSourceId()); + JdbcTemplate jdbcTemplate = getSourceJdbcTemplate(source); + String[] parameters = new String[] { "results_schema" }; + String[] parameterValues = new String[] { source.getTableQualifier(SourceDaimon.DaimonType.Results) }; + String[] deletesqlParameters = new String[] { "annotation_id", "question_id"}; + Object[] deletesqlValues = new Object[] {annotation.getId(),questionId}; + PreparedStatementRenderer deleterenderer = new PreparedStatementRenderer(source, "/resources/annotationresult/sql/deleteResultsByAnnotationIdAndQuestionId.sql", parameters, parameterValues, deletesqlParameters, deletesqlValues); + String deleteStatement = deleterenderer.getSql(); + deleteVariables.add(deleterenderer.getOrderedParams()); + jdbcTemplate.batchUpdate(deleteStatement, deleteVariables); + } public void insertResults(Annotation annotation, JSONArray results) { // might want to do a check- if the annotation ID+question ID already exists, update the existing row instead. Other option is just only query the latest instead @@ -113,18 +124,12 @@ public void insertResults(Annotation annotation, JSONArray results) { String statement = null; List variables = new ArrayList<>(); - List deleteVariables = new ArrayList<>(); Boolean hasCleared=false; for(int i=0; i < results.length(); i++){ JSONObject object = results.getJSONObject(i); if(!hasCleared && getResultByAnnotationIDAndQuestionID(annotation.getId(),Integer.parseInt(object.get("questionId").toString()))!=null){ // this entry already exists, need to update here instead of adding to the pile - String[] deletesqlParameters = new String[] { "annotation_id", "question_id"}; - Object[] deletesqlValues = new Object[] {annotation.getId(),Integer.parseInt(object.get("questionId").toString())}; - PreparedStatementRenderer deleterenderer = new PreparedStatementRenderer(source, "/resources/annotationresult/sql/deleteResultsByAnnotationIdAndQuestionId.sql", parameters, parameterValues, deletesqlParameters, deletesqlValues); - String deleteStatement = deleterenderer.getSql(); - deleteVariables.add(deleterenderer.getOrderedParams()); - jdbcTemplate.batchUpdate(deleteStatement, deleteVariables); + deleteResultsByAnnotationIdAndQuestionId(annotation,Integer.parseInt(object.get("questionId").toString())); hasCleared=true; } Object[] sqlValues = new Object[] { @@ -169,6 +174,7 @@ public Result mapRow(ResultSet rs, int rowNum) throws SQLException { return null; } result.setAnnotation(tempAnno); + result.setId(rs.getInt("result_id")); result.setQuestionId(rs.getInt("question_id")); result.setAnswerId(rs.getInt("answer_id")); result.setValue(rs.getString("value")); From 1326f9a1639ad1d8b6398d0ffe772890b987ac82 Mon Sep 17 00:00:00 2001 From: Saul Crumpton Date: Fri, 30 Jul 2021 15:40:06 -0400 Subject: [PATCH 18/55] querying for results based on QuestionSetId now is much faster --- .../annotation/result/ResultService.java | 41 ++++++++++++++----- .../sql/findResultsByAnnotationIds.sql | 4 ++ 2 files changed, 34 insertions(+), 11 deletions(-) create mode 100644 src/main/resources/resources/annotationresult/sql/findResultsByAnnotationIds.sql diff --git a/src/main/java/org/ohdsi/webapi/annotation/result/ResultService.java b/src/main/java/org/ohdsi/webapi/annotation/result/ResultService.java index 89c555d1f2..41b6419f70 100644 --- a/src/main/java/org/ohdsi/webapi/annotation/result/ResultService.java +++ b/src/main/java/org/ohdsi/webapi/annotation/result/ResultService.java @@ -1,5 +1,6 @@ package org.ohdsi.webapi.annotation.result; +import io.swagger.models.auth.In; import org.json.JSONArray; import org.json.JSONObject; import org.ohdsi.webapi.annotation.annotation.Annotation; @@ -29,6 +30,7 @@ import java.util.Collection; import java.util.Collections; import java.util.List; +import java.util.stream.Collectors; @Service public class ResultService extends AbstractDaoService { @@ -59,8 +61,24 @@ public List getResultsByAnnotation(Annotation annotation){ new String[]{"results_schema", "CDM_schema"}, new String[]{source.getTableQualifier(SourceDaimon.DaimonType.Results), source.getTableQualifier(SourceDaimon.DaimonType.CDM)}, "annotation_id", annotation.getId()); - Collection optionalFields = Collections.emptySet(); - return jdbcTemplate.query(renderer.getSql(), renderer.getOrderedParams(),new ResultRowMapper(optionalFields)); + return jdbcTemplate.query(renderer.getSql(),new ResultRowMapper()); + } + + public List getResultsByAnnotations(List annotations){ + String AnnotationIds=""+annotations.get(0).getId(); + int[] annotationIds = annotations.stream() + .mapToInt(Annotation::getId) + .toArray(); + System.out.println("AnnotationIDs: "+AnnotationIds); + CohortSample sample = sampleRepository.findById(annotations.get(0).getCohortSampleId()); + Source source = getSourceRepository().findBySourceId(sample.getSourceId()); + JdbcTemplate jdbcTemplate = getSourceJdbcTemplate(source); + PreparedStatementRenderer renderer = new PreparedStatementRenderer(source, "/resources/annotationresult/sql/findResultsByAnnotationIds.sql", + new String[]{"results_schema", "CDM_schema"}, + new String[]{source.getTableQualifier(SourceDaimon.DaimonType.Results), source.getTableQualifier(SourceDaimon.DaimonType.CDM)}, + "idList", annotationIds); + System.out.println(renderer); + return jdbcTemplate.query(renderer.getSql(),renderer.getOrderedParams(),new ResultRowMapper()); } public Result getResultByAnnotationIDAndQuestionID(int AnnotationID,int QuestionID){ @@ -75,21 +93,24 @@ public Result getResultByAnnotationIDAndQuestionID(int AnnotationID,int Question new String[]{"results_schema", "CDM_schema"}, new String[]{source.getTableQualifier(SourceDaimon.DaimonType.Results), source.getTableQualifier(SourceDaimon.DaimonType.CDM)}, sqlParameters, sqlValues); - Collection optionalFields = Collections.emptySet(); System.out.printf("Running query: %s with params: %s\n",renderer.getSql(),renderer.getOrderedParams().toString()); - List results= jdbcTemplate.query(renderer.getSql(), renderer.getOrderedParams(),new ResultRowMapper(optionalFields)); + List results= jdbcTemplate.query(renderer.getSql(), new ResultRowMapper()); if (results.isEmpty()){ return null; } return results.get(0); } - public List getResultsByQuestionSetId(int questionSetId) { + public List getResultsByQuestionSetId(int questionSetId) { List results = new ArrayList(); List annos=annotationService.getAnnotationsByQuestionSetId(questionSetId); - - for(Annotation anno : annos){ - results.addAll(getResultsByAnnotation(anno)); + List> collections = annos.stream() + .collect(Collectors.groupingBy(x -> x.getCohortSampleId())) + .entrySet().stream() + .map(e -> { ArrayList c = new ArrayList(); c.addAll(e.getValue()); return c; }) + .collect(Collectors.toList()); + for(ArrayList annoList : collections){ + results.addAll(getResultsByAnnotations(annoList)); } return results; } @@ -154,10 +175,8 @@ public void insertResults(Annotation annotation, JSONArray results) { /** Maps a SQL result to a sample element. */ private class ResultRowMapper implements RowMapper { - private final Collection optionalFields; - ResultRowMapper(Collection optionalFields) { - this.optionalFields = optionalFields; + ResultRowMapper() { } @Override diff --git a/src/main/resources/resources/annotationresult/sql/findResultsByAnnotationIds.sql b/src/main/resources/resources/annotationresult/sql/findResultsByAnnotationIds.sql new file mode 100644 index 0000000000..f9351990e5 --- /dev/null +++ b/src/main/resources/resources/annotationresult/sql/findResultsByAnnotationIds.sql @@ -0,0 +1,4 @@ +SELECT * +FROM @results_schema.annotation_result s +WHERE s.annotation_id IN ( @idList ) +; \ No newline at end of file From 791e3f97f7fb53294f5461aa75e5a42e7d6c1772 Mon Sep 17 00:00:00 2001 From: Saul Crumpton Date: Fri, 30 Jul 2021 15:50:24 -0400 Subject: [PATCH 19/55] adding in orderered params to all jdbcTemplate queries --- .../org/ohdsi/webapi/annotation/result/ResultService.java | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/main/java/org/ohdsi/webapi/annotation/result/ResultService.java b/src/main/java/org/ohdsi/webapi/annotation/result/ResultService.java index 41b6419f70..795044ef6f 100644 --- a/src/main/java/org/ohdsi/webapi/annotation/result/ResultService.java +++ b/src/main/java/org/ohdsi/webapi/annotation/result/ResultService.java @@ -61,7 +61,7 @@ public List getResultsByAnnotation(Annotation annotation){ new String[]{"results_schema", "CDM_schema"}, new String[]{source.getTableQualifier(SourceDaimon.DaimonType.Results), source.getTableQualifier(SourceDaimon.DaimonType.CDM)}, "annotation_id", annotation.getId()); - return jdbcTemplate.query(renderer.getSql(),new ResultRowMapper()); + return jdbcTemplate.query(renderer.getSql(),renderer.getOrderedParams(),new ResultRowMapper()); } public List getResultsByAnnotations(List annotations){ @@ -94,7 +94,7 @@ public Result getResultByAnnotationIDAndQuestionID(int AnnotationID,int Question new String[]{source.getTableQualifier(SourceDaimon.DaimonType.Results), source.getTableQualifier(SourceDaimon.DaimonType.CDM)}, sqlParameters, sqlValues); System.out.printf("Running query: %s with params: %s\n",renderer.getSql(),renderer.getOrderedParams().toString()); - List results= jdbcTemplate.query(renderer.getSql(), new ResultRowMapper()); + List results= jdbcTemplate.query(renderer.getSql(),renderer.getOrderedParams(), new ResultRowMapper()); if (results.isEmpty()){ return null; } From ba72b44b28d1390e5a7eeaeb4a1732fba071f4f7 Mon Sep 17 00:00:00 2001 From: Saul Crumpton Date: Fri, 30 Jul 2021 17:32:45 -0400 Subject: [PATCH 20/55] removed all instances/mentions of long and changed to int. Also fixed super table query --- .../annotation/AnnotationController.java | 10 +- .../annotation/AnnotationRepository.java | 2 +- .../annotation/AnnotationService.java | 15 ++- .../webapi/annotation/answer/Answer.java | 6 +- .../annotation/answer/AnswerRepository.java | 2 +- .../annotation/navigation/Navigation.java | 18 +-- .../navigation/NavigationController.java | 2 +- .../navigation/NavigationService.java | 10 +- .../webapi/annotation/question/Question.java | 6 +- .../question/QuestionRepository.java | 9 +- .../annotation/question/QuestionService.java | 4 + .../annotation/result/ResultController.java | 51 ++++++++ .../webapi/annotation/result/ResultDto.java | 12 +- .../annotation/result/ResultRepository.java | 2 +- .../annotation/result/SuperResultDto.java | 110 ++++++++++++++++++ .../annotation/set/QuestionSetRepository.java | 6 +- .../annotation/set/QuestionSetService.java | 3 + 17 files changed, 225 insertions(+), 43 deletions(-) create mode 100644 src/main/java/org/ohdsi/webapi/annotation/result/SuperResultDto.java diff --git a/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationController.java b/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationController.java index db9362e6f5..c123d35cdf 100644 --- a/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationController.java +++ b/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationController.java @@ -155,9 +155,9 @@ public void addAnnotation(AnnotationDto annotationDto) { @Path("/getsets") @Produces(MediaType.APPLICATION_JSON) public List getSets( - @QueryParam("cohortSampleId") final Long cohortSampleId, - @QueryParam("subjectId") final Long subjectId, - @QueryParam("setId") final Long setId + @QueryParam("cohortSampleId") final int cohortSampleId, + @QueryParam("subjectId") final int subjectId, + @QueryParam("setId") final int setId ) { return annotationService.getAnnotations(); } @@ -167,7 +167,7 @@ public List getSets( @GET @Produces(MediaType.APPLICATION_JSON) public List getAnnotationCSV( - @QueryParam("cohortID") Long cohortID, + @QueryParam("cohortID") int cohortID, @QueryParam("sourceKey") String sourceKey, @QueryParam("sampleName") String sampleName ) { @@ -176,7 +176,7 @@ public List getAnnotationCSV( sampleName = sampleName.replaceAll("_", " "); } - if (cohortID == null || sourceKey == null || sampleName == null) { + if (cohortID == 0 || sourceKey == null || sampleName == null) { return null; } diff --git a/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationRepository.java b/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationRepository.java index 16addacff8..a1048178cc 100644 --- a/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationRepository.java +++ b/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationRepository.java @@ -7,7 +7,7 @@ import org.springframework.data.jpa.repository.Query; import org.springframework.data.repository.query.Param; -public interface AnnotationRepository extends JpaRepository { +public interface AnnotationRepository extends JpaRepository { public Set findOneByCohortSampleIdAndSubjectIdAndQuestionSetId(int cohortSampleId, int subjectId, int questionSetId); public List findByCohortSampleIdAndQuestionSetId(int cohortSampleId, int questionSetId); diff --git a/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationService.java b/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationService.java index 396c97c96d..5f4799d6bd 100644 --- a/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationService.java +++ b/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationService.java @@ -39,12 +39,15 @@ public List getAnnotations() { } public Annotation getAnnotationsByAnnotationId(int annotationId) { - System.out.printf("looking for annotation %s \n",annotationId); Annotation result = annotationRepository.findByAnnotationId(annotationId); - System.out.printf("found annotation: %s \n",result.getId()); return result; } + public Annotation getAnnotationsByAnnotationId(Annotation annotation) { + Annotation result = annotationRepository.findByAnnotationId(annotation.getId()); + return result; + } + public List getAnnotationByCohortSampleIdAndBySubjectIdAndByQuestionSetId(int cohortSampleId, int subjectId, int questionSetId) { System.out.printf("cohortSampleId %d\n",cohortSampleId); System.out.printf("subjectId %d\n",subjectId); @@ -69,13 +72,13 @@ public Annotation addAnnotation(Annotation annotation, String name) { return annotationRepository.save(annotation); } - public List getAnnotationCSVData(Long cohortID, String source, String sampleName) { + public List getAnnotationCSVData(int cohortID, String source, String sampleName) { List results = new ArrayList(); // List samples = cohortSampleRepository.getSampleMembership(sampleName, cohortID); - List samples = new ArrayList(); - Set questionSet = questionSetRepository.findByCohortId(cohortID.intValue()); + List samples = new ArrayList(); + Set questionSet = questionSetRepository.findByCohortId(cohortID); List qs = new ArrayList(questionSet); - List qIDs = new ArrayList(); + List qIDs = new ArrayList(); for (Question q: qs.get(0).getQuestions()) { qIDs.add(q.getId()); diff --git a/src/main/java/org/ohdsi/webapi/annotation/answer/Answer.java b/src/main/java/org/ohdsi/webapi/annotation/answer/Answer.java index f3ad65870c..3a6fc7add7 100644 --- a/src/main/java/org/ohdsi/webapi/annotation/answer/Answer.java +++ b/src/main/java/org/ohdsi/webapi/annotation/answer/Answer.java @@ -19,7 +19,7 @@ public class Answer { @Id @GeneratedValue @Column(name = "answer_id") - private Long id; + private int id; @JsonIgnore @ManyToOne(fetch = FetchType.LAZY) @@ -40,14 +40,14 @@ public class Answer { /** * @return the id */ - public Long getId() { + public int getId() { return id; } /** * @param id the id to set */ - public void setId(Long id) { + public void setId(int id) { this.id = id; } diff --git a/src/main/java/org/ohdsi/webapi/annotation/answer/AnswerRepository.java b/src/main/java/org/ohdsi/webapi/annotation/answer/AnswerRepository.java index 65157ed9d2..a09141d027 100644 --- a/src/main/java/org/ohdsi/webapi/annotation/answer/AnswerRepository.java +++ b/src/main/java/org/ohdsi/webapi/annotation/answer/AnswerRepository.java @@ -3,4 +3,4 @@ import org.springframework.data.jpa.repository.JpaRepository; import org.ohdsi.webapi.annotation.answer.Answer; -public interface AnswerRepository extends JpaRepository {} +public interface AnswerRepository extends JpaRepository {} diff --git a/src/main/java/org/ohdsi/webapi/annotation/navigation/Navigation.java b/src/main/java/org/ohdsi/webapi/annotation/navigation/Navigation.java index 32b7a80a24..62a220dc14 100644 --- a/src/main/java/org/ohdsi/webapi/annotation/navigation/Navigation.java +++ b/src/main/java/org/ohdsi/webapi/annotation/navigation/Navigation.java @@ -2,9 +2,9 @@ import java.util.List; public class Navigation { - private Long prevSubjectId; - private Long nextSubjectId; - private Long nextUnannotatedSubjectId; + private int prevSubjectId; + private int nextSubjectId; + private int nextUnannotatedSubjectId; private int numProfileSamples; private int numAnnotations; @@ -13,42 +13,42 @@ public class Navigation { /** * @return the prevSubjectId */ - public Long getPrevSubjectId() { + public int getPrevSubjectId() { return prevSubjectId; } /** * @param prevSubjectId the prevSubjectId to set */ - public void setPrevSubjectId(Long prevSubjectId) { + public void setPrevSubjectId(int prevSubjectId) { this.prevSubjectId = prevSubjectId; } /** * @return the nextSubjectId */ - public Long getNextSubjectId() { + public int getNextSubjectId() { return nextSubjectId; } /** * @param nextSubjectId the nextSubjectId to set */ - public void setNextSubjectId(Long nextSubjectId) { + public void setNextSubjectId(int nextSubjectId) { this.nextSubjectId = nextSubjectId; } /** * @return the nextUnannotatedSubjectId */ - public Long getNextUnannotatedSubjectId() { + public int getNextUnannotatedSubjectId() { return nextUnannotatedSubjectId; } /** * @param nextUnannotatedSubjectId the nextUnannotatedSubjectId to set */ - public void setNextUnannotatedSubjectId(Long nextUnannotatedSubjectId) { + public void setNextUnannotatedSubjectId(int nextUnannotatedSubjectId) { this.nextUnannotatedSubjectId = nextUnannotatedSubjectId; } diff --git a/src/main/java/org/ohdsi/webapi/annotation/navigation/NavigationController.java b/src/main/java/org/ohdsi/webapi/annotation/navigation/NavigationController.java index 2bfeafbc22..0244445b70 100644 --- a/src/main/java/org/ohdsi/webapi/annotation/navigation/NavigationController.java +++ b/src/main/java/org/ohdsi/webapi/annotation/navigation/NavigationController.java @@ -39,7 +39,7 @@ public class NavigationController extends AbstractDaoService { @Produces(MediaType.APPLICATION_JSON) public Navigation getNavigation( @QueryParam("cohortId") final int cohortId, - @QueryParam("subjectId") final Long subjectId, + @QueryParam("subjectId") final int subjectId, @QueryParam("sampleName") final String sampleName, @QueryParam("sourceKey") final String sourceKey ) { diff --git a/src/main/java/org/ohdsi/webapi/annotation/navigation/NavigationService.java b/src/main/java/org/ohdsi/webapi/annotation/navigation/NavigationService.java index 1b00f53bae..e6fc687391 100644 --- a/src/main/java/org/ohdsi/webapi/annotation/navigation/NavigationService.java +++ b/src/main/java/org/ohdsi/webapi/annotation/navigation/NavigationService.java @@ -29,7 +29,7 @@ public class NavigationService extends AbstractDaoService { private CohortSampleRepository cohortSampleRepository; - public Navigation navData(Navigation nav, Long subjectId, String sampleName, int cohortId, Source source) + public Navigation navData(Navigation nav, int subjectId, String sampleName, int cohortId, Source source) { if (sampleName.indexOf("_") != -1) { sampleName = sampleName.replaceAll("_", " "); @@ -40,15 +40,15 @@ public Navigation navData(Navigation nav, Long subjectId, String sampleName, int int annCount = 0; boolean foundNext = false; for(int i = 0; i < sample.size(); i++) { - if((long) sample.get(i)[0] == subjectId) { - nav.setPrevSubjectId(i == 0 ? (long) sample.get(sample.size() - 1)[0] : (long) sample.get(i-1)[0]); - nav.setNextSubjectId(sample.size() == i + 1 ? (long) sample.get(0)[0] : (long) sample.get(i+1)[0]); + if((int) sample.get(i)[0] == subjectId) { + nav.setPrevSubjectId(i == 0 ? (int) sample.get(sample.size() - 1)[0] : (int) sample.get(i-1)[0]); + nav.setNextSubjectId(sample.size() == i + 1 ? (int) sample.get(0)[0] : (int) sample.get(i+1)[0]); } if ((boolean) sample.get(i)[1] == true) { annCount++; } if (!foundNext && (boolean) sample.get(i)[1] == true) { - nav.setNextUnannotatedSubjectId((long) sample.get(i)[0]); + nav.setNextUnannotatedSubjectId( (int)sample.get(i)[0]); foundNext = true; } diff --git a/src/main/java/org/ohdsi/webapi/annotation/question/Question.java b/src/main/java/org/ohdsi/webapi/annotation/question/Question.java index ece372b9a4..3b4eca87f6 100644 --- a/src/main/java/org/ohdsi/webapi/annotation/question/Question.java +++ b/src/main/java/org/ohdsi/webapi/annotation/question/Question.java @@ -23,7 +23,7 @@ public class Question { @Id @GeneratedValue @Column(name = "question_id") - private Long id; + private int id; @Column(name = "question_name") private String text; @@ -58,14 +58,14 @@ public class Question { /** * @return the id */ - public Long getId() { + public int getId() { return id; } /** * @param id the id to set */ - public void setId(Long id) { + public void setId(int id) { this.id = id; } diff --git a/src/main/java/org/ohdsi/webapi/annotation/question/QuestionRepository.java b/src/main/java/org/ohdsi/webapi/annotation/question/QuestionRepository.java index b381a69fff..3b2e074fa1 100644 --- a/src/main/java/org/ohdsi/webapi/annotation/question/QuestionRepository.java +++ b/src/main/java/org/ohdsi/webapi/annotation/question/QuestionRepository.java @@ -1,6 +1,13 @@ package org.ohdsi.webapi.annotation.question; +import org.ohdsi.webapi.annotation.annotation.Annotation; import org.springframework.data.jpa.repository.JpaRepository; import org.ohdsi.webapi.annotation.question.Question; +import org.springframework.data.jpa.repository.Query; -public interface QuestionRepository extends JpaRepository {} +import java.util.List; + +public interface QuestionRepository extends JpaRepository { + @Query("Select a FROM Question a WHERE a.id = ?1") + public Question findByQuestionId(int questionId); +} diff --git a/src/main/java/org/ohdsi/webapi/annotation/question/QuestionService.java b/src/main/java/org/ohdsi/webapi/annotation/question/QuestionService.java index 35dd319063..5251744ebb 100644 --- a/src/main/java/org/ohdsi/webapi/annotation/question/QuestionService.java +++ b/src/main/java/org/ohdsi/webapi/annotation/question/QuestionService.java @@ -20,6 +20,10 @@ public List getAllQuestions() { return questions; } + public Question getQuestionByQuestionId(int questionId){ + return questionRepository.findByQuestionId(questionId); + } + public void addQuestion(Question question) { questionRepository.save(question); } diff --git a/src/main/java/org/ohdsi/webapi/annotation/result/ResultController.java b/src/main/java/org/ohdsi/webapi/annotation/result/ResultController.java index aaa04868b9..e1f1eb5c05 100644 --- a/src/main/java/org/ohdsi/webapi/annotation/result/ResultController.java +++ b/src/main/java/org/ohdsi/webapi/annotation/result/ResultController.java @@ -3,9 +3,18 @@ import javax.ws.rs.*; import javax.ws.rs.core.MediaType; +import org.checkerframework.checker.units.qual.A; import org.ohdsi.webapi.annotation.annotation.Annotation; import org.ohdsi.webapi.annotation.annotation.AnnotationService; import org.ohdsi.webapi.annotation.annotation.AnnotationSummary; +import org.ohdsi.webapi.annotation.question.Question; +import org.ohdsi.webapi.annotation.question.QuestionService; +import org.ohdsi.webapi.annotation.set.QuestionSet; +import org.ohdsi.webapi.annotation.set.QuestionSetService; +import org.ohdsi.webapi.cohortdefinition.CohortDefinition; +import org.ohdsi.webapi.cohortdefinition.CohortDefinitionRepository; +import org.ohdsi.webapi.cohortsample.dto.CohortSampleDTO; +import org.ohdsi.webapi.service.CohortSampleService; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Component; import org.ohdsi.webapi.annotation.result.ResultService; @@ -18,12 +27,24 @@ @Component public class ResultController { + @Autowired + private CohortSampleService cohortSampleService; + @Autowired private ResultService resultService; + @Autowired + private QuestionService questionService; + + @Autowired + private QuestionSetService questionSetService; + @Autowired private AnnotationService annotationService; + @Autowired + private CohortDefinitionRepository cohortDefinitionRepository; + @GET @Path("/{annotationID}") @Produces(MediaType.APPLICATION_JSON) @@ -52,6 +73,36 @@ public List getResults( return resultService.getResultsByQuestionSetId(questionId); } + @GET + @Path("/completeResults") + @Produces(MediaType.APPLICATION_JSON) + public List getFullResults( + @QueryParam("questionSetId") final int questionSetId + ) { + List resultlist= resultService.getResultsByQuestionSetId(questionSetId); + List superList = new ArrayList(); + for (Result result : resultlist){ + Question myQuestion = questionService.getQuestionByQuestionId(result.getQuestionId()); + SuperResultDto tempdto = new SuperResultDto(result); + Annotation tempanno = annotationService.getAnnotationsByAnnotationId(result.getAnnotation()); + tempdto.setCohortSampleId(tempanno.getCohortSampleId()); + tempdto.setPatientId(tempanno.getSubjectId()); + CohortSampleDTO cohortSample = cohortSampleService.getCohortSample(tempanno.getCohortSampleId(),"" ); + CohortDefinition cohortDefinition= cohortDefinitionRepository.findOneWithDetail(cohortSample.getCohortDefinitionId()); + tempdto.setCohortName(cohortDefinition.getName()); + tempdto.setCohortId( cohortSample.getCohortDefinitionId()); + tempdto.setDataSourceId(cohortSample.getSourceId()); + tempdto.setCohortSampleName(cohortSample.getName()); + tempdto.setQuestionSetId(questionSetId); + QuestionSet questionSet = questionSetService.findQuestionSetByQuestionSetId(questionSetId); + tempdto.setQuestionSetName(questionSet.getName()); + tempdto.setCaseStatus(myQuestion.getCaseQuestion()); + tempdto.setQuestionText(myQuestion.getText()); + superList.add(tempdto); + } + return superList; + } + @Path("/{cohortDefinitionId}/{sourceKey}") @POST @Consumes(MediaType.APPLICATION_JSON) diff --git a/src/main/java/org/ohdsi/webapi/annotation/result/ResultDto.java b/src/main/java/org/ohdsi/webapi/annotation/result/ResultDto.java index 8102e8663a..f966e2314b 100644 --- a/src/main/java/org/ohdsi/webapi/annotation/result/ResultDto.java +++ b/src/main/java/org/ohdsi/webapi/annotation/result/ResultDto.java @@ -2,8 +2,8 @@ public class ResultDto { - private Long answerId; - private Long questionId; + private int answerId; + private int questionId; private String value; private String type; // private String sampleName; @@ -13,28 +13,28 @@ public class ResultDto { /** * @return the answerId */ - public Long getAnswerId() { + public int getAnswerId() { return answerId; } /** * @param answerId the answerId to set */ - public void setAnswerId(Long answerId) { + public void setAnswerId(int answerId) { this.answerId = answerId; } /** * @return the questionId */ - public Long getQuestionId() { + public int getQuestionId() { return questionId; } /** * @param questionId the questionId to set */ - public void setQuestionId(Long questionId) { + public void setQuestionId(int questionId) { this.questionId = questionId; } diff --git a/src/main/java/org/ohdsi/webapi/annotation/result/ResultRepository.java b/src/main/java/org/ohdsi/webapi/annotation/result/ResultRepository.java index 097f9971da..ec5e6e9520 100644 --- a/src/main/java/org/ohdsi/webapi/annotation/result/ResultRepository.java +++ b/src/main/java/org/ohdsi/webapi/annotation/result/ResultRepository.java @@ -13,7 +13,7 @@ import org.springframework.data.jpa.repository.Query; @Transactional -public interface ResultRepository extends JpaRepository { +public interface ResultRepository extends JpaRepository { // public Set findBySampleNameAndSubjectId(String sampleName, Long subject_id); @Query("select s.value from Result s where s.annotation=?1 and s.questionId = ?2") diff --git a/src/main/java/org/ohdsi/webapi/annotation/result/SuperResultDto.java b/src/main/java/org/ohdsi/webapi/annotation/result/SuperResultDto.java new file mode 100644 index 0000000000..8009e45306 --- /dev/null +++ b/src/main/java/org/ohdsi/webapi/annotation/result/SuperResultDto.java @@ -0,0 +1,110 @@ +package org.ohdsi.webapi.annotation.result; + +public class SuperResultDto { + + private int cohortId; + private String cohortName; + private int dataSourceId; + private int cohortSampleId; + private String cohortSampleName; + private int questionSetId; + private String questionSetName; + private int patientId; + private String questionText; + private String value; + private Boolean caseStatus; + + public SuperResultDto(Result result){ + this.value = result.getValue(); + + + } + + //***** GETTERS/SETTERS ***** + + public int getCohortId() { + return cohortId; + } + + public void setCohortId(int cohortId) { + this.cohortId = cohortId; + } + + public String getCohortName() { + return cohortName; + } + + public void setCohortName(String cohortName) { + this.cohortName = cohortName; + } + + public int getDataSourceId() { + return dataSourceId; + } + + public void setDataSourceId(int dataSourceId) { + this.dataSourceId = dataSourceId; + } + + public int getCohortSampleId() { + return cohortSampleId; + } + + public void setCohortSampleId(int cohortSampleId) { + this.cohortSampleId = cohortSampleId; + } + + public String getCohortSampleName() { + return cohortSampleName; + } + + public void setCohortSampleName(String cohortSampleName) { + this.cohortSampleName = cohortSampleName; + } + + public int getQuestionSetId() { + return questionSetId; + } + + public void setQuestionSetId(int questionSetId) { + this.questionSetId = questionSetId; + } + + public String getQuestionSetName() {return questionSetName;} + + public void setQuestionSetName(String questionSetName) { + this.questionSetName = questionSetName; + } + + public int getPatientId() { + return patientId; + } + + public void setPatientId(int patientId) { + this.patientId = patientId; + } + + public String getQuestionText() { + return questionText; + } + + public void setQuestionText(String questionText) { + this.questionText = questionText; + } + + public String getValue() { + return value; + } + + public void setValue(String value) { + this.value = value; + } + + public Boolean getCaseStatus() { + return caseStatus; + } + + public void setCaseStatus(Boolean caseStatus) { + this.caseStatus = caseStatus; + } +} \ No newline at end of file diff --git a/src/main/java/org/ohdsi/webapi/annotation/set/QuestionSetRepository.java b/src/main/java/org/ohdsi/webapi/annotation/set/QuestionSetRepository.java index 7b8480a9d7..1d4ef08bdf 100644 --- a/src/main/java/org/ohdsi/webapi/annotation/set/QuestionSetRepository.java +++ b/src/main/java/org/ohdsi/webapi/annotation/set/QuestionSetRepository.java @@ -1,13 +1,17 @@ package org.ohdsi.webapi.annotation.set; +import org.ohdsi.webapi.annotation.question.Question; import org.springframework.data.jpa.repository.JpaRepository; import java.util.Set; import org.ohdsi.webapi.annotation.set.QuestionSet; +import org.springframework.data.jpa.repository.Query; -public interface QuestionSetRepository extends JpaRepository { +public interface QuestionSetRepository extends JpaRepository { public Set findByCohortId(Integer cohortId); public QuestionSet findById(int id); + @Query("Select a FROM QuestionSet a WHERE a.id = ?1") + public QuestionSet findByQuestionSetId(int questionId); } diff --git a/src/main/java/org/ohdsi/webapi/annotation/set/QuestionSetService.java b/src/main/java/org/ohdsi/webapi/annotation/set/QuestionSetService.java index 457a7a38a5..0a5b29e610 100644 --- a/src/main/java/org/ohdsi/webapi/annotation/set/QuestionSetService.java +++ b/src/main/java/org/ohdsi/webapi/annotation/set/QuestionSetService.java @@ -31,4 +31,7 @@ public void addSet(QuestionSet set) { questionSetRepository.save(set); } + public QuestionSet findQuestionSetByQuestionSetId(int questionSetId){ + return questionSetRepository.findByQuestionSetId(questionSetId); + } } From c695f2487b6b7ed17fb8025d1a31a45c21630178 Mon Sep 17 00:00:00 2001 From: Saul Crumpton Date: Tue, 3 Aug 2021 13:29:38 -0400 Subject: [PATCH 21/55] working getSets query --- .../annotation/AnnotationController.java | 11 ---- .../annotation/result/SuperResultDto.java | 10 +--- .../annotation/set/QuestionSampleDto.java | 50 +++++++++++++++++++ .../annotation/set/QuestionSetController.java | 11 ++++ .../annotation/set/QuestionSetRepository.java | 5 ++ .../annotation/set/QuestionSetService.java | 5 ++ 6 files changed, 73 insertions(+), 19 deletions(-) create mode 100644 src/main/java/org/ohdsi/webapi/annotation/set/QuestionSampleDto.java diff --git a/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationController.java b/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationController.java index c123d35cdf..3c88889488 100644 --- a/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationController.java +++ b/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationController.java @@ -151,17 +151,6 @@ public void addAnnotation(AnnotationDto annotationDto) { } } - @GET - @Path("/getsets") - @Produces(MediaType.APPLICATION_JSON) - public List getSets( - @QueryParam("cohortSampleId") final int cohortSampleId, - @QueryParam("subjectId") final int subjectId, - @QueryParam("setId") final int setId - ) { - return annotationService.getAnnotations(); - } - //just for testing @Path("/csvData") @GET diff --git a/src/main/java/org/ohdsi/webapi/annotation/result/SuperResultDto.java b/src/main/java/org/ohdsi/webapi/annotation/result/SuperResultDto.java index 8009e45306..7d3534e692 100644 --- a/src/main/java/org/ohdsi/webapi/annotation/result/SuperResultDto.java +++ b/src/main/java/org/ohdsi/webapi/annotation/result/SuperResultDto.java @@ -16,8 +16,6 @@ public class SuperResultDto { public SuperResultDto(Result result){ this.value = result.getValue(); - - } //***** GETTERS/SETTERS ***** @@ -66,15 +64,11 @@ public int getQuestionSetId() { return questionSetId; } - public void setQuestionSetId(int questionSetId) { - this.questionSetId = questionSetId; - } + public void setQuestionSetId(int questionSetId) {this.questionSetId = questionSetId;} public String getQuestionSetName() {return questionSetName;} - public void setQuestionSetName(String questionSetName) { - this.questionSetName = questionSetName; - } + public void setQuestionSetName(String questionSetName) { this.questionSetName = questionSetName; } public int getPatientId() { return patientId; diff --git a/src/main/java/org/ohdsi/webapi/annotation/set/QuestionSampleDto.java b/src/main/java/org/ohdsi/webapi/annotation/set/QuestionSampleDto.java new file mode 100644 index 0000000000..03f4ca2672 --- /dev/null +++ b/src/main/java/org/ohdsi/webapi/annotation/set/QuestionSampleDto.java @@ -0,0 +1,50 @@ +package org.ohdsi.webapi.annotation.set; + +public class QuestionSampleDto { + private int QuestionSetId; + private int CohortSampleId; + private String QuestionSetName; + private String CohortSampleName; + + public QuestionSampleDto(int questionSetId, int cohortSampleId, String questionSetName, String cohortSampleName) { + this.QuestionSetId = questionSetId; + this.CohortSampleId = cohortSampleId; + this.QuestionSetName = questionSetName; + this.CohortSampleName = cohortSampleName; + } + + //***** GETTERS/SETTERS ****** + + public int getQuestionSetId() { + return QuestionSetId; + } + + public void setQuestionSetId(int questionSetId) { + this.QuestionSetId = questionSetId; + } + + public int getCohortSampleId() { + return CohortSampleId; + } + + public void setCohortSampleId(int cohortSampleId) { + this.CohortSampleId = cohortSampleId; + } + + public String getQuestionSetName() { + return QuestionSetName; + } + + public void setQuestionSetName(String questionSetName) { + this.QuestionSetName = questionSetName; + } + + public String getCohortSampleName() { + return CohortSampleName; + } + + public void setCohortSampleName(String cohortSampleName) { + this.CohortSampleName = cohortSampleName; + } + +} \ No newline at end of file diff --git a/src/main/java/org/ohdsi/webapi/annotation/set/QuestionSetController.java b/src/main/java/org/ohdsi/webapi/annotation/set/QuestionSetController.java index f5b7fc0b5d..bede372449 100644 --- a/src/main/java/org/ohdsi/webapi/annotation/set/QuestionSetController.java +++ b/src/main/java/org/ohdsi/webapi/annotation/set/QuestionSetController.java @@ -8,6 +8,8 @@ import javax.ws.rs.Produces; import javax.ws.rs.core.MediaType; import javax.ws.rs.QueryParam; + +import org.ohdsi.webapi.annotation.annotation.Annotation; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Component; import org.ohdsi.webapi.annotation.set.QuestionSetService; @@ -32,6 +34,15 @@ public List getSets(@QueryParam("cohortId") final Integer cohortId) return questionSetService.getSets(); } + @GET + @Path("getsets") + @Produces(MediaType.APPLICATION_JSON) + public List getSets( + @QueryParam("cohortId") final int cohortId + ) { + return questionSetService.getSamplesAndSetsByCohortId(cohortId); + } + @POST @Path("sets") @Consumes(MediaType.APPLICATION_JSON) diff --git a/src/main/java/org/ohdsi/webapi/annotation/set/QuestionSetRepository.java b/src/main/java/org/ohdsi/webapi/annotation/set/QuestionSetRepository.java index 1d4ef08bdf..0dfbf75d5c 100644 --- a/src/main/java/org/ohdsi/webapi/annotation/set/QuestionSetRepository.java +++ b/src/main/java/org/ohdsi/webapi/annotation/set/QuestionSetRepository.java @@ -2,6 +2,8 @@ import org.ohdsi.webapi.annotation.question.Question; import org.springframework.data.jpa.repository.JpaRepository; + +import java.util.List; import java.util.Set; import org.ohdsi.webapi.annotation.set.QuestionSet; import org.springframework.data.jpa.repository.Query; @@ -14,4 +16,7 @@ public interface QuestionSetRepository extends JpaRepository findSamplesAndSetsByCohortId(int cohortId); } diff --git a/src/main/java/org/ohdsi/webapi/annotation/set/QuestionSetService.java b/src/main/java/org/ohdsi/webapi/annotation/set/QuestionSetService.java index 0a5b29e610..08c972b7fa 100644 --- a/src/main/java/org/ohdsi/webapi/annotation/set/QuestionSetService.java +++ b/src/main/java/org/ohdsi/webapi/annotation/set/QuestionSetService.java @@ -1,5 +1,6 @@ package org.ohdsi.webapi.annotation.set; +import org.ohdsi.webapi.annotation.annotation.Annotation; import org.springframework.stereotype.Service; import org.springframework.beans.factory.annotation.Autowired; import java.util.ArrayList; @@ -34,4 +35,8 @@ public void addSet(QuestionSet set) { public QuestionSet findQuestionSetByQuestionSetId(int questionSetId){ return questionSetRepository.findByQuestionSetId(questionSetId); } + + public List getSamplesAndSetsByCohortId(int cohortId) { + return questionSetRepository.findSamplesAndSetsByCohortId(cohortId); + } } From 1afa631b01d7031dfa4292c708e0048ab201e49f Mon Sep 17 00:00:00 2001 From: Saul Crumpton Date: Tue, 10 Aug 2021 20:14:48 -0400 Subject: [PATCH 22/55] creating annotation study table to aid in query speed for results super table --- .../annotation/AnnotationController.java | 49 ++++++++++--- .../annotation/AnnotationService.java | 6 ++ .../annotation/result/ResultController.java | 4 + .../annotation/result/ResultService.java | 1 + .../annotation/result/SuperResultDto.java | 5 +- .../ohdsi/webapi/annotation/study/Study.java | 73 +++++++++++++++++++ .../annotation/study/StudyRepository.java | 7 ++ .../webapi/annotation/study/StudyService.java | 15 ++++ .../postgresql/V2.5.1__annotation.sql | 17 +++++ 9 files changed, 164 insertions(+), 13 deletions(-) create mode 100644 src/main/java/org/ohdsi/webapi/annotation/study/Study.java create mode 100644 src/main/java/org/ohdsi/webapi/annotation/study/StudyRepository.java create mode 100644 src/main/java/org/ohdsi/webapi/annotation/study/StudyService.java diff --git a/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationController.java b/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationController.java index 3c88889488..f6b5804f4c 100644 --- a/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationController.java +++ b/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationController.java @@ -16,11 +16,18 @@ import org.json.JSONArray; import org.ohdsi.webapi.annotation.result.ResultService; +import org.ohdsi.webapi.annotation.study.Study; +import org.ohdsi.webapi.annotation.study.StudyService; +import org.ohdsi.webapi.cohortdefinition.CohortDefinition; +import org.ohdsi.webapi.cohortdefinition.CohortDefinitionRepository; import org.ohdsi.webapi.cohortsample.CohortSample; import org.ohdsi.webapi.cohortsample.CohortSampleRepository; import org.ohdsi.webapi.cohortsample.CohortSamplingService; +import org.ohdsi.webapi.cohortsample.SampleElement; +import org.ohdsi.webapi.cohortsample.dto.CohortSampleDTO; import org.ohdsi.webapi.cohortsample.dto.SampleElementDTO; import org.ohdsi.webapi.source.Source; +import org.ohdsi.webapi.source.SourceService; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Component; import org.ohdsi.webapi.annotation.annotation.AnnotationService; @@ -36,11 +43,20 @@ @Component public class AnnotationController { + @Autowired + private StudyService studyService; + @Autowired private ResultService resultService; @Autowired - public CohortSamplingService cohortSamplingService; + private CohortDefinitionRepository cohortDefinitionRepository; + + @Autowired + private CohortSamplingService cohortSamplingService; + + @Autowired + private CohortSampleRepository sampleRepository; @Autowired private AnnotationService annotationService; @@ -48,6 +64,9 @@ public class AnnotationController { @Autowired private QuestionSetRepository questionSetRepository; + @Autowired + private SourceService sourceService; + @GET @Path("/") @Produces(MediaType.APPLICATION_JSON) @@ -131,23 +150,29 @@ public void addResult(@RequestBody String payload) { @Path("/sample") @Consumes(MediaType.APPLICATION_JSON) @Produces(MediaType.APPLICATION_JSON) - public void addAnnotation(AnnotationDto annotationDto) { - System.out.println("annotationDto: "+annotationDto); - System.out.println("annotationDtoGetId: "+annotationDto.getId()); - System.out.println("annotationDtoGesampleId"+annotationDto.getsampleId()); - System.out.println("annotationDtoGetAnnotationSetID"+annotationDto.getannotationSetId()); - List temp = cohortSamplingService.getSample(annotationDto.getsampleId(), false).getElements(); - System.out.println("SampleElementDTO"+temp); + public void addAnnotation(@RequestBody String payload) { + JSONObject jsonpayload = new JSONObject(payload); + int cohortSampleId = Integer.parseInt(jsonpayload.get("sampleId").toString()); + CohortSample cohortSample =sampleRepository.findById(cohortSampleId); + List temp = cohortSamplingService.getSample(cohortSampleId, false).getElements(); + Study study = new Study(); + int questionSetId = Integer.parseInt(jsonpayload.get("annotationSetId").toString()); + QuestionSet questionSet = questionSetRepository.findById(questionSetId); + study.setQuestionSet(questionSetRepository.findByQuestionSetId(questionSetId)); + study.setCohortSample(cohortSample); + CohortDefinition cohortDefinition= cohortDefinitionRepository.findOneWithDetail(cohortSample.getCohortDefinitionId()); + study.setCohortDefinition(cohortDefinition); + Source source = sourceService.findBySourceKey(jsonpayload.get("sourceKey").toString()); + study.setSource(source); + studyService.addStudy(study); for (SampleElementDTO element : temp){ System.out.println("element"+element); System.out.println("element GetPersonID"+element.getPersonId()); Annotation annotation = new Annotation(); - annotation.setId(annotationDto.getId()); annotation.setSubjectId(Integer.parseInt(element.getPersonId())); - annotation.setCohortSampleId(annotationDto.getsampleId()); - QuestionSet questionSet = questionSetRepository.findById(annotationDto.getannotationSetId()); + annotation.setCohortSampleId(cohortSampleId); annotation.setQuestionSet(questionSet); - annotationService.addAnnotation(annotation, annotationDto.getSampleName()); + annotationService.addAnnotation(annotation); } } diff --git a/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationService.java b/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationService.java index 5f4799d6bd..85feeb803c 100644 --- a/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationService.java +++ b/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationService.java @@ -60,6 +60,8 @@ public List getAnnotationByCohortSampleIdAndBySubjectIdAndByQuestion } public List getAnnotationByCohortSampleIdAndByQuestionSetId(int cohortSampleId, int setId) { +// this becomes getByStudyId +// checking if there is a study with the sample and question set that has already been created List annotations = new ArrayList(); annotationRepository.findByCohortSampleIdAndQuestionSetId(cohortSampleId, setId) .forEach(annotations::add); @@ -72,6 +74,10 @@ public Annotation addAnnotation(Annotation annotation, String name) { return annotationRepository.save(annotation); } + public Annotation addAnnotation(Annotation annotation) { + return annotationRepository.save(annotation); + } + public List getAnnotationCSVData(int cohortID, String source, String sampleName) { List results = new ArrayList(); // List samples = cohortSampleRepository.getSampleMembership(sampleName, cohortID); diff --git a/src/main/java/org/ohdsi/webapi/annotation/result/ResultController.java b/src/main/java/org/ohdsi/webapi/annotation/result/ResultController.java index e1f1eb5c05..c927764da6 100644 --- a/src/main/java/org/ohdsi/webapi/annotation/result/ResultController.java +++ b/src/main/java/org/ohdsi/webapi/annotation/result/ResultController.java @@ -79,9 +79,12 @@ public List getResults( public List getFullResults( @QueryParam("questionSetId") final int questionSetId ) { +// May want to replicate this but with an additional parameter- +// this would be (quesetionSetID + CohortSampleId) or AnnotationStudyId (aka the same thing) List resultlist= resultService.getResultsByQuestionSetId(questionSetId); List superList = new ArrayList(); for (Result result : resultlist){ +// things we currently query for; Annotation Cohort Sample, Cohort Definition, QuestionSets Question myQuestion = questionService.getQuestionByQuestionId(result.getQuestionId()); SuperResultDto tempdto = new SuperResultDto(result); Annotation tempanno = annotationService.getAnnotationsByAnnotationId(result.getAnnotation()); @@ -92,6 +95,7 @@ public List getFullResults( tempdto.setCohortName(cohortDefinition.getName()); tempdto.setCohortId( cohortSample.getCohortDefinitionId()); tempdto.setDataSourceId(cohortSample.getSourceId()); +// for above, it would be more useful to use DataSourceKey instead of ID tempdto.setCohortSampleName(cohortSample.getName()); tempdto.setQuestionSetId(questionSetId); QuestionSet questionSet = questionSetService.findQuestionSetByQuestionSetId(questionSetId); diff --git a/src/main/java/org/ohdsi/webapi/annotation/result/ResultService.java b/src/main/java/org/ohdsi/webapi/annotation/result/ResultService.java index 795044ef6f..75c9a9bb1d 100644 --- a/src/main/java/org/ohdsi/webapi/annotation/result/ResultService.java +++ b/src/main/java/org/ohdsi/webapi/annotation/result/ResultService.java @@ -148,6 +148,7 @@ public void insertResults(Annotation annotation, JSONArray results) { Boolean hasCleared=false; for(int i=0; i < results.length(); i++){ JSONObject object = results.getJSONObject(i); +// I can check here by AnnotationID only? TODO if(!hasCleared && getResultByAnnotationIDAndQuestionID(annotation.getId(),Integer.parseInt(object.get("questionId").toString()))!=null){ // this entry already exists, need to update here instead of adding to the pile deleteResultsByAnnotationIdAndQuestionId(annotation,Integer.parseInt(object.get("questionId").toString())); diff --git a/src/main/java/org/ohdsi/webapi/annotation/result/SuperResultDto.java b/src/main/java/org/ohdsi/webapi/annotation/result/SuperResultDto.java index 7d3534e692..a9bd4df236 100644 --- a/src/main/java/org/ohdsi/webapi/annotation/result/SuperResultDto.java +++ b/src/main/java/org/ohdsi/webapi/annotation/result/SuperResultDto.java @@ -1,13 +1,16 @@ package org.ohdsi.webapi.annotation.result; - +//this table is for human viewing- don't expect to ever review this again public class SuperResultDto { private int cohortId; private String cohortName; private int dataSourceId; +// can be removed/changed to dataSourceKey private int cohortSampleId; +// can be removed ( cohortSampleId) private String cohortSampleName; private int questionSetId; +// can be remove (questionSetId) private String questionSetName; private int patientId; private String questionText; diff --git a/src/main/java/org/ohdsi/webapi/annotation/study/Study.java b/src/main/java/org/ohdsi/webapi/annotation/study/Study.java new file mode 100644 index 0000000000..afbcc1d3ab --- /dev/null +++ b/src/main/java/org/ohdsi/webapi/annotation/study/Study.java @@ -0,0 +1,73 @@ +package org.ohdsi.webapi.annotation.study; + +import org.ohdsi.webapi.annotation.set.QuestionSet; +import org.ohdsi.webapi.cohortdefinition.CohortDefinition; +import org.ohdsi.webapi.cohortsample.CohortSample; +import org.ohdsi.webapi.source.Source; + +import javax.persistence.*; + +@Entity(name = "Study") +@Table(name = "annotation_study") +public class Study { + @Id + @GeneratedValue + @Column(name = "study_id") + private int id; + + @ManyToOne + @JoinColumn(name = "question_set_id") + private QuestionSet questionSet; + + @ManyToOne + @JoinColumn(name = "cohort_definition_id") + private CohortDefinition cohortDefinition; + + @ManyToOne + @JoinColumn(name = "cohort_sample_id") + private CohortSample cohortSample; + + @ManyToOne + @JoinColumn(name = "source_id") + private Source source; + + public int getId() { + return id; + } + + public void setId(int id) { + this.id = id; + } + + public QuestionSet getQuestionSet() { + return questionSet; + } + + public void setQuestionSet(QuestionSet questionSet) { + this.questionSet = questionSet; + } + + public CohortDefinition getCohortDefinition() { + return cohortDefinition; + } + + public void setCohortDefinition(CohortDefinition cohortDefinition) { + this.cohortDefinition = cohortDefinition; + } + + public CohortSample getCohortSample() { + return cohortSample; + } + + public void setCohortSample(CohortSample cohortSample) { + this.cohortSample = cohortSample; + } + + public Source getSource() { + return source; + } + + public void setSource(Source source) { + this.source = source; + } +} diff --git a/src/main/java/org/ohdsi/webapi/annotation/study/StudyRepository.java b/src/main/java/org/ohdsi/webapi/annotation/study/StudyRepository.java new file mode 100644 index 0000000000..3c77c68645 --- /dev/null +++ b/src/main/java/org/ohdsi/webapi/annotation/study/StudyRepository.java @@ -0,0 +1,7 @@ +package org.ohdsi.webapi.annotation.study; + +import org.springframework.data.jpa.repository.JpaRepository; + +public interface StudyRepository extends JpaRepository { + +} \ No newline at end of file diff --git a/src/main/java/org/ohdsi/webapi/annotation/study/StudyService.java b/src/main/java/org/ohdsi/webapi/annotation/study/StudyService.java new file mode 100644 index 0000000000..1f83991efa --- /dev/null +++ b/src/main/java/org/ohdsi/webapi/annotation/study/StudyService.java @@ -0,0 +1,15 @@ +package org.ohdsi.webapi.annotation.study; + +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.stereotype.Service; + + +@Service +public class StudyService { + @Autowired + private StudyRepository studyRepository; + + public void addStudy(Study study) { + studyRepository.save(study); + } +} diff --git a/src/main/resources/db/migration/postgresql/V2.5.1__annotation.sql b/src/main/resources/db/migration/postgresql/V2.5.1__annotation.sql index 8120352051..102cbedb0c 100644 --- a/src/main/resources/db/migration/postgresql/V2.5.1__annotation.sql +++ b/src/main/resources/db/migration/postgresql/V2.5.1__annotation.sql @@ -59,3 +59,20 @@ CREATE TABLE ${ohdsiSchema}.annotation ( CREATE INDEX idx_annotation_sample_subject ON ${ohdsiSchema}.annotation (cohort_sample_id,subject_id); CREATE INDEX idx_annotation_set ON ${ohdsiSchema}.annotation (set_id); + +CREATE TABLE ${ohdsiSchema}.annotation_study ( + study_id integer NOT NULL, + cohort_sample_id integer NOT NULL, + question_set_id integer NOT NULL, + cohort_definition_id integer NOT NULL, + source_id integer NOT NULL, + CONSTRAINT annotation_study_pkey PRIMARY KEY (study_id), + CONSTRAINT annotation_study_set_fk FOREIGN KEY (question_set_id) + REFERENCES ${ohdsiSchema}.annotation_set(set_id), + CONSTRAINT annotation_study_sample_fk FOREIGN KEY (cohort_sample_id) + REFERENCES ${ohdsiSchema}.cohort_sample(id), + CONSTRAINT annotation_study_definition_fk FOREIGN KEY (cohort_definition_id) + REFERENCES ${ohdsiSchema}.cohort_definition(id), + CONSTRAINT annotation_study_source_fk FOREIGN KEY (source_id) + REFERENCES ${ohdsiSchema}.source(source_id) +); From e5b1e2aeae7467be5ed91e30096d4bdbef18ffff Mon Sep 17 00:00:00 2001 From: Saul Crumpton Date: Wed, 11 Aug 2021 23:45:32 -0400 Subject: [PATCH 23/55] more work done on supertable- everything should be using annotation_study now --- .../annotation/AnnotationController.java | 4 +- .../annotation/result/ResultController.java | 53 ++++++++++---- .../annotation/result/ResultService.java | 37 ++++++++-- .../annotation/result/SuperResultDto.java | 69 ++++++++++++------- .../annotation/study/StudyRepository.java | 7 ++ .../webapi/annotation/study/StudyService.java | 6 ++ .../ddl/results/annotation_result.sql | 1 + .../sql/findResultsByStudyId.sql | 4 ++ .../annotationresult/sql/insertResults.sql | 4 +- 9 files changed, 138 insertions(+), 47 deletions(-) create mode 100644 src/main/resources/resources/annotationresult/sql/findResultsByStudyId.sql diff --git a/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationController.java b/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationController.java index f6b5804f4c..64ad4325e9 100644 --- a/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationController.java +++ b/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationController.java @@ -132,8 +132,8 @@ public void addResult(@RequestBody String payload) { ,Integer.parseInt(jsonpayload.get("subjectId").toString()),Integer.parseInt(jsonpayload.get("setId").toString())).get(0); System.out.printf("annotationID:%d\n",tempAnnotation.getId()); JSONArray array = jsonpayload.getJSONArray("results"); - - resultService.insertResults(tempAnnotation,array); + Study study = studyService.getStudyByQuestionSetIdAndSampleId(jsonpayload.getInt("setId"),jsonpayload.getInt("cohortSampleId") ); + resultService.insertResults(tempAnnotation,array,study); // for(int i=0; i < array.length(); i++){ // JSONObject object = array.getJSONObject(i); // Result result = new Result(); diff --git a/src/main/java/org/ohdsi/webapi/annotation/result/ResultController.java b/src/main/java/org/ohdsi/webapi/annotation/result/ResultController.java index c927764da6..009d2a707f 100644 --- a/src/main/java/org/ohdsi/webapi/annotation/result/ResultController.java +++ b/src/main/java/org/ohdsi/webapi/annotation/result/ResultController.java @@ -11,10 +11,14 @@ import org.ohdsi.webapi.annotation.question.QuestionService; import org.ohdsi.webapi.annotation.set.QuestionSet; import org.ohdsi.webapi.annotation.set.QuestionSetService; +import org.ohdsi.webapi.annotation.study.Study; +import org.ohdsi.webapi.annotation.study.StudyService; import org.ohdsi.webapi.cohortdefinition.CohortDefinition; import org.ohdsi.webapi.cohortdefinition.CohortDefinitionRepository; import org.ohdsi.webapi.cohortsample.dto.CohortSampleDTO; import org.ohdsi.webapi.service.CohortSampleService; +import org.ohdsi.webapi.source.Source; +import org.ohdsi.webapi.source.SourceService; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Component; import org.ohdsi.webapi.annotation.result.ResultService; @@ -22,6 +26,7 @@ import org.springframework.web.bind.annotation.RequestMapping; import java.util.*; +import java.util.stream.Collectors; @Path("/annotations/results") @Component @@ -45,6 +50,12 @@ public class ResultController { @Autowired private CohortDefinitionRepository cohortDefinitionRepository; + @Autowired + private StudyService studyService; + + @Autowired + private SourceService sourceService; + @GET @Path("/{annotationID}") @Produces(MediaType.APPLICATION_JSON) @@ -77,34 +88,50 @@ public List getResults( @Path("/completeResults") @Produces(MediaType.APPLICATION_JSON) public List getFullResults( - @QueryParam("questionSetId") final int questionSetId + @QueryParam("questionSetId") final int questionSetId, + @QueryParam("cohortSampleId") final int cohortSampleId, + @QueryParam("studyId") final int studyId ) { // May want to replicate this but with an additional parameter- // this would be (quesetionSetID + CohortSampleId) or AnnotationStudyId (aka the same thing) - List resultlist= resultService.getResultsByQuestionSetId(questionSetId); + + Study study = null; + if(studyId!=0){ + study=studyService.getStudyById(studyId); + } + else if (questionSetId!=0 && cohortSampleId!=0){ + study=studyService.getStudyByQuestionSetIdAndSampleId(questionSetId,studyId); + } + else{ + return null; + } + List resultlist=resultService.getResultsByStudy(study); List superList = new ArrayList(); +// Study finalStudy = study; + Source source = sourceService.findBySourceId(study.getCohortSample().getSourceId()); +// List fastlist = resultlist.stream().map(r -> new SuperResultDto(r, finalStudy,source)).collect(Collectors.toList()); +// List fastlist = resultlist.stream().map(r -> { +// Question myQuestion = questionService.getQuestionByQuestionId(r.getQuestionId()); +// Annotation tempanno = annotationService.getAnnotationsByAnnotationId(r.getAnnotation()); +// return new SuperResultDto(r, finalStudy,source,myQuestion,tempanno); +// } ).collect(Collectors.toList()); for (Result result : resultlist){ // things we currently query for; Annotation Cohort Sample, Cohort Definition, QuestionSets Question myQuestion = questionService.getQuestionByQuestionId(result.getQuestionId()); SuperResultDto tempdto = new SuperResultDto(result); Annotation tempanno = annotationService.getAnnotationsByAnnotationId(result.getAnnotation()); - tempdto.setCohortSampleId(tempanno.getCohortSampleId()); tempdto.setPatientId(tempanno.getSubjectId()); - CohortSampleDTO cohortSample = cohortSampleService.getCohortSample(tempanno.getCohortSampleId(),"" ); - CohortDefinition cohortDefinition= cohortDefinitionRepository.findOneWithDetail(cohortSample.getCohortDefinitionId()); - tempdto.setCohortName(cohortDefinition.getName()); - tempdto.setCohortId( cohortSample.getCohortDefinitionId()); - tempdto.setDataSourceId(cohortSample.getSourceId()); -// for above, it would be more useful to use DataSourceKey instead of ID - tempdto.setCohortSampleName(cohortSample.getName()); - tempdto.setQuestionSetId(questionSetId); - QuestionSet questionSet = questionSetService.findQuestionSetByQuestionSetId(questionSetId); - tempdto.setQuestionSetName(questionSet.getName()); + tempdto.setCohortName(study.getCohortDefinition().getName()); + tempdto.setCohortId( study.getCohortDefinition().getId()); + tempdto.setDataSourceKey(source.getSourceKey()); + tempdto.setCohortSampleName(study.getCohortSample().getName()); + tempdto.setQuestionSetName(study.getQuestionSet().getName()); tempdto.setCaseStatus(myQuestion.getCaseQuestion()); tempdto.setQuestionText(myQuestion.getText()); superList.add(tempdto); } return superList; +// return fastlist; } @Path("/{cohortDefinitionId}/{sourceKey}") diff --git a/src/main/java/org/ohdsi/webapi/annotation/result/ResultService.java b/src/main/java/org/ohdsi/webapi/annotation/result/ResultService.java index 75c9a9bb1d..8ff0a58939 100644 --- a/src/main/java/org/ohdsi/webapi/annotation/result/ResultService.java +++ b/src/main/java/org/ohdsi/webapi/annotation/result/ResultService.java @@ -7,6 +7,8 @@ import org.ohdsi.webapi.annotation.annotation.AnnotationService; import org.ohdsi.webapi.annotation.result.Result; import org.ohdsi.webapi.annotation.result.ResultRepository; +import org.ohdsi.webapi.annotation.study.Study; +import org.ohdsi.webapi.annotation.study.StudyService; import org.ohdsi.webapi.cohortsample.CohortSample; import org.ohdsi.webapi.cohortsample.CohortSampleRepository; import org.ohdsi.webapi.cohortsample.CohortSamplingService; @@ -44,9 +46,8 @@ public class ResultService extends AbstractDaoService { @Autowired private AnnotationService annotationService; -// public List getResultsByAnnotationID(int AnnotationID) { -// return resultRepository.findByAnnotationId(AnnotationID); -// } + @Autowired + private StudyService studyService; public List getResultsByAnnotationID(int AnnotationID){ Annotation ourAnno =annotationService.getAnnotationsByAnnotationId(AnnotationID); @@ -101,7 +102,28 @@ public Result getResultByAnnotationIDAndQuestionID(int AnnotationID,int Question return results.get(0); } - public List getResultsByQuestionSetId(int questionSetId) { + public List getResultsByQuestionSetIdAndSampleId(int questionSetId,int sampleId){ + Study study = studyService.getStudyByQuestionSetIdAndSampleId(questionSetId,sampleId); + return getResultsByStudyId(study.getId()); + } + + public List getResultsByStudyId(int studyId){ + Study study = studyService.getStudyById(studyId); + return getResultsByStudy(study); + } + + public List getResultsByStudy(Study study){ + CohortSample sample = study.getCohortSample(); + Source source = getSourceRepository().findBySourceId(sample.getSourceId()); + JdbcTemplate jdbcTemplate = getSourceJdbcTemplate(source); + PreparedStatementRenderer renderer = new PreparedStatementRenderer(source, "/resources/annotationresult/sql/findResultsByStudyId.sql", + new String[]{"results_schema", "CDM_schema"}, + new String[]{source.getTableQualifier(SourceDaimon.DaimonType.Results), source.getTableQualifier(SourceDaimon.DaimonType.CDM)}, + "studyId", study.getId()); + return jdbcTemplate.query(renderer.getSql(),renderer.getOrderedParams(),new ResultRowMapper()); + } + + public List getResultsByQuestionSetId(int questionSetId) { List results = new ArrayList(); List annos=annotationService.getAnnotationsByQuestionSetId(questionSetId); List> collections = annos.stream() @@ -130,7 +152,7 @@ public void deleteResultsByAnnotationIdAndQuestionId(Annotation annotation,int q jdbcTemplate.batchUpdate(deleteStatement, deleteVariables); } - public void insertResults(Annotation annotation, JSONArray results) { + public void insertResults(Annotation annotation, JSONArray results, Study study) { // might want to do a check- if the annotation ID+question ID already exists, update the existing row instead. Other option is just only query the latest instead CohortSample sample = sampleRepository.findById(annotation.getCohortSampleId()); Source source = getSourceRepository().findBySourceId(sample.getSourceId()); @@ -141,7 +163,7 @@ public void insertResults(Annotation annotation, JSONArray results) { String[] parameters = new String[] { "results_schema" }; String[] parameterValues = new String[] { source.getTableQualifier(SourceDaimon.DaimonType.Results) }; - String[] sqlParameters = new String[] { "annotation_id", "question_id", "answer_id", "value", "type" }; + String[] sqlParameters = new String[] { "annotation_id", "question_id", "answer_id", "value", "type", "study_id" }; String statement = null; List variables = new ArrayList<>(); @@ -159,7 +181,8 @@ public void insertResults(Annotation annotation, JSONArray results) { Integer.parseInt(object.get("questionId").toString()), Integer.parseInt(object.get("answerId").toString()), object.get("value").toString(), - object.get("type").toString() }; + object.get("type").toString(), + study.getId()}; PreparedStatementRenderer renderer = new PreparedStatementRenderer(source, "/resources/annotationresult/sql/insertResults.sql", parameters, parameterValues, sqlParameters, sqlValues); diff --git a/src/main/java/org/ohdsi/webapi/annotation/result/SuperResultDto.java b/src/main/java/org/ohdsi/webapi/annotation/result/SuperResultDto.java index a9bd4df236..0f81aade3c 100644 --- a/src/main/java/org/ohdsi/webapi/annotation/result/SuperResultDto.java +++ b/src/main/java/org/ohdsi/webapi/annotation/result/SuperResultDto.java @@ -1,16 +1,27 @@ package org.ohdsi.webapi.annotation.result; + +import org.ohdsi.webapi.annotation.annotation.Annotation; +import org.ohdsi.webapi.annotation.annotation.AnnotationService; +import org.ohdsi.webapi.annotation.question.Question; +import org.ohdsi.webapi.annotation.question.QuestionService; +import org.ohdsi.webapi.annotation.study.Study; +import org.ohdsi.webapi.source.Source; +import org.springframework.beans.factory.annotation.Autowired; + //this table is for human viewing- don't expect to ever review this again public class SuperResultDto { + @Autowired + private AnnotationService annotationService; + + @Autowired + private QuestionService questionService; + private int cohortId; private String cohortName; - private int dataSourceId; + private String dataSourceKey; // can be removed/changed to dataSourceKey - private int cohortSampleId; -// can be removed ( cohortSampleId) private String cohortSampleName; - private int questionSetId; -// can be remove (questionSetId) private String questionSetName; private int patientId; private String questionText; @@ -21,6 +32,32 @@ public SuperResultDto(Result result){ this.value = result.getValue(); } + public SuperResultDto(Result result, Study study, Source source){ + Question myQuestion = questionService.getQuestionByQuestionId(result.getQuestionId()); + this.caseStatus = myQuestion.getCaseQuestion(); + this.questionText = myQuestion.getText(); + Annotation tempanno = annotationService.getAnnotationsByAnnotationId(result.getAnnotation()); + this.value = result.getValue(); + this.patientId = tempanno.getSubjectId(); + this.cohortName= study.getCohortDefinition().getName(); + this.cohortId = study.getCohortDefinition().getId(); + this.dataSourceKey = source.getSourceKey(); + this.cohortSampleName = study.getCohortSample().getName(); + this.questionSetName = study.getQuestionSet().getName(); + } + + public SuperResultDto(Result result, Study study, Source source,Question myQuestion,Annotation tempanno){ + this.caseStatus = myQuestion.getCaseQuestion(); + this.questionText = myQuestion.getText(); + this.value = result.getValue(); + this.patientId = tempanno.getSubjectId(); + this.cohortName= study.getCohortDefinition().getName(); + this.cohortId = study.getCohortDefinition().getId(); + this.dataSourceKey = source.getSourceKey(); + this.cohortSampleName = study.getCohortSample().getName(); + this.questionSetName = study.getQuestionSet().getName(); + } + //***** GETTERS/SETTERS ***** public int getCohortId() { @@ -39,20 +76,12 @@ public void setCohortName(String cohortName) { this.cohortName = cohortName; } - public int getDataSourceId() { - return dataSourceId; - } - - public void setDataSourceId(int dataSourceId) { - this.dataSourceId = dataSourceId; - } - - public int getCohortSampleId() { - return cohortSampleId; + public String getDataSourceKey() { + return dataSourceKey; } - public void setCohortSampleId(int cohortSampleId) { - this.cohortSampleId = cohortSampleId; + public void setDataSourceKey(String dataSourceKey) { + this.dataSourceKey = dataSourceKey; } public String getCohortSampleName() { @@ -63,12 +92,6 @@ public void setCohortSampleName(String cohortSampleName) { this.cohortSampleName = cohortSampleName; } - public int getQuestionSetId() { - return questionSetId; - } - - public void setQuestionSetId(int questionSetId) {this.questionSetId = questionSetId;} - public String getQuestionSetName() {return questionSetName;} public void setQuestionSetName(String questionSetName) { this.questionSetName = questionSetName; } diff --git a/src/main/java/org/ohdsi/webapi/annotation/study/StudyRepository.java b/src/main/java/org/ohdsi/webapi/annotation/study/StudyRepository.java index 3c77c68645..9ab5bd41b3 100644 --- a/src/main/java/org/ohdsi/webapi/annotation/study/StudyRepository.java +++ b/src/main/java/org/ohdsi/webapi/annotation/study/StudyRepository.java @@ -1,7 +1,14 @@ package org.ohdsi.webapi.annotation.study; +import org.ohdsi.webapi.annotation.annotation.Annotation; import org.springframework.data.jpa.repository.JpaRepository; +import org.springframework.data.jpa.repository.Query; public interface StudyRepository extends JpaRepository { + @Query("Select s FROM Study s WHERE s.id = ?1") + public Study findByStudyId(int study_id); + + @Query("Select s FROM Study s WHERE s.questionSet.id = ?1 AND s.cohortSample.id = ?2") + public Study findByQuestionSetIdAndSampleId(int questionSetId,int sampleId); } \ No newline at end of file diff --git a/src/main/java/org/ohdsi/webapi/annotation/study/StudyService.java b/src/main/java/org/ohdsi/webapi/annotation/study/StudyService.java index 1f83991efa..64024a3571 100644 --- a/src/main/java/org/ohdsi/webapi/annotation/study/StudyService.java +++ b/src/main/java/org/ohdsi/webapi/annotation/study/StudyService.java @@ -12,4 +12,10 @@ public class StudyService { public void addStudy(Study study) { studyRepository.save(study); } + public Study getStudyById(int studyId){ + return studyRepository.findByStudyId(studyId); + } + public Study getStudyByQuestionSetIdAndSampleId(int questionSetId, int sampleId){ + return studyRepository.findByQuestionSetIdAndSampleId(questionSetId,sampleId); + } } diff --git a/src/main/resources/ddl/results/annotation_result.sql b/src/main/resources/ddl/results/annotation_result.sql index ab37468bf9..84949b5a11 100644 --- a/src/main/resources/ddl/results/annotation_result.sql +++ b/src/main/resources/ddl/results/annotation_result.sql @@ -4,6 +4,7 @@ CREATE TABLE @results_schema.annotation_result( annotation_id integer NOT NULL, question_id integer NOT NULL, answer_id bigint NOT NULL, + study_id int NOT NULL, value VARCHAR(255) NOT NULL, type VARCHAR(255) NOT NULL, last_update_time datetime DEFAULT GETDATE() diff --git a/src/main/resources/resources/annotationresult/sql/findResultsByStudyId.sql b/src/main/resources/resources/annotationresult/sql/findResultsByStudyId.sql new file mode 100644 index 0000000000..599c8d8127 --- /dev/null +++ b/src/main/resources/resources/annotationresult/sql/findResultsByStudyId.sql @@ -0,0 +1,4 @@ +SELECT * +FROM @results_schema.annotation_result s +WHERE s.study_id in (@studyId) +; \ No newline at end of file diff --git a/src/main/resources/resources/annotationresult/sql/insertResults.sql b/src/main/resources/resources/annotationresult/sql/insertResults.sql index 57ae8aa88a..b357452940 100644 --- a/src/main/resources/resources/annotationresult/sql/insertResults.sql +++ b/src/main/resources/resources/annotationresult/sql/insertResults.sql @@ -1,3 +1,3 @@ -INSERT INTO @results_schema.annotation_result (annotation_id, question_id, answer_id, value, type) -VALUES (@annotation_id, @question_id, @answer_id, @value, @type) +INSERT INTO @results_schema.annotation_result (annotation_id, question_id, answer_id, value, type,study_id) +VALUES (@annotation_id, @question_id, @answer_id, @value, @type, @study_id) ; From 92271b46889dfbfca5583d94ea227b4a91576024 Mon Sep 17 00:00:00 2001 From: Saul Crumpton Date: Thu, 12 Aug 2021 16:01:09 -0400 Subject: [PATCH 24/55] return plain Results from the getResults endpoint --- .../webapi/annotation/result/ResultController.java | 13 ++----------- 1 file changed, 2 insertions(+), 11 deletions(-) diff --git a/src/main/java/org/ohdsi/webapi/annotation/result/ResultController.java b/src/main/java/org/ohdsi/webapi/annotation/result/ResultController.java index 009d2a707f..0fdc5c54ac 100644 --- a/src/main/java/org/ohdsi/webapi/annotation/result/ResultController.java +++ b/src/main/java/org/ohdsi/webapi/annotation/result/ResultController.java @@ -59,20 +59,11 @@ public class ResultController { @GET @Path("/{annotationID}") @Produces(MediaType.APPLICATION_JSON) - public ArrayList getResults(@PathParam("annotationID") String annotationID) { + public List getResults(@PathParam("annotationID") String annotationID) { int annotationIdInt=Integer.parseInt(annotationID); ArrayList al = new ArrayList(); Annotation ourAnno =annotationService.getAnnotationsByAnnotationId(annotationIdInt); - List tempResults = resultService.getResultsByAnnotationID(annotationIdInt); - for(Result tempResult : tempResults ){ - System.out.println(tempResult); - Map testDict =new HashMap(); - testDict.put("questionId",String.valueOf(tempResult.getQuestionId())); - testDict.put("answerId",String.valueOf(tempResult.getAnswerId())); - testDict.put("subjectId",Integer.toString(ourAnno.getSubjectId())); - al.add(testDict); - } - return al; + return resultService.getResultsByAnnotationID(annotationIdInt); } @GET From 3329bdee906eaaa9d11f6eb31af37f14a7a9caf9 Mon Sep 17 00:00:00 2001 From: Saul Crumpton Date: Fri, 13 Aug 2021 15:26:51 -0400 Subject: [PATCH 25/55] changing sampleName to cohortSampleId in AnnotationController --- .../webapi/annotation/annotation/AnnotationController.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationController.java b/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationController.java index 64ad4325e9..98cd5c6c6f 100644 --- a/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationController.java +++ b/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationController.java @@ -124,7 +124,7 @@ public void addResult(@RequestBody String payload) { System.out.println(jsonpayload); System.out.println(jsonpayload.get("results")); System.out.printf("cohortId: %s\n",jsonpayload.get("cohortId").toString()); - System.out.printf("cohortSampleId: %s\n",jsonpayload.get("sampleName").toString()); + System.out.printf("cohortSampleId: %s\n",jsonpayload.get("cohortSampleId").toString()); System.out.printf("subjectId: %s\n",jsonpayload.get("subjectId").toString()); System.out.printf("setId: %s\n",jsonpayload.get("setId").toString()); // TODO: change this to use annotationService.getAnnotationsByAnnotationId potentially From b8b61f426b1c9ad3572a7ff6cfcf2eaa996213e4 Mon Sep 17 00:00:00 2001 From: Saul Crumpton Date: Fri, 13 Aug 2021 15:35:15 -0400 Subject: [PATCH 26/55] changing sampleName to cohortSampleId in AnnotationController pt 2 --- .../webapi/annotation/annotation/AnnotationController.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationController.java b/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationController.java index 98cd5c6c6f..3854f7cb3e 100644 --- a/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationController.java +++ b/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationController.java @@ -128,7 +128,7 @@ public void addResult(@RequestBody String payload) { System.out.printf("subjectId: %s\n",jsonpayload.get("subjectId").toString()); System.out.printf("setId: %s\n",jsonpayload.get("setId").toString()); // TODO: change this to use annotationService.getAnnotationsByAnnotationId potentially - Annotation tempAnnotation = annotationService.getAnnotationByCohortSampleIdAndBySubjectIdAndByQuestionSetId(Integer.parseInt(jsonpayload.get("sampleName").toString()) + Annotation tempAnnotation = annotationService.getAnnotationByCohortSampleIdAndBySubjectIdAndByQuestionSetId(Integer.parseInt(jsonpayload.get("cohortSampleId").toString()) ,Integer.parseInt(jsonpayload.get("subjectId").toString()),Integer.parseInt(jsonpayload.get("setId").toString())).get(0); System.out.printf("annotationID:%d\n",tempAnnotation.getId()); JSONArray array = jsonpayload.getJSONArray("results"); From 734b8b3dffdbca573c09c65de0f5cce745675dcd Mon Sep 17 00:00:00 2001 From: Saul Crumpton Date: Sat, 14 Aug 2021 19:03:10 -0400 Subject: [PATCH 27/55] complete results now querying by sampleId instead of Study ID when the param is passed --- .../org/ohdsi/webapi/annotation/result/ResultController.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/main/java/org/ohdsi/webapi/annotation/result/ResultController.java b/src/main/java/org/ohdsi/webapi/annotation/result/ResultController.java index 0fdc5c54ac..f45c6f341d 100644 --- a/src/main/java/org/ohdsi/webapi/annotation/result/ResultController.java +++ b/src/main/java/org/ohdsi/webapi/annotation/result/ResultController.java @@ -91,7 +91,7 @@ public List getFullResults( study=studyService.getStudyById(studyId); } else if (questionSetId!=0 && cohortSampleId!=0){ - study=studyService.getStudyByQuestionSetIdAndSampleId(questionSetId,studyId); + study=studyService.getStudyByQuestionSetIdAndSampleId(questionSetId,cohortSampleId); } else{ return null; From 47c6b31d55a3fee8a681c07e1db667398b2861a6 Mon Sep 17 00:00:00 2001 From: Saul Crumpton Date: Sun, 15 Aug 2021 19:11:36 -0400 Subject: [PATCH 28/55] finding samples and sets by cohort ID now uses inner join instead of left --- .../org/ohdsi/webapi/annotation/set/QuestionSetRepository.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/main/java/org/ohdsi/webapi/annotation/set/QuestionSetRepository.java b/src/main/java/org/ohdsi/webapi/annotation/set/QuestionSetRepository.java index 0dfbf75d5c..c1909deb7f 100644 --- a/src/main/java/org/ohdsi/webapi/annotation/set/QuestionSetRepository.java +++ b/src/main/java/org/ohdsi/webapi/annotation/set/QuestionSetRepository.java @@ -17,6 +17,6 @@ public interface QuestionSetRepository extends JpaRepository findSamplesAndSetsByCohortId(int cohortId); } From 37542bf08301fb1c8f30e5da37dba398eff839dc Mon Sep 17 00:00:00 2001 From: Saul Crumpton Date: Mon, 16 Aug 2021 21:51:20 -0400 Subject: [PATCH 29/55] adding answer text in additon to answer value to the super table --- .../annotation/answer/AnswerRepository.java | 6 +++- .../annotation/answer/AnswerService.java | 1 + .../annotation/result/ResultController.java | 8 +++++ .../annotation/result/SuperResultDto.java | 31 +++++++++++++------ 4 files changed, 36 insertions(+), 10 deletions(-) diff --git a/src/main/java/org/ohdsi/webapi/annotation/answer/AnswerRepository.java b/src/main/java/org/ohdsi/webapi/annotation/answer/AnswerRepository.java index a09141d027..691274c6f2 100644 --- a/src/main/java/org/ohdsi/webapi/annotation/answer/AnswerRepository.java +++ b/src/main/java/org/ohdsi/webapi/annotation/answer/AnswerRepository.java @@ -2,5 +2,9 @@ import org.springframework.data.jpa.repository.JpaRepository; import org.ohdsi.webapi.annotation.answer.Answer; +import org.springframework.data.jpa.repository.Query; -public interface AnswerRepository extends JpaRepository {} +public interface AnswerRepository extends JpaRepository { + @Query("Select a FROM Answer a WHERE a.id = ?1") + public Answer findByAnswerId(int answerId); +} diff --git a/src/main/java/org/ohdsi/webapi/annotation/answer/AnswerService.java b/src/main/java/org/ohdsi/webapi/annotation/answer/AnswerService.java index b2cf3db7b8..cdd6483792 100644 --- a/src/main/java/org/ohdsi/webapi/annotation/answer/AnswerService.java +++ b/src/main/java/org/ohdsi/webapi/annotation/answer/AnswerService.java @@ -15,4 +15,5 @@ public void addAnswer(Answer answer) { answerRepository.save(answer); } + public Answer getAnswerById(int answerId){return answerRepository.findByAnswerId(answerId);} } diff --git a/src/main/java/org/ohdsi/webapi/annotation/result/ResultController.java b/src/main/java/org/ohdsi/webapi/annotation/result/ResultController.java index f45c6f341d..cf3351745d 100644 --- a/src/main/java/org/ohdsi/webapi/annotation/result/ResultController.java +++ b/src/main/java/org/ohdsi/webapi/annotation/result/ResultController.java @@ -7,6 +7,8 @@ import org.ohdsi.webapi.annotation.annotation.Annotation; import org.ohdsi.webapi.annotation.annotation.AnnotationService; import org.ohdsi.webapi.annotation.annotation.AnnotationSummary; +import org.ohdsi.webapi.annotation.answer.Answer; +import org.ohdsi.webapi.annotation.answer.AnswerService; import org.ohdsi.webapi.annotation.question.Question; import org.ohdsi.webapi.annotation.question.QuestionService; import org.ohdsi.webapi.annotation.set.QuestionSet; @@ -56,6 +58,9 @@ public class ResultController { @Autowired private SourceService sourceService; + @Autowired + private AnswerService answerService; + @GET @Path("/{annotationID}") @Produces(MediaType.APPLICATION_JSON) @@ -111,6 +116,8 @@ else if (questionSetId!=0 && cohortSampleId!=0){ Question myQuestion = questionService.getQuestionByQuestionId(result.getQuestionId()); SuperResultDto tempdto = new SuperResultDto(result); Annotation tempanno = annotationService.getAnnotationsByAnnotationId(result.getAnnotation()); + Answer tempAnswer = answerService.getAnswerById(result.getAnswerId()); + tempdto.setAnswerText(tempAnswer.getText()); tempdto.setPatientId(tempanno.getSubjectId()); tempdto.setCohortName(study.getCohortDefinition().getName()); tempdto.setCohortId( study.getCohortDefinition().getId()); @@ -119,6 +126,7 @@ else if (questionSetId!=0 && cohortSampleId!=0){ tempdto.setQuestionSetName(study.getQuestionSet().getName()); tempdto.setCaseStatus(myQuestion.getCaseQuestion()); tempdto.setQuestionText(myQuestion.getText()); +// tempdto.setAnswerValue(result.getValue()); superList.add(tempdto); } return superList; diff --git a/src/main/java/org/ohdsi/webapi/annotation/result/SuperResultDto.java b/src/main/java/org/ohdsi/webapi/annotation/result/SuperResultDto.java index 0f81aade3c..9732d55a88 100644 --- a/src/main/java/org/ohdsi/webapi/annotation/result/SuperResultDto.java +++ b/src/main/java/org/ohdsi/webapi/annotation/result/SuperResultDto.java @@ -2,6 +2,8 @@ import org.ohdsi.webapi.annotation.annotation.Annotation; import org.ohdsi.webapi.annotation.annotation.AnnotationService; +import org.ohdsi.webapi.annotation.answer.Answer; +import org.ohdsi.webapi.annotation.answer.AnswerService; import org.ohdsi.webapi.annotation.question.Question; import org.ohdsi.webapi.annotation.question.QuestionService; import org.ohdsi.webapi.annotation.study.Study; @@ -17,27 +19,32 @@ public class SuperResultDto { @Autowired private QuestionService questionService; + @Autowired + private AnswerService answerService; + private int cohortId; private String cohortName; private String dataSourceKey; -// can be removed/changed to dataSourceKey private String cohortSampleName; private String questionSetName; private int patientId; private String questionText; - private String value; + private String answerText; + private String answerValue; private Boolean caseStatus; public SuperResultDto(Result result){ - this.value = result.getValue(); + this.answerValue = result.getValue(); } public SuperResultDto(Result result, Study study, Source source){ Question myQuestion = questionService.getQuestionByQuestionId(result.getQuestionId()); this.caseStatus = myQuestion.getCaseQuestion(); this.questionText = myQuestion.getText(); + Answer tempAnswer = answerService.getAnswerById(result.getAnswerId()); + this.answerText = tempAnswer.getText(); Annotation tempanno = annotationService.getAnnotationsByAnnotationId(result.getAnnotation()); - this.value = result.getValue(); + this.answerValue = result.getValue(); this.patientId = tempanno.getSubjectId(); this.cohortName= study.getCohortDefinition().getName(); this.cohortId = study.getCohortDefinition().getId(); @@ -49,13 +56,15 @@ public SuperResultDto(Result result, Study study, Source source){ public SuperResultDto(Result result, Study study, Source source,Question myQuestion,Annotation tempanno){ this.caseStatus = myQuestion.getCaseQuestion(); this.questionText = myQuestion.getText(); - this.value = result.getValue(); + this.answerValue = result.getValue(); this.patientId = tempanno.getSubjectId(); this.cohortName= study.getCohortDefinition().getName(); this.cohortId = study.getCohortDefinition().getId(); this.dataSourceKey = source.getSourceKey(); this.cohortSampleName = study.getCohortSample().getName(); this.questionSetName = study.getQuestionSet().getName(); + Answer tempAnswer = answerService.getAnswerById(result.getAnswerId()); + this.answerText = tempAnswer.getText(); } //***** GETTERS/SETTERS ***** @@ -112,12 +121,16 @@ public void setQuestionText(String questionText) { this.questionText = questionText; } - public String getValue() { - return value; + public String getAnswerText() {return answerText;} + + public void setAnswerText(String answerText) {this.answerText = answerText;} + + public String getAnswerValue() { + return answerValue; } - public void setValue(String value) { - this.value = value; + public void setAnswerValue(String answerValue) { + this.answerValue = answerValue; } public Boolean getCaseStatus() { From 6bd6d6687f83e5f4d70b9e52597e9ed65e769cec Mon Sep 17 00:00:00 2001 From: Saul Crumpton Date: Tue, 17 Aug 2021 19:07:48 -0400 Subject: [PATCH 30/55] setting AnswerValue now --- .../org/ohdsi/webapi/annotation/result/ResultController.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/main/java/org/ohdsi/webapi/annotation/result/ResultController.java b/src/main/java/org/ohdsi/webapi/annotation/result/ResultController.java index cf3351745d..fd7d96205a 100644 --- a/src/main/java/org/ohdsi/webapi/annotation/result/ResultController.java +++ b/src/main/java/org/ohdsi/webapi/annotation/result/ResultController.java @@ -118,6 +118,7 @@ else if (questionSetId!=0 && cohortSampleId!=0){ Annotation tempanno = annotationService.getAnnotationsByAnnotationId(result.getAnnotation()); Answer tempAnswer = answerService.getAnswerById(result.getAnswerId()); tempdto.setAnswerText(tempAnswer.getText()); + tempdto.setAnswerValue(tempAnswer.getValue()); tempdto.setPatientId(tempanno.getSubjectId()); tempdto.setCohortName(study.getCohortDefinition().getName()); tempdto.setCohortId( study.getCohortDefinition().getId()); @@ -126,7 +127,6 @@ else if (questionSetId!=0 && cohortSampleId!=0){ tempdto.setQuestionSetName(study.getQuestionSet().getName()); tempdto.setCaseStatus(myQuestion.getCaseQuestion()); tempdto.setQuestionText(myQuestion.getText()); -// tempdto.setAnswerValue(result.getValue()); superList.add(tempdto); } return superList; From abca93c4f89bdd6573503f8b2addbc44b888497e Mon Sep 17 00:00:00 2001 From: Saul Crumpton Date: Wed, 18 Aug 2021 19:37:31 -0400 Subject: [PATCH 31/55] using LinkedHashSet for QuestionSet to ensure we add questions in order --- .../java/org/ohdsi/webapi/annotation/set/QuestionSet.java | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/src/main/java/org/ohdsi/webapi/annotation/set/QuestionSet.java b/src/main/java/org/ohdsi/webapi/annotation/set/QuestionSet.java index a355f1dc4b..33013f8927 100644 --- a/src/main/java/org/ohdsi/webapi/annotation/set/QuestionSet.java +++ b/src/main/java/org/ohdsi/webapi/annotation/set/QuestionSet.java @@ -1,6 +1,7 @@ package org.ohdsi.webapi.annotation.set; import java.util.HashSet; +import java.util.LinkedHashSet; import java.util.Set; import javax.persistence.Column; import javax.persistence.Entity; @@ -32,7 +33,7 @@ public class QuestionSet { cascade = CascadeType.ALL, orphanRemoval = true ) - private Set questions = new HashSet(); + private Set questions = new LinkedHashSet(); //***** GETTERS/SETTERS ****** @@ -83,13 +84,13 @@ public void setName(String name) { * @return the questions */ public Set getQuestions() { - return new HashSet(questions); + return new LinkedHashSet(questions); } /** * @param questions the questions to set */ - protected void setQuestions(Set questions) { + protected void setQuestions(LinkedHashSet questions) { this.questions = questions; } From c880d3d32f2f7d41771340f5577b423570f22852 Mon Sep 17 00:00:00 2001 From: Saul Crumpton Date: Wed, 18 Aug 2021 20:14:54 -0400 Subject: [PATCH 32/55] can now delete questionSets --- .../annotation/set/QuestionSetController.java | 22 ++++++++++++++----- .../annotation/set/QuestionSetService.java | 15 ++++++++++++- 2 files changed, 30 insertions(+), 7 deletions(-) diff --git a/src/main/java/org/ohdsi/webapi/annotation/set/QuestionSetController.java b/src/main/java/org/ohdsi/webapi/annotation/set/QuestionSetController.java index bede372449..d1d84e2e76 100644 --- a/src/main/java/org/ohdsi/webapi/annotation/set/QuestionSetController.java +++ b/src/main/java/org/ohdsi/webapi/annotation/set/QuestionSetController.java @@ -1,16 +1,12 @@ package org.ohdsi.webapi.annotation.set; import java.util.List; -import javax.ws.rs.GET; -import javax.ws.rs.POST; -import javax.ws.rs.Path; -import javax.ws.rs.Consumes; -import javax.ws.rs.Produces; +import javax.ws.rs.*; import javax.ws.rs.core.MediaType; -import javax.ws.rs.QueryParam; import org.ohdsi.webapi.annotation.annotation.Annotation; import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.http.ResponseEntity; import org.springframework.stereotype.Component; import org.ohdsi.webapi.annotation.set.QuestionSetService; import org.ohdsi.webapi.annotation.set.QuestionSet; @@ -43,6 +39,20 @@ public List getSets( return questionSetService.getSamplesAndSetsByCohortId(cohortId); } + @GET + @Path("deleteSet/{questionSetId}") + @Produces(MediaType.APPLICATION_JSON) + public ResponseEntity deleteSet( + @PathParam("questionSetId") int questionSetId + ) { + if(questionSetService.deleteQuestionSet(questionSetId)){ + return ResponseEntity.status(200).body("The Question Set has been deleted"); + } + else{ + return ResponseEntity.status(400).body("Could not delete the Question Set"); + } + } + @POST @Path("sets") @Consumes(MediaType.APPLICATION_JSON) diff --git a/src/main/java/org/ohdsi/webapi/annotation/set/QuestionSetService.java b/src/main/java/org/ohdsi/webapi/annotation/set/QuestionSetService.java index 08c972b7fa..6c81a1d16f 100644 --- a/src/main/java/org/ohdsi/webapi/annotation/set/QuestionSetService.java +++ b/src/main/java/org/ohdsi/webapi/annotation/set/QuestionSetService.java @@ -1,6 +1,6 @@ package org.ohdsi.webapi.annotation.set; -import org.ohdsi.webapi.annotation.annotation.Annotation; +import org.ohdsi.webapi.annotation.annotation.AnnotationService; import org.springframework.stereotype.Service; import org.springframework.beans.factory.annotation.Autowired; import java.util.ArrayList; @@ -14,6 +14,9 @@ public class QuestionSetService { @Autowired private QuestionSetRepository questionSetRepository; + @Autowired + private AnnotationService annotationService; + public List getSets() { List sets = new ArrayList(); questionSetRepository.findAll() @@ -39,4 +42,14 @@ public QuestionSet findQuestionSetByQuestionSetId(int questionSetId){ public List getSamplesAndSetsByCohortId(int cohortId) { return questionSetRepository.findSamplesAndSetsByCohortId(cohortId); } + + public boolean deleteQuestionSet(int questionSetId) { + if(annotationService.getAnnotationsByQuestionSetId(questionSetId).isEmpty()){ + questionSetRepository.delete(questionSetId); + return true; + } + else{ + return false; + } + } } From 18a4d021f751a7371f709cf311453dc900ca6708 Mon Sep 17 00:00:00 2001 From: Saul Crumpton Date: Fri, 20 Aug 2021 13:58:27 -0400 Subject: [PATCH 33/55] Adding orderby for questionSet Question retrieval --- .../org/ohdsi/webapi/annotation/set/QuestionSet.java | 11 +++-------- 1 file changed, 3 insertions(+), 8 deletions(-) diff --git a/src/main/java/org/ohdsi/webapi/annotation/set/QuestionSet.java b/src/main/java/org/ohdsi/webapi/annotation/set/QuestionSet.java index 33013f8927..88aaedb19e 100644 --- a/src/main/java/org/ohdsi/webapi/annotation/set/QuestionSet.java +++ b/src/main/java/org/ohdsi/webapi/annotation/set/QuestionSet.java @@ -3,14 +3,8 @@ import java.util.HashSet; import java.util.LinkedHashSet; import java.util.Set; -import javax.persistence.Column; -import javax.persistence.Entity; -import javax.persistence.GeneratedValue; -import javax.persistence.CascadeType; -import javax.persistence.FetchType; -import javax.persistence.OneToMany; -import javax.persistence.Id; -import javax.persistence.Table; +import javax.persistence.*; + import org.ohdsi.webapi.annotation.question.Question; @Entity(name = "QuestionSet") @@ -33,6 +27,7 @@ public class QuestionSet { cascade = CascadeType.ALL, orphanRemoval = true ) + @OrderBy("id") private Set questions = new LinkedHashSet(); //***** GETTERS/SETTERS ****** From 11f9df0a48623b07adf2ba11b3c716b30147ab12 Mon Sep 17 00:00:00 2001 From: Saul Crumpton Date: Sat, 21 Aug 2021 14:41:04 -0400 Subject: [PATCH 34/55] checking to delete Results by annotation only instead of using questionid as well --- .../annotation/result/ResultService.java | 24 +++++-------------- .../sql/deleteResultsByAnnotationId.sql | 3 +++ ...leteResultsByAnnotationIdAndQuestionId.sql | 3 --- 3 files changed, 9 insertions(+), 21 deletions(-) create mode 100644 src/main/resources/resources/annotationresult/sql/deleteResultsByAnnotationId.sql delete mode 100644 src/main/resources/resources/annotationresult/sql/deleteResultsByAnnotationIdAndQuestionId.sql diff --git a/src/main/java/org/ohdsi/webapi/annotation/result/ResultService.java b/src/main/java/org/ohdsi/webapi/annotation/result/ResultService.java index 8ff0a58939..661f32be7e 100644 --- a/src/main/java/org/ohdsi/webapi/annotation/result/ResultService.java +++ b/src/main/java/org/ohdsi/webapi/annotation/result/ResultService.java @@ -1,18 +1,13 @@ package org.ohdsi.webapi.annotation.result; -import io.swagger.models.auth.In; import org.json.JSONArray; import org.json.JSONObject; import org.ohdsi.webapi.annotation.annotation.Annotation; import org.ohdsi.webapi.annotation.annotation.AnnotationService; -import org.ohdsi.webapi.annotation.result.Result; -import org.ohdsi.webapi.annotation.result.ResultRepository; import org.ohdsi.webapi.annotation.study.Study; import org.ohdsi.webapi.annotation.study.StudyService; import org.ohdsi.webapi.cohortsample.CohortSample; import org.ohdsi.webapi.cohortsample.CohortSampleRepository; -import org.ohdsi.webapi.cohortsample.CohortSamplingService; -import org.ohdsi.webapi.cohortsample.SampleElement; import org.ohdsi.webapi.service.AbstractDaoService; import org.ohdsi.webapi.source.Source; import org.ohdsi.webapi.source.SourceDaimon; @@ -22,15 +17,9 @@ import org.springframework.stereotype.Service; import org.ohdsi.webapi.util.PreparedStatementRenderer; -import javax.ws.rs.Consumes; -import javax.ws.rs.POST; -import javax.ws.rs.Path; -import javax.ws.rs.core.MediaType; import java.sql.ResultSet; import java.sql.SQLException; import java.util.ArrayList; -import java.util.Collection; -import java.util.Collections; import java.util.List; import java.util.stream.Collectors; @@ -137,16 +126,16 @@ public List getResultsByQuestionSetId(int questionSetId) { return results; } - public void deleteResultsByAnnotationIdAndQuestionId(Annotation annotation,int questionId){ + public void deleteResultsByAnnotationId(Annotation annotation){ List deleteVariables = new ArrayList<>(); CohortSample sample = sampleRepository.findById(annotation.getCohortSampleId()); Source source = getSourceRepository().findBySourceId(sample.getSourceId()); JdbcTemplate jdbcTemplate = getSourceJdbcTemplate(source); String[] parameters = new String[] { "results_schema" }; String[] parameterValues = new String[] { source.getTableQualifier(SourceDaimon.DaimonType.Results) }; - String[] deletesqlParameters = new String[] { "annotation_id", "question_id"}; - Object[] deletesqlValues = new Object[] {annotation.getId(),questionId}; - PreparedStatementRenderer deleterenderer = new PreparedStatementRenderer(source, "/resources/annotationresult/sql/deleteResultsByAnnotationIdAndQuestionId.sql", parameters, parameterValues, deletesqlParameters, deletesqlValues); + String[] deletesqlParameters = new String[] { "annotation_id"}; + Object[] deletesqlValues = new Object[] {annotation.getId()}; + PreparedStatementRenderer deleterenderer = new PreparedStatementRenderer(source, "/resources/annotationresult/sql/deleteResultsByAnnotationId.sql", parameters, parameterValues, deletesqlParameters, deletesqlValues); String deleteStatement = deleterenderer.getSql(); deleteVariables.add(deleterenderer.getOrderedParams()); jdbcTemplate.batchUpdate(deleteStatement, deleteVariables); @@ -170,10 +159,9 @@ public void insertResults(Annotation annotation, JSONArray results, Study study) Boolean hasCleared=false; for(int i=0; i < results.length(); i++){ JSONObject object = results.getJSONObject(i); -// I can check here by AnnotationID only? TODO - if(!hasCleared && getResultByAnnotationIDAndQuestionID(annotation.getId(),Integer.parseInt(object.get("questionId").toString()))!=null){ + if(!hasCleared && !getResultsByAnnotationID(annotation.getId()).isEmpty()){ // this entry already exists, need to update here instead of adding to the pile - deleteResultsByAnnotationIdAndQuestionId(annotation,Integer.parseInt(object.get("questionId").toString())); + deleteResultsByAnnotationId(annotation); hasCleared=true; } Object[] sqlValues = new Object[] { diff --git a/src/main/resources/resources/annotationresult/sql/deleteResultsByAnnotationId.sql b/src/main/resources/resources/annotationresult/sql/deleteResultsByAnnotationId.sql new file mode 100644 index 0000000000..365f4b6c15 --- /dev/null +++ b/src/main/resources/resources/annotationresult/sql/deleteResultsByAnnotationId.sql @@ -0,0 +1,3 @@ +DELETE FROM @results_schema.annotation_result +WHERE annotation_id = @annotation_id +; diff --git a/src/main/resources/resources/annotationresult/sql/deleteResultsByAnnotationIdAndQuestionId.sql b/src/main/resources/resources/annotationresult/sql/deleteResultsByAnnotationIdAndQuestionId.sql deleted file mode 100644 index 041c00cf27..0000000000 --- a/src/main/resources/resources/annotationresult/sql/deleteResultsByAnnotationIdAndQuestionId.sql +++ /dev/null @@ -1,3 +0,0 @@ -DELETE FROM @results_schema.annotation_result -WHERE annotation_id = @annotation_id AND question_id = @question_id -; From c793786628681fd546fb2e81b4003601ed538ec9 Mon Sep 17 00:00:00 2001 From: Saul Crumpton Date: Sat, 21 Aug 2021 15:13:43 -0400 Subject: [PATCH 35/55] getting answer value from result instead of answer for super table --- .../org/ohdsi/webapi/annotation/result/ResultController.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/main/java/org/ohdsi/webapi/annotation/result/ResultController.java b/src/main/java/org/ohdsi/webapi/annotation/result/ResultController.java index fd7d96205a..c954bc08cc 100644 --- a/src/main/java/org/ohdsi/webapi/annotation/result/ResultController.java +++ b/src/main/java/org/ohdsi/webapi/annotation/result/ResultController.java @@ -118,7 +118,7 @@ else if (questionSetId!=0 && cohortSampleId!=0){ Annotation tempanno = annotationService.getAnnotationsByAnnotationId(result.getAnnotation()); Answer tempAnswer = answerService.getAnswerById(result.getAnswerId()); tempdto.setAnswerText(tempAnswer.getText()); - tempdto.setAnswerValue(tempAnswer.getValue()); + tempdto.setAnswerValue(result.getValue()); tempdto.setPatientId(tempanno.getSubjectId()); tempdto.setCohortName(study.getCohortDefinition().getName()); tempdto.setCohortId( study.getCohortDefinition().getId()); From 514673b6e25133987e57d24404f81656ef408854 Mon Sep 17 00:00:00 2001 From: Charity Hilton Date: Sun, 22 Aug 2021 10:40:42 -0400 Subject: [PATCH 36/55] merge master into annotation feature; rename flyway to reflect latest version --- ...5.1__annotation.sql => V2.10.1.20210822101500__annotation.sql} | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename src/main/resources/db/migration/postgresql/{V2.5.1__annotation.sql => V2.10.1.20210822101500__annotation.sql} (100%) diff --git a/src/main/resources/db/migration/postgresql/V2.5.1__annotation.sql b/src/main/resources/db/migration/postgresql/V2.10.1.20210822101500__annotation.sql similarity index 100% rename from src/main/resources/db/migration/postgresql/V2.5.1__annotation.sql rename to src/main/resources/db/migration/postgresql/V2.10.1.20210822101500__annotation.sql From 1bbf4dd16d4ec8ebb10116326250480c1ade9cb6 Mon Sep 17 00:00:00 2001 From: Saul Crumpton Date: Sun, 22 Aug 2021 11:13:43 -0400 Subject: [PATCH 37/55] removing todo from nav service to navigate by sample name- this will never be supported --- .../ohdsi/webapi/annotation/navigation/NavigationService.java | 2 -- 1 file changed, 2 deletions(-) diff --git a/src/main/java/org/ohdsi/webapi/annotation/navigation/NavigationService.java b/src/main/java/org/ohdsi/webapi/annotation/navigation/NavigationService.java index e6fc687391..7485e48ad5 100644 --- a/src/main/java/org/ohdsi/webapi/annotation/navigation/NavigationService.java +++ b/src/main/java/org/ohdsi/webapi/annotation/navigation/NavigationService.java @@ -34,8 +34,6 @@ public Navigation navData(Navigation nav, int subjectId, String sampleName, int if (sampleName.indexOf("_") != -1) { sampleName = sampleName.replaceAll("_", " "); } -// List sample = cohortSampleRepository.getNavSample(sampleName); -// TODO impmlement above funtion List sample = new ArrayList(); int annCount = 0; boolean foundNext = false; From dd28f06496da018fa9ede06bca18d2786a33840a Mon Sep 17 00:00:00 2001 From: Saul Crumpton Date: Sun, 22 Aug 2021 11:14:10 -0400 Subject: [PATCH 38/55] removing unused result link in Annotation entity --- .../ohdsi/webapi/annotation/annotation/Annotation.java | 8 -------- 1 file changed, 8 deletions(-) diff --git a/src/main/java/org/ohdsi/webapi/annotation/annotation/Annotation.java b/src/main/java/org/ohdsi/webapi/annotation/annotation/Annotation.java index ac0fe9ad5d..ed4be77891 100644 --- a/src/main/java/org/ohdsi/webapi/annotation/annotation/Annotation.java +++ b/src/main/java/org/ohdsi/webapi/annotation/annotation/Annotation.java @@ -42,14 +42,6 @@ public class Annotation { @JoinColumn(name = "question_set_id") private QuestionSet questionSet; - // @OneToMany( - // fetch = FetchType.EAGER, - // mappedBy = "annotation", - // cascade = CascadeType.ALL, - // orphanRemoval = true - // ) - // private Set results = new HashSet(); - //***** GETTERS/SETTERS ****** /** From 4f08ca29635a10b02dbbfe77fbcb4c2a9dd20f03 Mon Sep 17 00:00:00 2001 From: Saul Crumpton Date: Sun, 22 Aug 2021 11:14:35 -0400 Subject: [PATCH 39/55] removing unused sample_name field from annotation --- .../org/ohdsi/webapi/annotation/annotation/Annotation.java | 3 --- 1 file changed, 3 deletions(-) diff --git a/src/main/java/org/ohdsi/webapi/annotation/annotation/Annotation.java b/src/main/java/org/ohdsi/webapi/annotation/annotation/Annotation.java index ed4be77891..fe5a17fc87 100644 --- a/src/main/java/org/ohdsi/webapi/annotation/annotation/Annotation.java +++ b/src/main/java/org/ohdsi/webapi/annotation/annotation/Annotation.java @@ -35,9 +35,6 @@ public class Annotation { @Column(name = "cohort_sample_id") private int cohortSampleId; - // @Column(name = "sample_name") - // private String sampleName; - @ManyToOne @JoinColumn(name = "question_set_id") private QuestionSet questionSet; From c3755030f97c0d3899d4656294a8c7c98a3bfaa1 Mon Sep 17 00:00:00 2001 From: Saul Crumpton Date: Sun, 22 Aug 2021 11:15:13 -0400 Subject: [PATCH 40/55] removing unused getters and setters in Annotation Entity --- .../annotation/annotation/Annotation.java | 30 +------------------ 1 file changed, 1 insertion(+), 29 deletions(-) diff --git a/src/main/java/org/ohdsi/webapi/annotation/annotation/Annotation.java b/src/main/java/org/ohdsi/webapi/annotation/annotation/Annotation.java index fe5a17fc87..9924a5acb3 100644 --- a/src/main/java/org/ohdsi/webapi/annotation/annotation/Annotation.java +++ b/src/main/java/org/ohdsi/webapi/annotation/annotation/Annotation.java @@ -96,33 +96,5 @@ public QuestionSet getQuestionSet() { public void setQuestionSet(QuestionSet questionSet) { this.questionSet = questionSet; } - - // /** - // * @return the results - // */ - // public Set getResults() { - // return new HashSet(results); - // } - - // /** - // * @param results the results to set - // */ - // protected void setResults(Set results) { - // this.results = results; - // } - - // public void addToResults(Result result) { - // result.setAnnotation(this); - // this.results.add(result); - // } - - -// public void setSampleName(String name) { -// this.sampleName = name; -// } - -// public String getSampleName() { -// return this.sampleName; -// } - + } From d0dfb87b7d6eb3ded17c2fa159254d416ab66494 Mon Sep 17 00:00:00 2001 From: Saul Crumpton Date: Sun, 22 Aug 2021 11:15:41 -0400 Subject: [PATCH 41/55] removing unused imports from Annotation Entity --- .../webapi/annotation/annotation/Annotation.java | 11 +---------- 1 file changed, 1 insertion(+), 10 deletions(-) diff --git a/src/main/java/org/ohdsi/webapi/annotation/annotation/Annotation.java b/src/main/java/org/ohdsi/webapi/annotation/annotation/Annotation.java index 9924a5acb3..2ede5b60fb 100644 --- a/src/main/java/org/ohdsi/webapi/annotation/annotation/Annotation.java +++ b/src/main/java/org/ohdsi/webapi/annotation/annotation/Annotation.java @@ -1,22 +1,13 @@ package org.ohdsi.webapi.annotation.annotation; -import java.util.HashSet; -import java.util.Set; import javax.persistence.Column; import javax.persistence.Entity; import javax.persistence.GeneratedValue; -import javax.persistence.CascadeType; -import javax.persistence.FetchType; -import javax.persistence.OneToMany; import javax.persistence.ManyToOne; import javax.persistence.JoinColumn; import javax.persistence.Id; import javax.persistence.Table; - -import com.fasterxml.jackson.annotation.JsonIgnoreProperties; -import org.ohdsi.webapi.annotation.result.Result; import org.ohdsi.webapi.annotation.set.QuestionSet; -import com.fasterxml.jackson.annotation.JsonIgnore; @Entity(name = "Annotation") @Table( @@ -96,5 +87,5 @@ public QuestionSet getQuestionSet() { public void setQuestionSet(QuestionSet questionSet) { this.questionSet = questionSet; } - + } From f0421a1d08d4fce235e15129c91c1ceb7344855f Mon Sep 17 00:00:00 2001 From: Saul Crumpton Date: Sun, 22 Aug 2021 11:18:18 -0400 Subject: [PATCH 42/55] removing unused code in AnnotationController, also removing only-for-testing API endpoints --- .../annotation/AnnotationController.java | 34 +------------------ 1 file changed, 1 insertion(+), 33 deletions(-) diff --git a/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationController.java b/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationController.java index 3854f7cb3e..fd828f0089 100644 --- a/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationController.java +++ b/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationController.java @@ -79,7 +79,7 @@ public List getAnnotations( returnAnnotations = getFullAnnotations(cohortSampleId,subjectId,setId); List summaries = new ArrayList(); for(Annotation singleAnno : returnAnnotations){ -// TODO see about doing this in a more performant manner? +// can we see about doing this in a more performant manner? AnnotationSummary tempAnnoSummary=new AnnotationSummary(singleAnno); summaries.add(tempAnnoSummary); } @@ -134,16 +134,6 @@ public void addResult(@RequestBody String payload) { JSONArray array = jsonpayload.getJSONArray("results"); Study study = studyService.getStudyByQuestionSetIdAndSampleId(jsonpayload.getInt("setId"),jsonpayload.getInt("cohortSampleId") ); resultService.insertResults(tempAnnotation,array,study); -// for(int i=0; i < array.length(); i++){ -// JSONObject object = array.getJSONObject(i); -// Result result = new Result(); -// result.setQuestionId(Long.parseLong(object.get("questionId").toString())); -// result.setAnswerId(Long.parseLong(object.get("answerId").toString())); -// result.setValue(object.get("value").toString()); -// result.setType(object.get("type").toString()); -// result.setAnnotation(tempAnnotation); -// resultService.save(result); -// } } @POST @@ -176,28 +166,6 @@ public void addAnnotation(@RequestBody String payload) { } } -//just for testing - @Path("/csvData") - @GET - @Produces(MediaType.APPLICATION_JSON) - public List getAnnotationCSV( - @QueryParam("cohortID") int cohortID, - @QueryParam("sourceKey") String sourceKey, - @QueryParam("sampleName") String sampleName - ) { - - if (sampleName.indexOf("_") != -1) { - sampleName = sampleName.replaceAll("_", " "); - } - - if (cohortID == 0 || sourceKey == null || sampleName == null) { - return null; - } - - return annotationService.getAnnotationCSVData(cohortID, sourceKey, sampleName); - - } - @GET @Path("/{annotationID}") @Produces(MediaType.APPLICATION_JSON) From 712c3885fb7496aa264fe1d690e4d5d0a6ec9d1b Mon Sep 17 00:00:00 2001 From: Saul Crumpton Date: Sun, 22 Aug 2021 11:32:20 -0400 Subject: [PATCH 43/55] removing todo for searching for annotation by annotationID instead of by CohortSampleId and SubjectId and QuestionSetId --- .../webapi/annotation/annotation/AnnotationController.java | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationController.java b/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationController.java index fd828f0089..f24e2638e5 100644 --- a/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationController.java +++ b/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationController.java @@ -127,9 +127,7 @@ public void addResult(@RequestBody String payload) { System.out.printf("cohortSampleId: %s\n",jsonpayload.get("cohortSampleId").toString()); System.out.printf("subjectId: %s\n",jsonpayload.get("subjectId").toString()); System.out.printf("setId: %s\n",jsonpayload.get("setId").toString()); -// TODO: change this to use annotationService.getAnnotationsByAnnotationId potentially - Annotation tempAnnotation = annotationService.getAnnotationByCohortSampleIdAndBySubjectIdAndByQuestionSetId(Integer.parseInt(jsonpayload.get("cohortSampleId").toString()) - ,Integer.parseInt(jsonpayload.get("subjectId").toString()),Integer.parseInt(jsonpayload.get("setId").toString())).get(0); + Annotation tempAnnotation = annotationService.getAnnotationsByAnnotationId(jsonpayload.getInt("id")); System.out.printf("annotationID:%d\n",tempAnnotation.getId()); JSONArray array = jsonpayload.getJSONArray("results"); Study study = studyService.getStudyByQuestionSetIdAndSampleId(jsonpayload.getInt("setId"),jsonpayload.getInt("cohortSampleId") ); From 8854ba4a8f24159f00b201e798048a98327f4619 Mon Sep 17 00:00:00 2001 From: Saul Crumpton Date: Sun, 22 Aug 2021 11:39:04 -0400 Subject: [PATCH 44/55] removing unused imports from AnnotationController and AnnotationService. Also removing non-useful code and unused imports --- .../annotation/AnnotationController.java | 9 -- .../annotation/AnnotationService.java | 86 +++---------------- 2 files changed, 10 insertions(+), 85 deletions(-) diff --git a/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationController.java b/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationController.java index f24e2638e5..e6e9f6a3df 100644 --- a/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationController.java +++ b/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationController.java @@ -1,9 +1,7 @@ package org.ohdsi.webapi.annotation.annotation; import java.util.ArrayList; -import java.util.HashMap; import java.util.List; -import java.util.Map; import javax.ws.rs.GET; import javax.ws.rs.POST; import javax.ws.rs.Path; @@ -14,7 +12,6 @@ import javax.ws.rs.PathParam; import org.json.JSONObject; import org.json.JSONArray; - import org.ohdsi.webapi.annotation.result.ResultService; import org.ohdsi.webapi.annotation.study.Study; import org.ohdsi.webapi.annotation.study.StudyService; @@ -23,20 +20,14 @@ import org.ohdsi.webapi.cohortsample.CohortSample; import org.ohdsi.webapi.cohortsample.CohortSampleRepository; import org.ohdsi.webapi.cohortsample.CohortSamplingService; -import org.ohdsi.webapi.cohortsample.SampleElement; -import org.ohdsi.webapi.cohortsample.dto.CohortSampleDTO; import org.ohdsi.webapi.cohortsample.dto.SampleElementDTO; import org.ohdsi.webapi.source.Source; import org.ohdsi.webapi.source.SourceService; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Component; -import org.ohdsi.webapi.annotation.annotation.AnnotationService; -import org.ohdsi.webapi.annotation.annotation.Annotation; import org.ohdsi.webapi.annotation.set.QuestionSetRepository; import org.ohdsi.webapi.annotation.set.QuestionSet; -import org.ohdsi.webapi.annotation.result.Result; import org.springframework.web.bind.annotation.RequestBody; -import org.ohdsi.webapi.service.AbstractDaoService; @Path("annotations") diff --git a/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationService.java b/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationService.java index 85feeb803c..ba015bf0be 100644 --- a/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationService.java +++ b/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationService.java @@ -4,18 +4,6 @@ import org.springframework.beans.factory.annotation.Autowired; import java.util.ArrayList; import java.util.List; -import java.util.Set; -import org.ohdsi.webapi.annotation.annotation.AnnotationRepository; -import org.ohdsi.webapi.annotation.set.QuestionSet; -import org.ohdsi.webapi.annotation.question.Question; -import org.ohdsi.webapi.annotation.result.Result; -import org.ohdsi.webapi.annotation.result.ResultRepository; -import org.ohdsi.webapi.annotation.set.QuestionSetRepository; -// import org.aspectj.weaver.patterns.TypePatternQuestions.Question; -import org.ohdsi.webapi.annotation.annotation.Annotation; -import org.ohdsi.webapi.cohortsample.CohortSampleRepository; -import org.ohdsi.webapi.cohortsample.CohortSample; - @Service public class AnnotationService { @@ -23,15 +11,6 @@ public class AnnotationService { @Autowired private AnnotationRepository annotationRepository; - @Autowired - private CohortSampleRepository cohortSampleRepository; - - @Autowired - private QuestionSetRepository questionSetRepository; - - @Autowired - private ResultRepository resultRepository; - public List getAnnotations() { List annotations = new ArrayList(); annotationRepository.findAll().forEach(annotations::add); @@ -43,10 +22,10 @@ public Annotation getAnnotationsByAnnotationId(int annotationId) { return result; } - public Annotation getAnnotationsByAnnotationId(Annotation annotation) { - Annotation result = annotationRepository.findByAnnotationId(annotation.getId()); - return result; - } + public Annotation getAnnotationsByAnnotationId(Annotation annotation) { + Annotation result = annotationRepository.findByAnnotationId(annotation.getId()); + return result; + } public List getAnnotationByCohortSampleIdAndBySubjectIdAndByQuestionSetId(int cohortSampleId, int subjectId, int questionSetId) { System.out.printf("cohortSampleId %d\n",cohortSampleId); @@ -68,59 +47,14 @@ public List getAnnotationByCohortSampleIdAndByQuestionSetId(int coho return annotations; } - public Annotation addAnnotation(Annotation annotation, String name) { -// cohortSampleRepository.annotated(name, annotation.getSubjectId(), annotation.getCohortId()); -// TODO implement above function and getSampleMembership + public Annotation addAnnotation(Annotation annotation) { return annotationRepository.save(annotation); } - public Annotation addAnnotation(Annotation annotation) { - return annotationRepository.save(annotation); - } - - public List getAnnotationCSVData(int cohortID, String source, String sampleName) { - List results = new ArrayList(); -// List samples = cohortSampleRepository.getSampleMembership(sampleName, cohortID); - List samples = new ArrayList(); - Set questionSet = questionSetRepository.findByCohortId(cohortID); - List qs = new ArrayList(questionSet); - List qIDs = new ArrayList(); - - for (Question q: qs.get(0).getQuestions()) { - qIDs.add(q.getId()); - } - - Object[] metaData = new Object[3]; - metaData[0] = source; - metaData[1] = cohortID; - metaData[2] = questionSet; - - results.add(metaData); - - - for (int i = 0; i answers = new ArrayList<>(); - for (int j = 0; j < qIDs.size(); j++) { -// TODO fix if necessary -// answers.add(resultRepository.getAnswers(sampleName, qIDs.get(j), samples.get(i))); - } - - row[1] = answers; - - - results.add(row); - } - - return results; + public List getAnnotationsByCohortSampleId(int cohortSampleId) { + return annotationRepository.findByCohortSampleId(cohortSampleId); + } + public List getAnnotationsByQuestionSetId(int questionSetId) { + return annotationRepository.findByQuestionSetId(questionSetId); } - - public List getAnnotationsByCohortSampleId(int cohortSampleId) { - return annotationRepository.findByCohortSampleId(cohortSampleId); - } - public List getAnnotationsByQuestionSetId(int questionSetId) { - return annotationRepository.findByQuestionSetId(questionSetId); - } } From d58f51cd8d5d650fa46c9d397ee96f5b7087297e Mon Sep 17 00:00:00 2001 From: Saul Crumpton Date: Sun, 22 Aug 2021 11:48:51 -0400 Subject: [PATCH 45/55] changing AnnotationRepository to use base findById instead of explicit query --- .../webapi/annotation/annotation/AnnotationRepository.java | 6 +----- .../webapi/annotation/annotation/AnnotationService.java | 4 ++-- 2 files changed, 3 insertions(+), 7 deletions(-) diff --git a/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationRepository.java b/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationRepository.java index a1048178cc..1e060dbeb8 100644 --- a/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationRepository.java +++ b/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationRepository.java @@ -13,9 +13,5 @@ public interface AnnotationRepository extends JpaRepository public List findByCohortSampleIdAndQuestionSetId(int cohortSampleId, int questionSetId); public List findByCohortSampleId(int cohortSampleId); public List findByQuestionSetId(int questionSetId); - - @Query("Select a FROM Annotation a WHERE a.id = ?1") - public Annotation findByAnnotationId(int annotation_id); -// @Query(value="SELECT * FROM ohdsi.annotation",nativeQuery = true) -// public List findAllAnnotations(); + public Annotation findById(int annotation_id); } diff --git a/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationService.java b/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationService.java index ba015bf0be..6325f65b2f 100644 --- a/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationService.java +++ b/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationService.java @@ -18,12 +18,12 @@ public List getAnnotations() { } public Annotation getAnnotationsByAnnotationId(int annotationId) { - Annotation result = annotationRepository.findByAnnotationId(annotationId); + Annotation result = annotationRepository.findById(annotationId); return result; } public Annotation getAnnotationsByAnnotationId(Annotation annotation) { - Annotation result = annotationRepository.findByAnnotationId(annotation.getId()); + Annotation result = annotationRepository.findById(annotation.getId()); return result; } From 9c558ecfa685c229ffe902ab0ce8207263c1b8eb Mon Sep 17 00:00:00 2001 From: Saul Crumpton Date: Sun, 22 Aug 2021 11:54:41 -0400 Subject: [PATCH 46/55] updated AnswerRepository to use default findById method instead of query --- .../org/ohdsi/webapi/annotation/answer/AnswerController.java | 2 -- .../org/ohdsi/webapi/annotation/answer/AnswerRepository.java | 5 +---- .../org/ohdsi/webapi/annotation/answer/AnswerService.java | 4 +--- 3 files changed, 2 insertions(+), 9 deletions(-) diff --git a/src/main/java/org/ohdsi/webapi/annotation/answer/AnswerController.java b/src/main/java/org/ohdsi/webapi/annotation/answer/AnswerController.java index f85f7b84fd..247b8a2d95 100644 --- a/src/main/java/org/ohdsi/webapi/annotation/answer/AnswerController.java +++ b/src/main/java/org/ohdsi/webapi/annotation/answer/AnswerController.java @@ -7,8 +7,6 @@ import javax.ws.rs.core.MediaType; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Component; -import org.ohdsi.webapi.annotation.answer.AnswerService; -import org.ohdsi.webapi.annotation.answer.Answer; @Path("annotation/") @Component diff --git a/src/main/java/org/ohdsi/webapi/annotation/answer/AnswerRepository.java b/src/main/java/org/ohdsi/webapi/annotation/answer/AnswerRepository.java index 691274c6f2..80945adc55 100644 --- a/src/main/java/org/ohdsi/webapi/annotation/answer/AnswerRepository.java +++ b/src/main/java/org/ohdsi/webapi/annotation/answer/AnswerRepository.java @@ -1,10 +1,7 @@ package org.ohdsi.webapi.annotation.answer; import org.springframework.data.jpa.repository.JpaRepository; -import org.ohdsi.webapi.annotation.answer.Answer; -import org.springframework.data.jpa.repository.Query; public interface AnswerRepository extends JpaRepository { - @Query("Select a FROM Answer a WHERE a.id = ?1") - public Answer findByAnswerId(int answerId); + public Answer findById(int answerId); } diff --git a/src/main/java/org/ohdsi/webapi/annotation/answer/AnswerService.java b/src/main/java/org/ohdsi/webapi/annotation/answer/AnswerService.java index cdd6483792..c241ead8d5 100644 --- a/src/main/java/org/ohdsi/webapi/annotation/answer/AnswerService.java +++ b/src/main/java/org/ohdsi/webapi/annotation/answer/AnswerService.java @@ -2,8 +2,6 @@ import org.springframework.stereotype.Service; import org.springframework.beans.factory.annotation.Autowired; -import org.ohdsi.webapi.annotation.answer.AnswerRepository; -import org.ohdsi.webapi.annotation.answer.Answer; @Service public class AnswerService { @@ -15,5 +13,5 @@ public void addAnswer(Answer answer) { answerRepository.save(answer); } - public Answer getAnswerById(int answerId){return answerRepository.findByAnswerId(answerId);} + public Answer getAnswerById(int answerId){return answerRepository.findById(answerId);} } From cecc37a1a75d891163b8f6023442f609ab09c104 Mon Sep 17 00:00:00 2001 From: Saul Crumpton Date: Sun, 22 Aug 2021 11:55:14 -0400 Subject: [PATCH 47/55] updated QuestionRepository to use default findById method instead of manual query --- .../ohdsi/webapi/annotation/question/QuestionController.java | 2 -- .../ohdsi/webapi/annotation/question/QuestionRepository.java | 3 +-- .../org/ohdsi/webapi/annotation/question/QuestionService.java | 2 +- 3 files changed, 2 insertions(+), 5 deletions(-) diff --git a/src/main/java/org/ohdsi/webapi/annotation/question/QuestionController.java b/src/main/java/org/ohdsi/webapi/annotation/question/QuestionController.java index d2a0fea45a..38a63d42c6 100644 --- a/src/main/java/org/ohdsi/webapi/annotation/question/QuestionController.java +++ b/src/main/java/org/ohdsi/webapi/annotation/question/QuestionController.java @@ -9,8 +9,6 @@ import javax.ws.rs.core.MediaType; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Component; -import org.ohdsi.webapi.annotation.question.QuestionService; -import org.ohdsi.webapi.annotation.question.Question; @Path("annotations/") @Component diff --git a/src/main/java/org/ohdsi/webapi/annotation/question/QuestionRepository.java b/src/main/java/org/ohdsi/webapi/annotation/question/QuestionRepository.java index 3b2e074fa1..ee455bf7a4 100644 --- a/src/main/java/org/ohdsi/webapi/annotation/question/QuestionRepository.java +++ b/src/main/java/org/ohdsi/webapi/annotation/question/QuestionRepository.java @@ -8,6 +8,5 @@ import java.util.List; public interface QuestionRepository extends JpaRepository { - @Query("Select a FROM Question a WHERE a.id = ?1") - public Question findByQuestionId(int questionId); + public Question findById(int questionId); } diff --git a/src/main/java/org/ohdsi/webapi/annotation/question/QuestionService.java b/src/main/java/org/ohdsi/webapi/annotation/question/QuestionService.java index 5251744ebb..b34c9c2ed4 100644 --- a/src/main/java/org/ohdsi/webapi/annotation/question/QuestionService.java +++ b/src/main/java/org/ohdsi/webapi/annotation/question/QuestionService.java @@ -21,7 +21,7 @@ public List getAllQuestions() { } public Question getQuestionByQuestionId(int questionId){ - return questionRepository.findByQuestionId(questionId); + return questionRepository.findById(questionId); } public void addQuestion(Question question) { From 26eff094d13c42012fc003e1d7da52d6c528ba5c Mon Sep 17 00:00:00 2001 From: Saul Crumpton Date: Sun, 22 Aug 2021 12:01:34 -0400 Subject: [PATCH 48/55] removing all chaff from Annotation Result package- unused fields etc --- .../webapi/annotation/result/Result.java | 51 ------------------- .../annotation/result/ResultController.java | 47 +---------------- .../webapi/annotation/result/ResultDto.java | 14 ----- .../annotation/result/ResultService.java | 7 +-- 4 files changed, 4 insertions(+), 115 deletions(-) diff --git a/src/main/java/org/ohdsi/webapi/annotation/result/Result.java b/src/main/java/org/ohdsi/webapi/annotation/result/Result.java index 4db11dcd71..ef0c757756 100644 --- a/src/main/java/org/ohdsi/webapi/annotation/result/Result.java +++ b/src/main/java/org/ohdsi/webapi/annotation/result/Result.java @@ -31,18 +31,6 @@ public class Result { @Column(name = "answer_id") private int answerId; -//need charity's help here! these can all be retrieved from the annotation_id -// @JsonIgnore -// @Column(name = "set_id") -// private Long setId; - -// @Column(name = "sample_name") -// private String sampleName; - -// @JsonIgnore -// @Column(name = "subject_id") -// private Long subjectId; - @Column(name = "value") private String value; @@ -79,20 +67,6 @@ public void setAnnotation(Annotation annotation) { this.annotation = annotation; } - /** - * @return the subjectId - */ -// public Long getSubjectId() { -// return subjectId; -// } - - /** - * @param subjectId the subjectId to set - */ -// public void setSubjectId(Long subjectId) { -// this.subjectId = subjectId; -// } - /** * @return the answerId */ @@ -107,20 +81,6 @@ public void setAnswerId(int answerId) { this.answerId = answerId; } - /** - * @return the setId - */ -// public Long getSetId() { -// return setId; -// } - - /** - * @param setId the setId to set - */ -// public void setSetId(Long setId) { -// this.setId = setId; -// } - /** * @return the questionId */ @@ -162,15 +122,4 @@ public String getValue() { public void setValue(String value) { this.value = value; } - /** - * @return the type - */ -// public String getSampleName() { -// return sampleName; -// } - - /** - * @param type the type to set - */ -// public void setSampleName(String name) {this.sampleName = name;} } diff --git a/src/main/java/org/ohdsi/webapi/annotation/result/ResultController.java b/src/main/java/org/ohdsi/webapi/annotation/result/ResultController.java index c954bc08cc..1307cbf855 100644 --- a/src/main/java/org/ohdsi/webapi/annotation/result/ResultController.java +++ b/src/main/java/org/ohdsi/webapi/annotation/result/ResultController.java @@ -3,55 +3,34 @@ import javax.ws.rs.*; import javax.ws.rs.core.MediaType; -import org.checkerframework.checker.units.qual.A; import org.ohdsi.webapi.annotation.annotation.Annotation; import org.ohdsi.webapi.annotation.annotation.AnnotationService; -import org.ohdsi.webapi.annotation.annotation.AnnotationSummary; import org.ohdsi.webapi.annotation.answer.Answer; import org.ohdsi.webapi.annotation.answer.AnswerService; import org.ohdsi.webapi.annotation.question.Question; import org.ohdsi.webapi.annotation.question.QuestionService; -import org.ohdsi.webapi.annotation.set.QuestionSet; -import org.ohdsi.webapi.annotation.set.QuestionSetService; import org.ohdsi.webapi.annotation.study.Study; import org.ohdsi.webapi.annotation.study.StudyService; -import org.ohdsi.webapi.cohortdefinition.CohortDefinition; -import org.ohdsi.webapi.cohortdefinition.CohortDefinitionRepository; -import org.ohdsi.webapi.cohortsample.dto.CohortSampleDTO; -import org.ohdsi.webapi.service.CohortSampleService; import org.ohdsi.webapi.source.Source; import org.ohdsi.webapi.source.SourceService; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Component; -import org.ohdsi.webapi.annotation.result.ResultService; -import org.springframework.web.bind.annotation.PathVariable; -import org.springframework.web.bind.annotation.RequestMapping; import java.util.*; -import java.util.stream.Collectors; @Path("/annotations/results") @Component public class ResultController { - @Autowired - private CohortSampleService cohortSampleService; - @Autowired private ResultService resultService; @Autowired private QuestionService questionService; - @Autowired - private QuestionSetService questionSetService; - @Autowired private AnnotationService annotationService; - @Autowired - private CohortDefinitionRepository cohortDefinitionRepository; - @Autowired private StudyService studyService; @@ -64,11 +43,8 @@ public class ResultController { @GET @Path("/{annotationID}") @Produces(MediaType.APPLICATION_JSON) - public List getResults(@PathParam("annotationID") String annotationID) { - int annotationIdInt=Integer.parseInt(annotationID); - ArrayList al = new ArrayList(); - Annotation ourAnno =annotationService.getAnnotationsByAnnotationId(annotationIdInt); - return resultService.getResultsByAnnotationID(annotationIdInt); + public List getResultsByAnnotationId(@PathParam("annotationID") int annotationID) { + return resultService.getResultsByAnnotationId(annotationID); } @GET @@ -88,9 +64,6 @@ public List getFullResults( @QueryParam("cohortSampleId") final int cohortSampleId, @QueryParam("studyId") final int studyId ) { -// May want to replicate this but with an additional parameter- -// this would be (quesetionSetID + CohortSampleId) or AnnotationStudyId (aka the same thing) - Study study = null; if(studyId!=0){ study=studyService.getStudyById(studyId); @@ -103,16 +76,8 @@ else if (questionSetId!=0 && cohortSampleId!=0){ } List resultlist=resultService.getResultsByStudy(study); List superList = new ArrayList(); -// Study finalStudy = study; Source source = sourceService.findBySourceId(study.getCohortSample().getSourceId()); -// List fastlist = resultlist.stream().map(r -> new SuperResultDto(r, finalStudy,source)).collect(Collectors.toList()); -// List fastlist = resultlist.stream().map(r -> { -// Question myQuestion = questionService.getQuestionByQuestionId(r.getQuestionId()); -// Annotation tempanno = annotationService.getAnnotationsByAnnotationId(r.getAnnotation()); -// return new SuperResultDto(r, finalStudy,source,myQuestion,tempanno); -// } ).collect(Collectors.toList()); for (Result result : resultlist){ -// things we currently query for; Annotation Cohort Sample, Cohort Definition, QuestionSets Question myQuestion = questionService.getQuestionByQuestionId(result.getQuestionId()); SuperResultDto tempdto = new SuperResultDto(result); Annotation tempanno = annotationService.getAnnotationsByAnnotationId(result.getAnnotation()); @@ -130,13 +95,5 @@ else if (questionSetId!=0 && cohortSampleId!=0){ superList.add(tempdto); } return superList; -// return fastlist; - } - - @Path("/{cohortDefinitionId}/{sourceKey}") - @POST - @Consumes(MediaType.APPLICATION_JSON) - public void createResult(){ - } } diff --git a/src/main/java/org/ohdsi/webapi/annotation/result/ResultDto.java b/src/main/java/org/ohdsi/webapi/annotation/result/ResultDto.java index f966e2314b..fcd1663e94 100644 --- a/src/main/java/org/ohdsi/webapi/annotation/result/ResultDto.java +++ b/src/main/java/org/ohdsi/webapi/annotation/result/ResultDto.java @@ -6,7 +6,6 @@ public class ResultDto { private int questionId; private String value; private String type; -// private String sampleName; //***** GETTERS/SETTERS ****** @@ -66,17 +65,4 @@ public void setType(String type) { this.type = type; } - /** - * @return the type - */ -// public String getSampleName() { -// return sampleName; -// } - - /** - * @param type the type to set - */ -// public void setSampleName(String name) { -// this.sampleName = name; -// } } diff --git a/src/main/java/org/ohdsi/webapi/annotation/result/ResultService.java b/src/main/java/org/ohdsi/webapi/annotation/result/ResultService.java index 661f32be7e..71835e152c 100644 --- a/src/main/java/org/ohdsi/webapi/annotation/result/ResultService.java +++ b/src/main/java/org/ohdsi/webapi/annotation/result/ResultService.java @@ -29,16 +29,13 @@ public class ResultService extends AbstractDaoService { @Autowired private CohortSampleRepository sampleRepository; - @Autowired - private ResultRepository resultRepository; - @Autowired private AnnotationService annotationService; @Autowired private StudyService studyService; - public List getResultsByAnnotationID(int AnnotationID){ + public List getResultsByAnnotationId(int AnnotationID){ Annotation ourAnno =annotationService.getAnnotationsByAnnotationId(AnnotationID); return getResultsByAnnotation(ourAnno); } @@ -159,7 +156,7 @@ public void insertResults(Annotation annotation, JSONArray results, Study study) Boolean hasCleared=false; for(int i=0; i < results.length(); i++){ JSONObject object = results.getJSONObject(i); - if(!hasCleared && !getResultsByAnnotationID(annotation.getId()).isEmpty()){ + if(!hasCleared && !getResultsByAnnotationId(annotation.getId()).isEmpty()){ // this entry already exists, need to update here instead of adding to the pile deleteResultsByAnnotationId(annotation); hasCleared=true; From 075af8943179de4d606d2765bbc24a75820c2282 Mon Sep 17 00:00:00 2001 From: Saul Crumpton Date: Sun, 22 Aug 2021 12:04:25 -0400 Subject: [PATCH 49/55] updated QuestionSet to use default findById, removed unused imports and fields --- .../java/org/ohdsi/webapi/annotation/set/QuestionSet.java | 1 - .../ohdsi/webapi/annotation/set/QuestionSetController.java | 3 --- .../ohdsi/webapi/annotation/set/QuestionSetRepository.java | 3 --- .../org/ohdsi/webapi/annotation/set/QuestionSetService.java | 4 +--- 4 files changed, 1 insertion(+), 10 deletions(-) diff --git a/src/main/java/org/ohdsi/webapi/annotation/set/QuestionSet.java b/src/main/java/org/ohdsi/webapi/annotation/set/QuestionSet.java index 88aaedb19e..d33d26b0bc 100644 --- a/src/main/java/org/ohdsi/webapi/annotation/set/QuestionSet.java +++ b/src/main/java/org/ohdsi/webapi/annotation/set/QuestionSet.java @@ -1,6 +1,5 @@ package org.ohdsi.webapi.annotation.set; -import java.util.HashSet; import java.util.LinkedHashSet; import java.util.Set; import javax.persistence.*; diff --git a/src/main/java/org/ohdsi/webapi/annotation/set/QuestionSetController.java b/src/main/java/org/ohdsi/webapi/annotation/set/QuestionSetController.java index d1d84e2e76..a4575f79c9 100644 --- a/src/main/java/org/ohdsi/webapi/annotation/set/QuestionSetController.java +++ b/src/main/java/org/ohdsi/webapi/annotation/set/QuestionSetController.java @@ -4,12 +4,9 @@ import javax.ws.rs.*; import javax.ws.rs.core.MediaType; -import org.ohdsi.webapi.annotation.annotation.Annotation; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.http.ResponseEntity; import org.springframework.stereotype.Component; -import org.ohdsi.webapi.annotation.set.QuestionSetService; -import org.ohdsi.webapi.annotation.set.QuestionSet; @Path("annotations/") @Component diff --git a/src/main/java/org/ohdsi/webapi/annotation/set/QuestionSetRepository.java b/src/main/java/org/ohdsi/webapi/annotation/set/QuestionSetRepository.java index c1909deb7f..db8d488345 100644 --- a/src/main/java/org/ohdsi/webapi/annotation/set/QuestionSetRepository.java +++ b/src/main/java/org/ohdsi/webapi/annotation/set/QuestionSetRepository.java @@ -14,9 +14,6 @@ public interface QuestionSetRepository extends JpaRepository findByCohortId(Integer cohortId); public QuestionSet findById(int id); - @Query("Select a FROM QuestionSet a WHERE a.id = ?1") - public QuestionSet findByQuestionSetId(int questionId); - @Query("Select distinct new org.ohdsi.webapi.annotation.set.QuestionSampleDto(q.id,c.id,q.name,c.name) FROM QuestionSet q INNER JOIN Annotation a ON a.questionSet.id = q.id INNER JOIN CohortSample c ON c.id = a.cohortSampleId WHERE q.cohortId = ?1") public List findSamplesAndSetsByCohortId(int cohortId); } diff --git a/src/main/java/org/ohdsi/webapi/annotation/set/QuestionSetService.java b/src/main/java/org/ohdsi/webapi/annotation/set/QuestionSetService.java index 6c81a1d16f..c471de54ac 100644 --- a/src/main/java/org/ohdsi/webapi/annotation/set/QuestionSetService.java +++ b/src/main/java/org/ohdsi/webapi/annotation/set/QuestionSetService.java @@ -5,8 +5,6 @@ import org.springframework.beans.factory.annotation.Autowired; import java.util.ArrayList; import java.util.List; -import org.ohdsi.webapi.annotation.set.QuestionSetRepository; -import org.ohdsi.webapi.annotation.set.QuestionSet; @Service public class QuestionSetService { @@ -36,7 +34,7 @@ public void addSet(QuestionSet set) { } public QuestionSet findQuestionSetByQuestionSetId(int questionSetId){ - return questionSetRepository.findByQuestionSetId(questionSetId); + return questionSetRepository.findById(questionSetId); } public List getSamplesAndSetsByCohortId(int cohortId) { From cdca276306939f335e3cf8bf29182e1fa9e59c92 Mon Sep 17 00:00:00 2001 From: Saul Crumpton Date: Sun, 22 Aug 2021 12:05:14 -0400 Subject: [PATCH 50/55] removing more unused imports from QuestionSet repository --- .../org/ohdsi/webapi/annotation/set/QuestionSetRepository.java | 3 --- 1 file changed, 3 deletions(-) diff --git a/src/main/java/org/ohdsi/webapi/annotation/set/QuestionSetRepository.java b/src/main/java/org/ohdsi/webapi/annotation/set/QuestionSetRepository.java index db8d488345..81c5b3bfd5 100644 --- a/src/main/java/org/ohdsi/webapi/annotation/set/QuestionSetRepository.java +++ b/src/main/java/org/ohdsi/webapi/annotation/set/QuestionSetRepository.java @@ -1,11 +1,8 @@ package org.ohdsi.webapi.annotation.set; -import org.ohdsi.webapi.annotation.question.Question; import org.springframework.data.jpa.repository.JpaRepository; - import java.util.List; import java.util.Set; -import org.ohdsi.webapi.annotation.set.QuestionSet; import org.springframework.data.jpa.repository.Query; From 530fa59804120632db7ef9258446466e33bed794 Mon Sep 17 00:00:00 2001 From: Saul Crumpton Date: Sun, 22 Aug 2021 12:49:12 -0400 Subject: [PATCH 51/55] using sequence for annotation_id instead of generated value --- .../webapi/annotation/annotation/Annotation.java | 13 ++++++++++++- .../annotation/annotation/AnnotationController.java | 2 +- .../org/ohdsi/webapi/cohortsample/CohortSample.java | 1 - .../V2.10.1.20210822101500__annotation.sql | 12 ++++++------ 4 files changed, 19 insertions(+), 9 deletions(-) diff --git a/src/main/java/org/ohdsi/webapi/annotation/annotation/Annotation.java b/src/main/java/org/ohdsi/webapi/annotation/annotation/Annotation.java index 2ede5b60fb..829b85090a 100644 --- a/src/main/java/org/ohdsi/webapi/annotation/annotation/Annotation.java +++ b/src/main/java/org/ohdsi/webapi/annotation/annotation/Annotation.java @@ -7,6 +7,9 @@ import javax.persistence.JoinColumn; import javax.persistence.Id; import javax.persistence.Table; + +import org.hibernate.annotations.GenericGenerator; +import org.hibernate.annotations.Parameter; import org.ohdsi.webapi.annotation.set.QuestionSet; @Entity(name = "Annotation") @@ -16,7 +19,15 @@ public class Annotation { @Id - @GeneratedValue + @GenericGenerator( + name="annotation_generator", + strategy = "org.hibernate.id.enhanced.SequenceStyleGenerator", + parameters = { + @Parameter(name="sequence_name",value="annotation_sequence"), + @Parameter(name="increment_size",value="1") + } + ) + @GeneratedValue(generator = "annotation_generator") @Column(name = "annotation_id") private int id; diff --git a/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationController.java b/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationController.java index e6e9f6a3df..3da8f31c5e 100644 --- a/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationController.java +++ b/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationController.java @@ -137,7 +137,7 @@ public void addAnnotation(@RequestBody String payload) { Study study = new Study(); int questionSetId = Integer.parseInt(jsonpayload.get("annotationSetId").toString()); QuestionSet questionSet = questionSetRepository.findById(questionSetId); - study.setQuestionSet(questionSetRepository.findByQuestionSetId(questionSetId)); + study.setQuestionSet(questionSetRepository.findById(questionSetId)); study.setCohortSample(cohortSample); CohortDefinition cohortDefinition= cohortDefinitionRepository.findOneWithDetail(cohortSample.getCohortDefinitionId()); study.setCohortDefinition(cohortDefinition); diff --git a/src/main/java/org/ohdsi/webapi/cohortsample/CohortSample.java b/src/main/java/org/ohdsi/webapi/cohortsample/CohortSample.java index b2b05b7640..a5a105603c 100644 --- a/src/main/java/org/ohdsi/webapi/cohortsample/CohortSample.java +++ b/src/main/java/org/ohdsi/webapi/cohortsample/CohortSample.java @@ -136,5 +136,4 @@ public String getAgeMode() { public void setAgeMode(String ageMode) { this.ageMode = ageMode; } - } diff --git a/src/main/resources/db/migration/postgresql/V2.10.1.20210822101500__annotation.sql b/src/main/resources/db/migration/postgresql/V2.10.1.20210822101500__annotation.sql index 102cbedb0c..e68f4f6b82 100644 --- a/src/main/resources/db/migration/postgresql/V2.10.1.20210822101500__annotation.sql +++ b/src/main/resources/db/migration/postgresql/V2.10.1.20210822101500__annotation.sql @@ -42,23 +42,23 @@ CREATE TABLE ${ohdsiSchema}.annotation_answer ( CREATE INDEX idx_annotation_answer_question ON ${ohdsiSchema}.annotation_question (question_id); +CREATE SEQUENCE ${ohdsiSchema}.annotation_sequence; CREATE TABLE ${ohdsiSchema}.annotation ( - annotation_id integer NOT NULL, + annotation_id integer NOT NULL DEFAULT NEXTVAL('annotation_sequence'), subject_id integer NOT NULL, cohort_sample_id integer NOT NULL, - set_id integer NOT NULL, + question_set_id integer NOT NULL, date_created TIMESTAMP WITH TIME ZONE NOT NULL DEFAULT (now()), - --user_id integer, CONSTRAINT annotation_pkey PRIMARY KEY (annotation_id), - CONSTRAINT annotation_set_fk FOREIGN KEY (set_id) + CONSTRAINT annotation_set_fk FOREIGN KEY (question_set_id) REFERENCES ${ohdsiSchema}.annotation_set(set_id), CONSTRAINT annotation_sample_fk FOREIGN KEY (cohort_sample_id) REFERENCES ${ohdsiSchema}.cohort_sample(id), - CONSTRAINT unq_subject_sample_set UNIQUE(subject_id, cohort_sample_id, set_id) + CONSTRAINT unq_subject_sample_set UNIQUE(subject_id, cohort_sample_id, question_set_id) ); CREATE INDEX idx_annotation_sample_subject ON ${ohdsiSchema}.annotation (cohort_sample_id,subject_id); -CREATE INDEX idx_annotation_set ON ${ohdsiSchema}.annotation (set_id); +CREATE INDEX idx_annotation_set ON ${ohdsiSchema}.annotation (question_set_id); CREATE TABLE ${ohdsiSchema}.annotation_study ( study_id integer NOT NULL, From 2643f9673c2db1ad39bb466f76b7ed2fa42fb3f7 Mon Sep 17 00:00:00 2001 From: Saul Crumpton Date: Sun, 22 Aug 2021 13:01:16 -0400 Subject: [PATCH 52/55] using generator for all IDs in Question, QuestionSet, Answer --- .../ohdsi/webapi/annotation/answer/Answer.java | 13 ++++++++++++- .../webapi/annotation/question/Question.java | 12 +++++++++++- .../ohdsi/webapi/annotation/set/QuestionSet.java | 11 ++++++++++- .../V2.10.1.20210822101500__annotation.sql | 16 ++++++++++++---- 4 files changed, 45 insertions(+), 7 deletions(-) diff --git a/src/main/java/org/ohdsi/webapi/annotation/answer/Answer.java b/src/main/java/org/ohdsi/webapi/annotation/answer/Answer.java index 3a6fc7add7..f25a86e0f5 100644 --- a/src/main/java/org/ohdsi/webapi/annotation/answer/Answer.java +++ b/src/main/java/org/ohdsi/webapi/annotation/answer/Answer.java @@ -8,6 +8,9 @@ import javax.persistence.FetchType; import javax.persistence.GeneratedValue; import javax.persistence.JoinColumn; + +import org.hibernate.annotations.GenericGenerator; +import org.hibernate.annotations.Parameter; import org.ohdsi.webapi.annotation.question.Question; import com.fasterxml.jackson.annotation.JsonIgnore; @@ -17,7 +20,15 @@ public class Answer { @Id - @GeneratedValue + @GenericGenerator( + name="answer_generator", + strategy = "org.hibernate.id.enhanced.SequenceStyleGenerator", + parameters = { + @Parameter(name="sequence_name",value="annotation_answer_sequence"), + @Parameter(name="increment_size",value="1") + } + ) + @GeneratedValue(generator = "answer_generator") @Column(name = "answer_id") private int id; diff --git a/src/main/java/org/ohdsi/webapi/annotation/question/Question.java b/src/main/java/org/ohdsi/webapi/annotation/question/Question.java index 3b4eca87f6..23ef7aa398 100644 --- a/src/main/java/org/ohdsi/webapi/annotation/question/Question.java +++ b/src/main/java/org/ohdsi/webapi/annotation/question/Question.java @@ -12,6 +12,8 @@ import javax.persistence.JoinColumn; import javax.persistence.Id; import javax.persistence.Table; + +import org.hibernate.annotations.GenericGenerator; import org.ohdsi.webapi.annotation.answer.Answer; import org.ohdsi.webapi.annotation.set.QuestionSet; import com.fasterxml.jackson.annotation.JsonIgnore; @@ -21,7 +23,15 @@ public class Question { @Id - @GeneratedValue + @GenericGenerator( + name="question_generator", + strategy = "org.hibernate.id.enhanced.SequenceStyleGenerator", + parameters = { + @org.hibernate.annotations.Parameter(name="sequence_name",value="annotation_question_sequence"), + @org.hibernate.annotations.Parameter(name="increment_size",value="1") + } + ) + @GeneratedValue(generator = "question_generator") @Column(name = "question_id") private int id; diff --git a/src/main/java/org/ohdsi/webapi/annotation/set/QuestionSet.java b/src/main/java/org/ohdsi/webapi/annotation/set/QuestionSet.java index d33d26b0bc..31aa44c0fe 100644 --- a/src/main/java/org/ohdsi/webapi/annotation/set/QuestionSet.java +++ b/src/main/java/org/ohdsi/webapi/annotation/set/QuestionSet.java @@ -4,6 +4,7 @@ import java.util.Set; import javax.persistence.*; +import org.hibernate.annotations.GenericGenerator; import org.ohdsi.webapi.annotation.question.Question; @Entity(name = "QuestionSet") @@ -11,7 +12,15 @@ public class QuestionSet { @Id - @GeneratedValue + @GenericGenerator( + name="set_generator", + strategy = "org.hibernate.id.enhanced.SequenceStyleGenerator", + parameters = { + @org.hibernate.annotations.Parameter(name="sequence_name",value="annotation_question_set_sequence"), + @org.hibernate.annotations.Parameter(name="increment_size",value="1") + } + ) + @GeneratedValue(generator = "set_generator") @Column(name = "set_id") private int id; diff --git a/src/main/resources/db/migration/postgresql/V2.10.1.20210822101500__annotation.sql b/src/main/resources/db/migration/postgresql/V2.10.1.20210822101500__annotation.sql index e68f4f6b82..ce75dfdf79 100644 --- a/src/main/resources/db/migration/postgresql/V2.10.1.20210822101500__annotation.sql +++ b/src/main/resources/db/migration/postgresql/V2.10.1.20210822101500__annotation.sql @@ -1,5 +1,7 @@ +CREATE SEQUENCE ${ohdsiSchema}.annotation_question_set_sequence; + CREATE TABLE ${ohdsiSchema}.annotation_set ( - set_id integer NOT NULL, + set_id integer NOT NULL DEFAULT NEXTVAL('annotation_question_set_sequence'), name VARCHAR(255) NOT NULL, cohort_definition_id integer NOT NULL, date_created TIMESTAMP WITH TIME ZONE NOT NULL DEFAULT (now()), @@ -11,8 +13,10 @@ CREATE TABLE ${ohdsiSchema}.annotation_set ( CREATE INDEX idx_cohort_annotation_set ON ${ohdsiSchema}.annotation_set (cohort_definition_id); +CREATE SEQUENCE ${ohdsiSchema}.annotation_question_sequence; + CREATE TABLE ${ohdsiSchema}.annotation_question ( - question_id integer NOT NULL, + question_id integer NOT NULL DEFAULT NEXTVAL('annotation_question_sequence'), set_id integer NOT NULL, question_name VARCHAR(255) NOT NULL, question_type VARCHAR(50) NOT NULL, @@ -28,9 +32,10 @@ CREATE TABLE ${ohdsiSchema}.annotation_question ( CREATE INDEX idx_annotation_set_question ON ${ohdsiSchema}.annotation_question (set_id); +CREATE SEQUENCE ${ohdsiSchema}.annotation_answer_sequence; CREATE TABLE ${ohdsiSchema}.annotation_answer ( - answer_id integer NOT NULL, + answer_id integer NOT NULL DEFAULT NEXTVAL('annotation_answer_sequence'), question_id integer NOT NULL, text character varying(250) NOT NULL, value character varying(250) NOT NULL, @@ -43,6 +48,7 @@ CREATE TABLE ${ohdsiSchema}.annotation_answer ( CREATE INDEX idx_annotation_answer_question ON ${ohdsiSchema}.annotation_question (question_id); CREATE SEQUENCE ${ohdsiSchema}.annotation_sequence; + CREATE TABLE ${ohdsiSchema}.annotation ( annotation_id integer NOT NULL DEFAULT NEXTVAL('annotation_sequence'), subject_id integer NOT NULL, @@ -60,8 +66,10 @@ CREATE TABLE ${ohdsiSchema}.annotation ( CREATE INDEX idx_annotation_sample_subject ON ${ohdsiSchema}.annotation (cohort_sample_id,subject_id); CREATE INDEX idx_annotation_set ON ${ohdsiSchema}.annotation (question_set_id); +CREATE SEQUENCE ${ohdsiSchema}.annotation_study_sequence; + CREATE TABLE ${ohdsiSchema}.annotation_study ( - study_id integer NOT NULL, + study_id integer NOT NULL DEFAULT NEXTVAL('annotation_study_sequence'), cohort_sample_id integer NOT NULL, question_set_id integer NOT NULL, cohort_definition_id integer NOT NULL, From 45057a4ab044e4b884d355fa5db44fe219c0eca5 Mon Sep 17 00:00:00 2001 From: Charity Hilton Date: Mon, 23 Aug 2021 16:50:39 -0400 Subject: [PATCH 53/55] rename annotation sequences --- ...> V2.10.1.20210823142322__annotations.sql} | 20 +++++++++---------- 1 file changed, 10 insertions(+), 10 deletions(-) rename src/main/resources/db/migration/postgresql/{V2.10.1.20210822101500__annotation.sql => V2.10.1.20210823142322__annotations.sql} (89%) diff --git a/src/main/resources/db/migration/postgresql/V2.10.1.20210822101500__annotation.sql b/src/main/resources/db/migration/postgresql/V2.10.1.20210823142322__annotations.sql similarity index 89% rename from src/main/resources/db/migration/postgresql/V2.10.1.20210822101500__annotation.sql rename to src/main/resources/db/migration/postgresql/V2.10.1.20210823142322__annotations.sql index ce75dfdf79..bbe7181e9e 100644 --- a/src/main/resources/db/migration/postgresql/V2.10.1.20210822101500__annotation.sql +++ b/src/main/resources/db/migration/postgresql/V2.10.1.20210823142322__annotations.sql @@ -1,7 +1,7 @@ -CREATE SEQUENCE ${ohdsiSchema}.annotation_question_set_sequence; +CREATE SEQUENCE ${ohdsiSchema}.annotation_set_seq; CREATE TABLE ${ohdsiSchema}.annotation_set ( - set_id integer NOT NULL DEFAULT NEXTVAL('annotation_question_set_sequence'), + set_id integer NOT NULL DEFAULT NEXTVAL('annotation_set_seq'), name VARCHAR(255) NOT NULL, cohort_definition_id integer NOT NULL, date_created TIMESTAMP WITH TIME ZONE NOT NULL DEFAULT (now()), @@ -13,10 +13,10 @@ CREATE TABLE ${ohdsiSchema}.annotation_set ( CREATE INDEX idx_cohort_annotation_set ON ${ohdsiSchema}.annotation_set (cohort_definition_id); -CREATE SEQUENCE ${ohdsiSchema}.annotation_question_sequence; +CREATE SEQUENCE ${ohdsiSchema}.annotation_question_seq; CREATE TABLE ${ohdsiSchema}.annotation_question ( - question_id integer NOT NULL DEFAULT NEXTVAL('annotation_question_sequence'), + question_id integer NOT NULL DEFAULT NEXTVAL('annotation_question_seq'), set_id integer NOT NULL, question_name VARCHAR(255) NOT NULL, question_type VARCHAR(50) NOT NULL, @@ -32,10 +32,10 @@ CREATE TABLE ${ohdsiSchema}.annotation_question ( CREATE INDEX idx_annotation_set_question ON ${ohdsiSchema}.annotation_question (set_id); -CREATE SEQUENCE ${ohdsiSchema}.annotation_answer_sequence; +CREATE SEQUENCE ${ohdsiSchema}.annotation_answer_seq; CREATE TABLE ${ohdsiSchema}.annotation_answer ( - answer_id integer NOT NULL DEFAULT NEXTVAL('annotation_answer_sequence'), + answer_id integer NOT NULL DEFAULT NEXTVAL('annotation_answer_seq'), question_id integer NOT NULL, text character varying(250) NOT NULL, value character varying(250) NOT NULL, @@ -47,10 +47,10 @@ CREATE TABLE ${ohdsiSchema}.annotation_answer ( CREATE INDEX idx_annotation_answer_question ON ${ohdsiSchema}.annotation_question (question_id); -CREATE SEQUENCE ${ohdsiSchema}.annotation_sequence; +CREATE SEQUENCE ${ohdsiSchema}.annotation_seq; CREATE TABLE ${ohdsiSchema}.annotation ( - annotation_id integer NOT NULL DEFAULT NEXTVAL('annotation_sequence'), + annotation_id integer NOT NULL DEFAULT NEXTVAL('annotation_seq'), subject_id integer NOT NULL, cohort_sample_id integer NOT NULL, question_set_id integer NOT NULL, @@ -66,10 +66,10 @@ CREATE TABLE ${ohdsiSchema}.annotation ( CREATE INDEX idx_annotation_sample_subject ON ${ohdsiSchema}.annotation (cohort_sample_id,subject_id); CREATE INDEX idx_annotation_set ON ${ohdsiSchema}.annotation (question_set_id); -CREATE SEQUENCE ${ohdsiSchema}.annotation_study_sequence; +CREATE SEQUENCE ${ohdsiSchema}.annotation_study_seq; CREATE TABLE ${ohdsiSchema}.annotation_study ( - study_id integer NOT NULL DEFAULT NEXTVAL('annotation_study_sequence'), + study_id integer NOT NULL DEFAULT NEXTVAL('annotation_study_seq'), cohort_sample_id integer NOT NULL, question_set_id integer NOT NULL, cohort_definition_id integer NOT NULL, From aa9f441c2ba3d7c2964eacb44cb4da54ef0a6917 Mon Sep 17 00:00:00 2001 From: Saul Crumpton Date: Mon, 23 Aug 2021 19:52:27 -0400 Subject: [PATCH 54/55] corrected sequence names for id generators of entities. Also removed id from results table as it isn't necessary --- .../annotation/annotation/Annotation.java | 2 +- .../webapi/annotation/answer/Answer.java | 2 +- .../webapi/annotation/question/Question.java | 2 +- .../webapi/annotation/result/Result.java | 41 ------------------- .../annotation/result/ResultRepository.java | 27 ------------ .../annotation/result/ResultService.java | 1 - .../webapi/annotation/set/QuestionSet.java | 2 +- .../ohdsi/webapi/annotation/study/Study.java | 11 ++++- .../ddl/results/annotation_result.sql | 1 - 9 files changed, 14 insertions(+), 75 deletions(-) delete mode 100644 src/main/java/org/ohdsi/webapi/annotation/result/ResultRepository.java diff --git a/src/main/java/org/ohdsi/webapi/annotation/annotation/Annotation.java b/src/main/java/org/ohdsi/webapi/annotation/annotation/Annotation.java index 829b85090a..9d6bcc8f7a 100644 --- a/src/main/java/org/ohdsi/webapi/annotation/annotation/Annotation.java +++ b/src/main/java/org/ohdsi/webapi/annotation/annotation/Annotation.java @@ -23,7 +23,7 @@ public class Annotation { name="annotation_generator", strategy = "org.hibernate.id.enhanced.SequenceStyleGenerator", parameters = { - @Parameter(name="sequence_name",value="annotation_sequence"), + @Parameter(name="sequence_name",value="annotation_seq"), @Parameter(name="increment_size",value="1") } ) diff --git a/src/main/java/org/ohdsi/webapi/annotation/answer/Answer.java b/src/main/java/org/ohdsi/webapi/annotation/answer/Answer.java index f25a86e0f5..a57243fb5c 100644 --- a/src/main/java/org/ohdsi/webapi/annotation/answer/Answer.java +++ b/src/main/java/org/ohdsi/webapi/annotation/answer/Answer.java @@ -24,7 +24,7 @@ public class Answer { name="answer_generator", strategy = "org.hibernate.id.enhanced.SequenceStyleGenerator", parameters = { - @Parameter(name="sequence_name",value="annotation_answer_sequence"), + @Parameter(name="sequence_name",value="annotation_answer_seq"), @Parameter(name="increment_size",value="1") } ) diff --git a/src/main/java/org/ohdsi/webapi/annotation/question/Question.java b/src/main/java/org/ohdsi/webapi/annotation/question/Question.java index 23ef7aa398..f632ed0c5e 100644 --- a/src/main/java/org/ohdsi/webapi/annotation/question/Question.java +++ b/src/main/java/org/ohdsi/webapi/annotation/question/Question.java @@ -27,7 +27,7 @@ public class Question { name="question_generator", strategy = "org.hibernate.id.enhanced.SequenceStyleGenerator", parameters = { - @org.hibernate.annotations.Parameter(name="sequence_name",value="annotation_question_sequence"), + @org.hibernate.annotations.Parameter(name="sequence_name",value="annotation_question_seq"), @org.hibernate.annotations.Parameter(name="increment_size",value="1") } ) diff --git a/src/main/java/org/ohdsi/webapi/annotation/result/Result.java b/src/main/java/org/ohdsi/webapi/annotation/result/Result.java index ef0c757756..04fb3801ed 100644 --- a/src/main/java/org/ohdsi/webapi/annotation/result/Result.java +++ b/src/main/java/org/ohdsi/webapi/annotation/result/Result.java @@ -1,58 +1,17 @@ package org.ohdsi.webapi.annotation.result; -import javax.persistence.Column; -import javax.persistence.Entity; -import javax.persistence.Id; -import javax.persistence.Table; -import javax.persistence.ManyToOne; -import javax.persistence.FetchType; -import javax.persistence.GeneratedValue; -import javax.persistence.JoinColumn; import org.ohdsi.webapi.annotation.annotation.Annotation; -import com.fasterxml.jackson.annotation.JsonIgnore; -@Entity(name = "Result") -@Table(name = "annotation_result") public class Result { - @Id - @GeneratedValue - @Column(name = "result_id") - private int id; - - @JsonIgnore - @ManyToOne(fetch = FetchType.LAZY) - @JoinColumn(name = "annotation_id") private Annotation annotation; - - @Column(name = "question_id") private int questionId; - - @Column(name = "answer_id") private int answerId; - - @Column(name = "value") private String value; - - @Column(name = "type") private String type; //***** GETTERS/SETTERS ****** - /** - * @return the id - */ - public int getId() { - return id; - } - - /** - * @param id the id to set - */ - public void setId(int id) { - this.id = id; - } - /** * @return the annotation */ diff --git a/src/main/java/org/ohdsi/webapi/annotation/result/ResultRepository.java b/src/main/java/org/ohdsi/webapi/annotation/result/ResultRepository.java deleted file mode 100644 index ec5e6e9520..0000000000 --- a/src/main/java/org/ohdsi/webapi/annotation/result/ResultRepository.java +++ /dev/null @@ -1,27 +0,0 @@ -package org.ohdsi.webapi.annotation.result; - -import org.ohdsi.webapi.annotation.annotation.Annotation; -import org.ohdsi.webapi.cohortsample.CohortSample; -import org.springframework.data.jpa.repository.JpaRepository; -import org.ohdsi.webapi.annotation.result.Result; - -import java.util.List; -import java.util.Set; - -import org.springframework.data.repository.query.Param; -import org.springframework.transaction.annotation.Transactional; -import org.springframework.data.jpa.repository.Query; - -@Transactional -public interface ResultRepository extends JpaRepository { -// public Set findBySampleNameAndSubjectId(String sampleName, Long subject_id); - - @Query("select s.value from Result s where s.annotation=?1 and s.questionId = ?2") - public Set getAnswers(Annotation annotation, int questionID); - - @Query("select r FROM Result r WHERE r.annotation.id = ?1") - List findByAnnotationId(int annotationId); - - @Query("select r FROM Result r WHERE r.questionId = ?1") - List findByQuestionId(int questionId); -} diff --git a/src/main/java/org/ohdsi/webapi/annotation/result/ResultService.java b/src/main/java/org/ohdsi/webapi/annotation/result/ResultService.java index 71835e152c..70bf6400c3 100644 --- a/src/main/java/org/ohdsi/webapi/annotation/result/ResultService.java +++ b/src/main/java/org/ohdsi/webapi/annotation/result/ResultService.java @@ -202,7 +202,6 @@ public Result mapRow(ResultSet rs, int rowNum) throws SQLException { return null; } result.setAnnotation(tempAnno); - result.setId(rs.getInt("result_id")); result.setQuestionId(rs.getInt("question_id")); result.setAnswerId(rs.getInt("answer_id")); result.setValue(rs.getString("value")); diff --git a/src/main/java/org/ohdsi/webapi/annotation/set/QuestionSet.java b/src/main/java/org/ohdsi/webapi/annotation/set/QuestionSet.java index 31aa44c0fe..ea3189364e 100644 --- a/src/main/java/org/ohdsi/webapi/annotation/set/QuestionSet.java +++ b/src/main/java/org/ohdsi/webapi/annotation/set/QuestionSet.java @@ -16,7 +16,7 @@ public class QuestionSet { name="set_generator", strategy = "org.hibernate.id.enhanced.SequenceStyleGenerator", parameters = { - @org.hibernate.annotations.Parameter(name="sequence_name",value="annotation_question_set_sequence"), + @org.hibernate.annotations.Parameter(name="sequence_name",value="annotation_set_seq"), @org.hibernate.annotations.Parameter(name="increment_size",value="1") } ) diff --git a/src/main/java/org/ohdsi/webapi/annotation/study/Study.java b/src/main/java/org/ohdsi/webapi/annotation/study/Study.java index afbcc1d3ab..99fde1211d 100644 --- a/src/main/java/org/ohdsi/webapi/annotation/study/Study.java +++ b/src/main/java/org/ohdsi/webapi/annotation/study/Study.java @@ -1,5 +1,6 @@ package org.ohdsi.webapi.annotation.study; +import org.hibernate.annotations.GenericGenerator; import org.ohdsi.webapi.annotation.set.QuestionSet; import org.ohdsi.webapi.cohortdefinition.CohortDefinition; import org.ohdsi.webapi.cohortsample.CohortSample; @@ -11,7 +12,15 @@ @Table(name = "annotation_study") public class Study { @Id - @GeneratedValue + @GenericGenerator( + name="annotation_study_generator", + strategy = "org.hibernate.id.enhanced.SequenceStyleGenerator", + parameters = { + @org.hibernate.annotations.Parameter(name="sequence_name",value="annotation_study_seq"), + @org.hibernate.annotations.Parameter(name="increment_size",value="1") + } + ) + @GeneratedValue(generator = "annotation_study_generator") @Column(name = "study_id") private int id; diff --git a/src/main/resources/ddl/results/annotation_result.sql b/src/main/resources/ddl/results/annotation_result.sql index 84949b5a11..c11222075d 100644 --- a/src/main/resources/ddl/results/annotation_result.sql +++ b/src/main/resources/ddl/results/annotation_result.sql @@ -1,6 +1,5 @@ IF OBJECT_ID('@results_schema.annotation_result', 'U') IS NULL CREATE TABLE @results_schema.annotation_result( - result_id integer NOT NULL AUTO_INCREMENT, annotation_id integer NOT NULL, question_id integer NOT NULL, answer_id bigint NOT NULL, From 8814282d549548014fb57125d2a3885a52c145de Mon Sep 17 00:00:00 2001 From: Chris Knoll Date: Wed, 10 Nov 2021 13:31:32 -0500 Subject: [PATCH 55/55] Added security migration scripts. Renamed end point from 'annotations' to 'annotation' --- .../annotation/AnnotationController.java | 2 +- .../navigation/NavigationController.java | 2 +- .../question/QuestionController.java | 2 +- .../annotation/set/QuestionSetController.java | 2 +- ...1.20211108000000__annotations_security.sql | 41 +++++++++++++++++++ 5 files changed, 45 insertions(+), 4 deletions(-) create mode 100644 src/main/resources/db/migration/postgresql/V2.10.1.20211108000000__annotations_security.sql diff --git a/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationController.java b/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationController.java index 3da8f31c5e..b73601f34b 100644 --- a/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationController.java +++ b/src/main/java/org/ohdsi/webapi/annotation/annotation/AnnotationController.java @@ -30,7 +30,7 @@ import org.springframework.web.bind.annotation.RequestBody; -@Path("annotations") +@Path("annotation") @Component public class AnnotationController { diff --git a/src/main/java/org/ohdsi/webapi/annotation/navigation/NavigationController.java b/src/main/java/org/ohdsi/webapi/annotation/navigation/NavigationController.java index 0244445b70..9b6861da43 100644 --- a/src/main/java/org/ohdsi/webapi/annotation/navigation/NavigationController.java +++ b/src/main/java/org/ohdsi/webapi/annotation/navigation/NavigationController.java @@ -17,7 +17,7 @@ import org.ohdsi.webapi.annotation.annotation.AnnotationService; import com.fasterxml.jackson.databind.ObjectMapper; -@Path("annotations/") +@Path("annotation/") @Component public class NavigationController extends AbstractDaoService { diff --git a/src/main/java/org/ohdsi/webapi/annotation/question/QuestionController.java b/src/main/java/org/ohdsi/webapi/annotation/question/QuestionController.java index 38a63d42c6..4e2c196900 100644 --- a/src/main/java/org/ohdsi/webapi/annotation/question/QuestionController.java +++ b/src/main/java/org/ohdsi/webapi/annotation/question/QuestionController.java @@ -10,7 +10,7 @@ import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Component; -@Path("annotations/") +@Path("annotation/") @Component public class QuestionController { diff --git a/src/main/java/org/ohdsi/webapi/annotation/set/QuestionSetController.java b/src/main/java/org/ohdsi/webapi/annotation/set/QuestionSetController.java index a4575f79c9..2dd7cda734 100644 --- a/src/main/java/org/ohdsi/webapi/annotation/set/QuestionSetController.java +++ b/src/main/java/org/ohdsi/webapi/annotation/set/QuestionSetController.java @@ -8,7 +8,7 @@ import org.springframework.http.ResponseEntity; import org.springframework.stereotype.Component; -@Path("annotations/") +@Path("annotation/") @Component public class QuestionSetController { diff --git a/src/main/resources/db/migration/postgresql/V2.10.1.20211108000000__annotations_security.sql b/src/main/resources/db/migration/postgresql/V2.10.1.20211108000000__annotations_security.sql new file mode 100644 index 0000000000..a8bb2e4ce2 --- /dev/null +++ b/src/main/resources/db/migration/postgresql/V2.10.1.20211108000000__annotations_security.sql @@ -0,0 +1,41 @@ +INSERT INTO ${ohdsiSchema}.sec_permission(id, value, description) +VALUES (NEXTVAL('${ohdsiSchema}.sec_permission_id_seq'), 'annotation:get', 'Gets annotation summary'), + (NEXTVAL('${ohdsiSchema}.sec_permission_id_seq'), 'annotation:*:get', 'Get annotation result by ID.'), + (NEXTVAL('${ohdsiSchema}.sec_permission_id_seq'), 'annotation:fullquestion:get', 'Get annotation result by ID.'), + (NEXTVAL('${ohdsiSchema}.sec_permission_id_seq'), 'annotation:post', 'Adds an annotation result.'), + (NEXTVAL('${ohdsiSchema}.sec_permission_id_seq'), 'annotation:sample:post', 'Adds an annotation to sample.'), + (NEXTVAL('${ohdsiSchema}.sec_permission_id_seq'), 'annotation:answers:post', 'Adds an annotation to sample.'), + (NEXTVAL('${ohdsiSchema}.sec_permission_id_seq'), 'annotation:navigation:get', 'Gets annotation navigation.'), + (NEXTVAL('${ohdsiSchema}.sec_permission_id_seq'), 'annotation:questions:get', 'Gets annotation questions.'), + (NEXTVAL('${ohdsiSchema}.sec_permission_id_seq'), 'annotation:questions:post', 'Adds question to annotation.'), + (NEXTVAL('${ohdsiSchema}.sec_permission_id_seq'), 'annotation:results:get', 'Gets annotation results.'), + (NEXTVAL('${ohdsiSchema}.sec_permission_id_seq'), 'annotation:results:*:get', 'Gets annotation results by ID.'), + (NEXTVAL('${ohdsiSchema}.sec_permission_id_seq'), 'annotation:results:completeResults:get', 'Gets complete annotation results.'), + (NEXTVAL('${ohdsiSchema}.sec_permission_id_seq'), 'annotation:sets:get', 'Gets annotation sets.'), + (NEXTVAL('${ohdsiSchema}.sec_permission_id_seq'), 'annotation:sets:post', 'Create annotation sets.'), + (NEXTVAL('${ohdsiSchema}.sec_permission_id_seq'), 'annotation:getsets:get', 'Gets annotation sets as getsets.'), + (NEXTVAL('${ohdsiSchema}.sec_permission_id_seq'), 'annotation:deleteset:*:get', 'Deletes an annotation set.') +; + +INSERT INTO ${ohdsiSchema}.sec_role_permission(role_id, permission_id) +SELECT sr.id, sp.id +FROM ${ohdsiSchema}.sec_permission SP, + ${ohdsiSchema}.sec_role sr +WHERE sp.value IN ( + 'annotation:get', + 'annotation:*:get', + 'annotation:fullquestion:get', + 'annotation:post', + 'annotation:sample:post', + 'annotation:answers:post', + 'annotation:navigation:get', + 'annotation:questions:get', + 'annotation:questions:post', + 'annotation:results:get', + 'annotation:results:*:get', + 'annotation:sets:get', + 'annotation:sets:post', + 'annotation:getsets:get', + 'annotation:deleteset:*:get') + AND sr.name IN ('Atlas users'); + \ No newline at end of file