#6182

Committed 08 Jul 2025 07:04PM UTC coverage: 79.433% (+0.03%) from 79.402%

Build # #6182

Build Type

push

Committed by

Commit Message

DT-1934: Add Institution Domains (#2599)

Coverage Stats

109 of 119 new or added lines in 8 files covered. (91.6%)

10459 of 13167 relevant lines covered (79.43%)

0.79 hits per line

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

72.34

/src/main/java/org/broadinstitute/consent/http/service/InstitutionService.java

package org.broadinstitute.consent.http.service;

import com.google.api.client.http.HttpStatusCodes;
import com.google.inject.Inject;
import jakarta.ws.rs.NotFoundException;
import jakarta.ws.rs.ServerErrorException;
import java.io.IOException;
import java.sql.SQLException;
import java.util.Date;
import java.util.List;
import java.util.Objects;
import org.broadinstitute.consent.http.cloudstore.GCSService;
import org.broadinstitute.consent.http.db.InstitutionDAO;
import org.broadinstitute.consent.http.db.UserDAO;
import org.broadinstitute.consent.http.models.Institution;
import org.broadinstitute.consent.http.models.InstitutionDomainMap;
import org.broadinstitute.consent.http.service.UserService.SimplifiedUser;

public class InstitutionService {

  private final InstitutionDAO institutionDAO;
  private final UserDAO userDAO;
  private final GCSService store;

  @Inject
  public InstitutionService(InstitutionDAO institutionDAO, UserDAO userDAO, GCSService store) {
    this.institutionDAO = institutionDAO;
    this.userDAO = userDAO;
    this.store = store;
  }

  public Institution createInstitution(Institution institution, Integer userId) {
    checkForEmptyName(institution);
    checkUserId(userId);
    try {
      return institutionDAO.insertFullInstitution(institution, userId);
    } catch (SQLException e) {
      throw new ServerErrorException("Could not create institution", HttpStatusCodes.STATUS_CODE_SERVER_ERROR, e);
    }
  }

  public Institution updateInstitutionById(Institution institutionPayload, Integer id,
      Integer userId) throws SQLException {
    Institution targetInstitution = institutionDAO.findInstitutionById(id);
    isInstitutionNull(targetInstitution);
    checkUserId(userId);
    checkForEmptyName(institutionPayload);
    return institutionDAO.updateFullInstitution(institutionPayload, userId);
  }

  public void deleteInstitutionById(Integer id) {
    Institution institution = institutionDAO.findInstitutionById(id);
    isInstitutionNull(institution);
    institutionDAO.deleteInstitutionById(id);
  }

  public Institution findInstitutionById(Integer id) throws NotFoundException {
    Institution institution = institutionDAO.findInstitutionById(id);
    isInstitutionNull(institution);

    List<SimplifiedUser> signingOfficials = userDAO.getSOsByInstitution(id).stream()
        .map(SimplifiedUser::new)
        .toList();
    institution.setSigningOfficials(signingOfficials);

    return institution;
  }

  private InstitutionDomainMap getInstitutionDomainMap() {
    try {
      return store.readJsonFileFromBucket("institution-domain/allowlist.json",
          InstitutionDomainMap.class);
    } catch (IOException e) {
      throw new ServerErrorException("Could not load institution configuration",
          HttpStatusCodes.STATUS_CODE_SERVER_ERROR, e);
    }
  }

  public Institution findInstitutionForEmail(String email) {
    String name = getInstitutionDomainMap().getInstitutionForEmail(email);
    if (name != null) {
      var institutions = institutionDAO.findInstitutionsByName(name);
      if (institutions.size() == 1) {
        return institutions.get(0);
      }
    }
    return null;
  }

  public List<Institution> findAllInstitutions() {
    return institutionDAO.findAllInstitutions();
  }

  public List<Institution> findAllInstitutionsByName(String name) {
    return institutionDAO.findInstitutionsByName(name);
  }

  private void checkForEmptyName(Institution institution) {
    String name = institution.getName();
    if (Objects.isNull(name) || name.isBlank()) {
      throw new IllegalArgumentException("Institution name cannot be null or empty");
    }
  }

  private void checkUserId(Integer userId) {
    if (Objects.isNull(userId)) {
      throw new IllegalArgumentException("User ID is a required parameter");
    }
  }

  private void isInstitutionNull(Institution institution) {
    if (Objects.isNull(institution)) {
      throw new NotFoundException("Institution not found");
    }
  }
}

1	package org.broadinstitute.consent.http.service;
2
3	import com.google.api.client.http.HttpStatusCodes;
4	import com.google.inject.Inject;
5	import jakarta.ws.rs.NotFoundException;
6	import jakarta.ws.rs.ServerErrorException;
7	import java.io.IOException;
8	import java.sql.SQLException;
9	import java.util.Date;
10	import java.util.List;
11	import java.util.Objects;
12	import org.broadinstitute.consent.http.cloudstore.GCSService;
13	import org.broadinstitute.consent.http.db.InstitutionDAO;
14	import org.broadinstitute.consent.http.db.UserDAO;
15	import org.broadinstitute.consent.http.models.Institution;
16	import org.broadinstitute.consent.http.models.InstitutionDomainMap;
17	import org.broadinstitute.consent.http.service.UserService.SimplifiedUser;
18
19	public class InstitutionService {
20
21	private final InstitutionDAO institutionDAO;
22	private final UserDAO userDAO;
23	private final GCSService store;
24
25	@Inject
26	public InstitutionService(InstitutionDAO institutionDAO, UserDAO userDAO, GCSService store) {	1✔
27	this.institutionDAO = institutionDAO;	1✔
28	this.userDAO = userDAO;	1✔
29	this.store = store;	1✔
30	}	1✔
31
32	public Institution createInstitution(Institution institution, Integer userId) {
33	checkForEmptyName(institution);	1✔
34	checkUserId(userId);	1✔
35	try {
36	return institutionDAO.insertFullInstitution(institution, userId);	1✔
NEW 37	} catch (SQLException e) {	×
NEW 38	throw new ServerErrorException("Could not create institution", HttpStatusCodes.STATUS_CODE_SERVER_ERROR, e);	×
39	}
40	}
41
42	public Institution updateInstitutionById(Institution institutionPayload, Integer id,
43	Integer userId) throws SQLException {
44	Institution targetInstitution = institutionDAO.findInstitutionById(id);	1✔
45	isInstitutionNull(targetInstitution);	1✔
46	checkUserId(userId);	1✔
47	checkForEmptyName(institutionPayload);	1✔
48	return institutionDAO.updateFullInstitution(institutionPayload, userId);	1✔
49	}
50
51	public void deleteInstitutionById(Integer id) {
52	Institution institution = institutionDAO.findInstitutionById(id);	1✔
53	isInstitutionNull(institution);	1✔
54	institutionDAO.deleteInstitutionById(id);	1✔
55	}	1✔
56
57	public Institution findInstitutionById(Integer id) throws NotFoundException {
58	Institution institution = institutionDAO.findInstitutionById(id);	1✔
59	isInstitutionNull(institution);	1✔
60
61	List<SimplifiedUser> signingOfficials = userDAO.getSOsByInstitution(id).stream()	1✔
62	.map(SimplifiedUser::new)	1✔
63	.toList();	1✔
64	institution.setSigningOfficials(signingOfficials);	1✔
65
66	return institution;	1✔
67	}
68
69	private InstitutionDomainMap getInstitutionDomainMap() {
70	try {
71	return store.readJsonFileFromBucket("institution-domain/allowlist.json",	×
72	InstitutionDomainMap.class);
73	} catch (IOException e) {	×
74	throw new ServerErrorException("Could not load institution configuration",	×
75	HttpStatusCodes.STATUS_CODE_SERVER_ERROR, e);
76	}
77	}
78
79	public Institution findInstitutionForEmail(String email) {
80	String name = getInstitutionDomainMap().getInstitutionForEmail(email);	×
81	if (name != null) {	×
82	var institutions = institutionDAO.findInstitutionsByName(name);	×
83	if (institutions.size() == 1) {	×
84	return institutions.get(0);	×
85	}
86	}
87	return null;	×
88	}
89
90	public List<Institution> findAllInstitutions() {
91	return institutionDAO.findAllInstitutions();	1✔
92	}
93
94	public List<Institution> findAllInstitutionsByName(String name) {
95	return institutionDAO.findInstitutionsByName(name);	×
96	}
97
98	private void checkForEmptyName(Institution institution) {
99	String name = institution.getName();	1✔
100	if (Objects.isNull(name) \|\| name.isBlank()) {	1✔
101	throw new IllegalArgumentException("Institution name cannot be null or empty");	1✔
102	}
103	}	1✔
104
105	private void checkUserId(Integer userId) {
106	if (Objects.isNull(userId)) {	1✔
107	throw new IllegalArgumentException("User ID is a required parameter");	×
108	}
109	}	1✔
110
111	private void isInstitutionNull(Institution institution) {
112	if (Objects.isNull(institution)) {	1✔
113	throw new NotFoundException("Institution not found");	1✔
114	}
115	}	1✔
116	}

DataBiosphere / consent / #6182

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