#5817

Committed 02 May 2025 01:06PM UTC coverage: 78.733% (-1.3%) from 80.036%

Build # #5817

Build Type

push

Committed by

Commit Message

DT-1595 Remove unused endpoints (#2507)

Run Details

2 of 2 new or added lines in 1 file covered. (100.0%)

159 existing lines in 7 files now uncovered.

10029 of 12738 relevant lines covered (78.73%)

0.79 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0

/src/main/java/org/broadinstitute/consent/http/models/DacDecisionMetrics.java

package org.broadinstitute.consent.http.models;

import java.util.List;
import java.util.Objects;
import java.util.stream.Collectors;
import org.broadinstitute.consent.http.models.dto.DatasetDTO;

/**
 * Generate a row of dac decision data.
 */
public class DacDecisionMetrics implements DecisionMetrics {

  private Dac dac;
  private List<DatasetDTO> datasets;
  private List<DarDecisionMetrics> metrics;
  private Integer chairCount;
  private Integer memberCount;
  private Integer datasetCount;
  private Integer darsReceived;
  private Integer percentDARsReviewed;
  private Integer averageCountUniqueUser;
  private Double averageTurnaroundTimeMillis;
  private Integer averageTurnaroundTime;
  private Integer percentRevealAlgorithm;
  private Integer percentAgreementAlgorithm;
  private Integer percentSRPAccurate;

  private static final String JOINER = "\t";
  public static final String headerRow = String.join(
      JOINER,
      "DAC ID",
      "DAC UID",
      "# of DAC Members",
      "# of DAC Chairs",
      "# of Datasets",
      "# of DARs Received",
      "% of DARs Reviewed",
      "Average # Users on Approved DAR",
      "Average DAR Turnaround Time",
      "% Reveal DUOS Algorithm",
      "% Agreement with DUOS Algorithm",
      "% Structured Research Purpose Accurate",
      "\n");

  public String toString(String joiner) {
    String name = this.getDac().getName();
    return String.join(
        joiner,
        getValue(name),
        getValue(getDacUID(name)),
        getValue(getMemberCount()),
        getValue(getChairCount()),
        getValue(getDatasetCount()),
        getValue(getDarsReceived()),
        getValue(getPercentDARsReviewed()),
        getValue(getAverageCountUniqueUser().toString()),
        getValue(getAverageTurnaroundTime()),
        getValue(getPercentRevealAlgorithm()),
        getValue(getPercentAgreementAlgorithm()),
        getValue(getPercentSRPAccurate()),
        "\n");
  }

  public DacDecisionMetrics(Dac dac, List<DatasetDTO> datasets, List<DarDecisionMetrics> metrics) {
    this.setDac(dac);
    this.setDatasets(datasets);
    this.setMetrics(metrics);
    this.setChairCount(dac);
    this.setMemberCount(dac);
    this.setDatasetCount(datasets);
    this.setDarsReceived(metrics.size());

    List<DarDecisionMetrics> completedDarMetrics =
        metrics.stream()
            .filter(m -> Objects.nonNull(m.getDacDecision()))
            .collect(Collectors.toList());

    if (!metrics.isEmpty()) {
      int percentReviewed = createPercentage(completedDarMetrics.size(), metrics.size());
      this.setPercentDARsReviewed(percentReviewed);
    }

    List<DarDecisionMetrics> approvedDarMetrics =
        completedDarMetrics.stream()
            .filter(m -> (m.getDacDecision()).equalsIgnoreCase("Yes"))
            .collect(Collectors.toList());

    this.setAverageCountUniqueUser(approvedDarMetrics);

    completedDarMetrics.stream()
        .filter(m -> Objects.nonNull(m.getTurnaroundTimeMillis()))
        .mapToLong(DarDecisionMetrics::getTurnaroundTimeMillis)
        .average()
        .ifPresent(this::setAverageTurnaroundTimeMillis);

    this.setAverageTurnaroundTime();
    this.setPercentAgreementAlgorithm(completedDarMetrics);
    this.setPercentSRPAccurate(completedDarMetrics);
    this.setPercentRevealAlgorithm(null); //not implemented yet, will be empty column
  }

  public Integer createPercentage(int num, int denom) {
    return (int) (((double) num / (double) denom) * 100);

  }

  public Dac getDac() {
    return dac;
  }

  private void setDac(Dac dac) {
    this.dac = dac;
  }

  public List<DatasetDTO> getDatasets() {
    return datasets;
  }

  private void setDatasets(List<DatasetDTO> datasets) {
    this.datasets = datasets;
  }

  public List<DarDecisionMetrics> getMetrics() {
    return metrics;
  }

  private void setMetrics(List<DarDecisionMetrics> metrics) {
    this.metrics = metrics;
  }

  public Integer getChairCount() {
    return chairCount;
  }

  private void setChairCount(Dac dac) {
    if (Objects.nonNull(dac.getChairpersons()) && !dac.getChairpersons().isEmpty()) {
      this.chairCount = dac.getChairpersons().size();
    }
  }

  public Integer getMemberCount() {
    return memberCount;
  }

  private void setMemberCount(Dac dac) {
    if (Objects.nonNull(dac.getMembers()) && !dac.getMembers().isEmpty()) {
      this.memberCount = dac.getMembers().size();
    }
  }

  public Integer getDatasetCount() {
    return datasetCount;
  }

  private void setDatasetCount(List<DatasetDTO> datasets) {
    if (Objects.nonNull(datasets) && !datasets.isEmpty()) {
      this.datasetCount = datasets.size();
    }
  }

  private void setAverageCountUniqueUser(List<DarDecisionMetrics> metrics) {
    this.averageCountUniqueUser = (int) metrics.stream()
        .map(DarDecisionMetrics::getCountUniqueUsers)
        .mapToInt(Integer::intValue)
        .average()
        .orElse(0);
  }

  public Integer getAverageCountUniqueUser() {
    return averageCountUniqueUser;
  }

  public Integer getDarsReceived() {
    return darsReceived;
  }

  private void setDarsReceived(Integer darsReceived) {
    this.darsReceived = darsReceived;
  }

  public Integer getPercentDARsReviewed() {
    return percentDARsReviewed;
  }

  private void setPercentDARsReviewed(Integer percentDARsReviewed) {
    this.percentDARsReviewed = percentDARsReviewed;
  }

  public Double getAverageTurnaroundTimeMillis() {
    return averageTurnaroundTimeMillis;
  }

  private void setAverageTurnaroundTimeMillis(Double averageTurnaroundTimeMillis) {
    this.averageTurnaroundTimeMillis = averageTurnaroundTimeMillis;
  }

  public Integer getAverageTurnaroundTime() {
    return averageTurnaroundTime;
  }

  private void setAverageTurnaroundTime() {
    if (Objects.nonNull(this.getAverageTurnaroundTimeMillis())) {
      this.averageTurnaroundTime = this.convertMillisToDays(
          this.averageTurnaroundTimeMillis.longValue());
    }
  }

  public Integer getPercentRevealAlgorithm() {
    return percentRevealAlgorithm;
  }

  private void setPercentRevealAlgorithm(Integer percentRevealAlgorithm) {
    this.percentRevealAlgorithm = percentRevealAlgorithm;
  }

  public Integer getPercentAgreementAlgorithm() {
    return percentAgreementAlgorithm;
  }

  private void setPercentAgreementAlgorithm(List<DarDecisionMetrics> completedDarMetrics) {
    if (!completedDarMetrics.isEmpty()) {
      List<DarDecisionMetrics> agreementMetricsDenominator =
          completedDarMetrics.stream()
              .filter(m -> Objects.nonNull(m.getAlgorithmDecision()))
              .collect(Collectors.toList());

      List<DarDecisionMetrics> agreementMetricsNumerator =
          agreementMetricsDenominator.stream()
              .filter(m -> m.getAlgorithmDecision().equalsIgnoreCase(m.getDacDecision()))
              .collect(Collectors.toList());

      int percentAgreement = createPercentage(agreementMetricsNumerator.size(),
          agreementMetricsDenominator.size());
      this.percentAgreementAlgorithm = percentAgreement;
    }
  }

  public Integer getPercentSRPAccurate() {
    return percentSRPAccurate;
  }

  private void setPercentSRPAccurate(List<DarDecisionMetrics> completedDarMetrics) {
    List<DarDecisionMetrics> srpMetricsDenominator =
        completedDarMetrics.stream()
            .filter(m -> Objects.nonNull(m.getSrpDecision()))
            .collect(Collectors.toList());

    List<DarDecisionMetrics> srpMetricsNumerator =
        srpMetricsDenominator.stream()
            .filter(m -> m.getSrpDecision().equalsIgnoreCase("yes"))
            .collect(Collectors.toList());
    int percentSrp = createPercentage(srpMetricsNumerator.size(), srpMetricsDenominator.size());
    this.percentSRPAccurate = percentSrp;
  }

  private String getValue(String str) {
    return Objects.nonNull(str) ? str : "";
  }

  private String getValue(Integer i) {
    return Objects.nonNull(i) ? i.toString() : "";
  }
}

1	package org.broadinstitute.consent.http.models;
2
3	import java.util.List;
4	import java.util.Objects;
5	import java.util.stream.Collectors;
6	import org.broadinstitute.consent.http.models.dto.DatasetDTO;
7
8	/**
9	* Generate a row of dac decision data.
10	*/
11	public class DacDecisionMetrics implements DecisionMetrics {
12
13	private Dac dac;
14	private List<DatasetDTO> datasets;
15	private List<DarDecisionMetrics> metrics;
16	private Integer chairCount;
17	private Integer memberCount;
18	private Integer datasetCount;
19	private Integer darsReceived;
20	private Integer percentDARsReviewed;
21	private Integer averageCountUniqueUser;
22	private Double averageTurnaroundTimeMillis;
23	private Integer averageTurnaroundTime;
24	private Integer percentRevealAlgorithm;
25	private Integer percentAgreementAlgorithm;
26	private Integer percentSRPAccurate;
27
28	private static final String JOINER = "\t";
UNCOV 29	public static final String headerRow = String.join(	×
30	JOINER,
31	"DAC ID",
32	"DAC UID",
33	"# of DAC Members",
34	"# of DAC Chairs",
35	"# of Datasets",
36	"# of DARs Received",
37	"% of DARs Reviewed",
38	"Average # Users on Approved DAR",
39	"Average DAR Turnaround Time",
40	"% Reveal DUOS Algorithm",
41	"% Agreement with DUOS Algorithm",
42	"% Structured Research Purpose Accurate",
43	"\n");
44
45	public String toString(String joiner) {
46	String name = this.getDac().getName();	×
47	return String.join(	×
48	joiner,
49	getValue(name),	×
50	getValue(getDacUID(name)),	×
51	getValue(getMemberCount()),	×
52	getValue(getChairCount()),	×
53	getValue(getDatasetCount()),	×
54	getValue(getDarsReceived()),	×
55	getValue(getPercentDARsReviewed()),	×
56	getValue(getAverageCountUniqueUser().toString()),	×
57	getValue(getAverageTurnaroundTime()),	×
58	getValue(getPercentRevealAlgorithm()),	×
59	getValue(getPercentAgreementAlgorithm()),	×
60	getValue(getPercentSRPAccurate()),	×
61	"\n");
62	}
63
UNCOV 64	public DacDecisionMetrics(Dac dac, List<DatasetDTO> datasets, List<DarDecisionMetrics> metrics) {	×
UNCOV 65	this.setDac(dac);	×
UNCOV 66	this.setDatasets(datasets);	×
UNCOV 67	this.setMetrics(metrics);	×
UNCOV 68	this.setChairCount(dac);	×
UNCOV 69	this.setMemberCount(dac);	×
UNCOV 70	this.setDatasetCount(datasets);	×
UNCOV 71	this.setDarsReceived(metrics.size());	×
72
UNCOV 73	List<DarDecisionMetrics> completedDarMetrics =	×
UNCOV 74	metrics.stream()	×
UNCOV 75	.filter(m -> Objects.nonNull(m.getDacDecision()))	×
UNCOV 76	.collect(Collectors.toList());	×
77
UNCOV 78	if (!metrics.isEmpty()) {	×
79	int percentReviewed = createPercentage(completedDarMetrics.size(), metrics.size());	×
80	this.setPercentDARsReviewed(percentReviewed);	×
81	}
82
UNCOV 83	List<DarDecisionMetrics> approvedDarMetrics =	×
UNCOV 84	completedDarMetrics.stream()	×
UNCOV 85	.filter(m -> (m.getDacDecision()).equalsIgnoreCase("Yes"))	×
UNCOV 86	.collect(Collectors.toList());	×
87
UNCOV 88	this.setAverageCountUniqueUser(approvedDarMetrics);	×
89
UNCOV 90	completedDarMetrics.stream()	×
UNCOV 91	.filter(m -> Objects.nonNull(m.getTurnaroundTimeMillis()))	×
UNCOV 92	.mapToLong(DarDecisionMetrics::getTurnaroundTimeMillis)	×
UNCOV 93	.average()	×
UNCOV 94	.ifPresent(this::setAverageTurnaroundTimeMillis);	×
95
UNCOV 96	this.setAverageTurnaroundTime();	×
UNCOV 97	this.setPercentAgreementAlgorithm(completedDarMetrics);	×
UNCOV 98	this.setPercentSRPAccurate(completedDarMetrics);	×
UNCOV 99	this.setPercentRevealAlgorithm(null); //not implemented yet, will be empty column	×
UNCOV 100	}	×
101
102	public Integer createPercentage(int num, int denom) {
UNCOV 103	return (int) (((double) num / (double) denom) * 100);	×
104
105	}
106
107	public Dac getDac() {
108	return dac;	×
109	}
110
111	private void setDac(Dac dac) {
UNCOV 112	this.dac = dac;	×
UNCOV 113	}	×
114
115	public List<DatasetDTO> getDatasets() {
116	return datasets;	×
117	}
118
119	private void setDatasets(List<DatasetDTO> datasets) {
UNCOV 120	this.datasets = datasets;	×
UNCOV 121	}	×
122
123	public List<DarDecisionMetrics> getMetrics() {
124	return metrics;	×
125	}
126
127	private void setMetrics(List<DarDecisionMetrics> metrics) {
UNCOV 128	this.metrics = metrics;	×
UNCOV 129	}	×
130
131	public Integer getChairCount() {
132	return chairCount;	×
133	}
134
135	private void setChairCount(Dac dac) {
UNCOV 136	if (Objects.nonNull(dac.getChairpersons()) && !dac.getChairpersons().isEmpty()) {	×
UNCOV 137	this.chairCount = dac.getChairpersons().size();	×
138	}
UNCOV 139	}	×
140
141	public Integer getMemberCount() {
142	return memberCount;	×
143	}
144
145	private void setMemberCount(Dac dac) {
UNCOV 146	if (Objects.nonNull(dac.getMembers()) && !dac.getMembers().isEmpty()) {	×
UNCOV 147	this.memberCount = dac.getMembers().size();	×
148	}
UNCOV 149	}	×
150
151	public Integer getDatasetCount() {
152	return datasetCount;	×
153	}
154
155	private void setDatasetCount(List<DatasetDTO> datasets) {
UNCOV 156	if (Objects.nonNull(datasets) && !datasets.isEmpty()) {	×
UNCOV 157	this.datasetCount = datasets.size();	×
158	}
UNCOV 159	}	×
160
161	private void setAverageCountUniqueUser(List<DarDecisionMetrics> metrics) {
UNCOV 162	this.averageCountUniqueUser = (int) metrics.stream()	×
UNCOV 163	.map(DarDecisionMetrics::getCountUniqueUsers)	×
UNCOV 164	.mapToInt(Integer::intValue)	×
UNCOV 165	.average()	×
UNCOV 166	.orElse(0);	×
UNCOV 167	}	×
168
169	public Integer getAverageCountUniqueUser() {
170	return averageCountUniqueUser;	×
171	}
172
173	public Integer getDarsReceived() {
174	return darsReceived;	×
175	}
176
177	private void setDarsReceived(Integer darsReceived) {
UNCOV 178	this.darsReceived = darsReceived;	×
UNCOV 179	}	×
180
181	public Integer getPercentDARsReviewed() {
182	return percentDARsReviewed;	×
183	}
184
185	private void setPercentDARsReviewed(Integer percentDARsReviewed) {
186	this.percentDARsReviewed = percentDARsReviewed;	×
187	}	×
188
189	public Double getAverageTurnaroundTimeMillis() {
UNCOV 190	return averageTurnaroundTimeMillis;	×
191	}
192
193	private void setAverageTurnaroundTimeMillis(Double averageTurnaroundTimeMillis) {
194	this.averageTurnaroundTimeMillis = averageTurnaroundTimeMillis;	×
195	}	×
196
197	public Integer getAverageTurnaroundTime() {
198	return averageTurnaroundTime;	×
199	}
200
201	private void setAverageTurnaroundTime() {
UNCOV 202	if (Objects.nonNull(this.getAverageTurnaroundTimeMillis())) {	×
203	this.averageTurnaroundTime = this.convertMillisToDays(	×
204	this.averageTurnaroundTimeMillis.longValue());	×
205	}
UNCOV 206	}	×
207
208	public Integer getPercentRevealAlgorithm() {
209	return percentRevealAlgorithm;	×
210	}
211
212	private void setPercentRevealAlgorithm(Integer percentRevealAlgorithm) {
UNCOV 213	this.percentRevealAlgorithm = percentRevealAlgorithm;	×
UNCOV 214	}	×
215
216	public Integer getPercentAgreementAlgorithm() {
217	return percentAgreementAlgorithm;	×
218	}
219
220	private void setPercentAgreementAlgorithm(List<DarDecisionMetrics> completedDarMetrics) {
UNCOV 221	if (!completedDarMetrics.isEmpty()) {	×
222	List<DarDecisionMetrics> agreementMetricsDenominator =	×
223	completedDarMetrics.stream()	×
224	.filter(m -> Objects.nonNull(m.getAlgorithmDecision()))	×
225	.collect(Collectors.toList());	×
226
227	List<DarDecisionMetrics> agreementMetricsNumerator =	×
228	agreementMetricsDenominator.stream()	×
229	.filter(m -> m.getAlgorithmDecision().equalsIgnoreCase(m.getDacDecision()))	×
230	.collect(Collectors.toList());	×
231
232	int percentAgreement = createPercentage(agreementMetricsNumerator.size(),	×
233	agreementMetricsDenominator.size());	×
234	this.percentAgreementAlgorithm = percentAgreement;	×
235	}
UNCOV 236	}	×
237
238	public Integer getPercentSRPAccurate() {
239	return percentSRPAccurate;	×
240	}
241
242	private void setPercentSRPAccurate(List<DarDecisionMetrics> completedDarMetrics) {
UNCOV 243	List<DarDecisionMetrics> srpMetricsDenominator =	×
UNCOV 244	completedDarMetrics.stream()	×
UNCOV 245	.filter(m -> Objects.nonNull(m.getSrpDecision()))	×
UNCOV 246	.collect(Collectors.toList());	×
247
UNCOV 248	List<DarDecisionMetrics> srpMetricsNumerator =	×
UNCOV 249	srpMetricsDenominator.stream()	×
UNCOV 250	.filter(m -> m.getSrpDecision().equalsIgnoreCase("yes"))	×
UNCOV 251	.collect(Collectors.toList());	×
UNCOV 252	int percentSrp = createPercentage(srpMetricsNumerator.size(), srpMetricsDenominator.size());	×
UNCOV 253	this.percentSRPAccurate = percentSrp;	×
UNCOV 254	}	×
255
256	private String getValue(String str) {
257	return Objects.nonNull(str) ? str : "";	×
258	}
259
260	private String getValue(Integer i) {
261	return Objects.nonNull(i) ? i.toString() : "";	×
262	}
263	}

DataBiosphere / consent / #5817

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous