#5692

Committed 18 Apr 2025 02:50PM UTC coverage: 78.932% (-0.02%) from 78.955%

Build # #5692

Build Type

push

Committed by

Commit Message

DT-1497: Add code to auto-set institution on user creation (#2485)

Institution is no longer selected by user but is assigned based on a user's email address and the DUOS configured domain-to-institution mapping.

Coverage Stats

52 of 68 new or added lines in 8 files covered. (76.47%)

1 existing line in 1 file now uncovered.

10183 of 12901 relevant lines covered (78.93%)

0.79 hits per line

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

84.06

/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.util.Date;
import java.util.List;
import java.util.Objects;
import java.util.stream.Collectors;
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);
    Date createTimestamp = new Date();
    Integer id = institutionDAO.insertInstitution(
        institution.getName(),
        institution.getItDirectorName(),
        institution.getItDirectorEmail(),
        institution.getInstitutionUrl(),
        institution.getDunsNumber(),
        institution.getOrgChartUrl(),
        institution.getVerificationUrl(),
        institution.getVerificationFilename(),
        (Objects.nonNull(institution.getOrganizationType()) ? institution.getOrganizationType()
            .getValue() : null),
        userId,
        createTimestamp
    );
    return institutionDAO.findInstitutionById(id);
  }

  public Institution updateInstitutionById(Institution institutionPayload, Integer id,
      Integer userId) {
    Institution targetInstitution = institutionDAO.findInstitutionById(id);
    isInstitutionNull(targetInstitution);
    checkUserId(userId);
    checkForEmptyName(institutionPayload);
    Date updateDate = new Date();
    institutionDAO.updateInstitutionById(
        id,
        institutionPayload.getName(),
        institutionPayload.getItDirectorEmail(),
        institutionPayload.getItDirectorName(),
        institutionPayload.getInstitutionUrl(),
        institutionPayload.getDunsNumber(),
        institutionPayload.getOrgChartUrl(),
        institutionPayload.getVerificationUrl(),
        institutionPayload.getVerificationFilename(),
        (Objects.nonNull(institutionPayload.getOrganizationType())
            ? institutionPayload.getOrganizationType().getValue() : null),
        userId,
        updateDate
    );
    return institutionDAO.findInstitutionById(id);
  }

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

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

    List<SimplifiedUser> signingOfficials = userDAO.getSOsByInstitution(id).stream()
        .map(SimplifiedUser::new)
        .collect(Collectors.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.util.Date;
9	import java.util.List;
10	import java.util.Objects;
11	import java.util.stream.Collectors;
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	Date createTimestamp = new Date();	1✔
36	Integer id = institutionDAO.insertInstitution(	1✔
37	institution.getName(),	1✔
38	institution.getItDirectorName(),	1✔
39	institution.getItDirectorEmail(),	1✔
40	institution.getInstitutionUrl(),	1✔
41	institution.getDunsNumber(),	1✔
42	institution.getOrgChartUrl(),	1✔
43	institution.getVerificationUrl(),	1✔
44	institution.getVerificationFilename(),	1✔
45	(Objects.nonNull(institution.getOrganizationType()) ? institution.getOrganizationType()	1✔
46	.getValue() : null),	1✔
47	userId,
48	createTimestamp
49	);
50	return institutionDAO.findInstitutionById(id);	1✔
51	}
52
53	public Institution updateInstitutionById(Institution institutionPayload, Integer id,
54	Integer userId) {
55	Institution targetInstitution = institutionDAO.findInstitutionById(id);	1✔
56	isInstitutionNull(targetInstitution);	1✔
57	checkUserId(userId);	1✔
58	checkForEmptyName(institutionPayload);	1✔
59	Date updateDate = new Date();	1✔
60	institutionDAO.updateInstitutionById(	1✔
61	id,
62	institutionPayload.getName(),	1✔
63	institutionPayload.getItDirectorEmail(),	1✔
64	institutionPayload.getItDirectorName(),	1✔
65	institutionPayload.getInstitutionUrl(),	1✔
66	institutionPayload.getDunsNumber(),	1✔
67	institutionPayload.getOrgChartUrl(),	1✔
68	institutionPayload.getVerificationUrl(),	1✔
69	institutionPayload.getVerificationFilename(),	1✔
70	(Objects.nonNull(institutionPayload.getOrganizationType())	1✔
71	? institutionPayload.getOrganizationType().getValue() : null),	1✔
72	userId,
73	updateDate
74	);
75	return institutionDAO.findInstitutionById(id);	1✔
76	}
77
78	public void deleteInstitutionById(Integer id) {
79	Institution institution = institutionDAO.findInstitutionById(id);	1✔
80	isInstitutionNull(institution);	1✔
81	institutionDAO.deleteInstitutionById(id);	1✔
82	}	1✔
83
84	public Institution findInstitutionById(Integer id) {
85	Institution institution = institutionDAO.findInstitutionById(id);	1✔
86	isInstitutionNull(institution);	1✔
87
88	List<SimplifiedUser> signingOfficials = userDAO.getSOsByInstitution(id).stream()	1✔
89	.map(SimplifiedUser::new)	1✔
90	.collect(Collectors.toList());	1✔
91	institution.setSigningOfficials(signingOfficials);	1✔
92
93	return institution;	1✔
94	}
95
96	private InstitutionDomainMap getInstitutionDomainMap() {
97	try {
NEW 98	return store.readJsonFileFromBucket("institution-domain/allowlist.json",	×
99	InstitutionDomainMap.class);
NEW 100	} catch (IOException e) {	×
NEW 101	throw new ServerErrorException("Could not load institution configuration",	×
102	HttpStatusCodes.STATUS_CODE_SERVER_ERROR, e);
103	}
104	}
105
106	public Institution findInstitutionForEmail(String email) {
NEW 107	String name = getInstitutionDomainMap().getInstitutionForEmail(email);	×
NEW 108	if (name != null) {	×
NEW 109	var institutions = institutionDAO.findInstitutionsByName(name);	×
NEW 110	if (institutions.size() == 1) {	×
NEW 111	return institutions.get(0);	×
112	}
113	}
NEW 114	return null;	×
115	}
116
117	public List<Institution> findAllInstitutions() {
118	return institutionDAO.findAllInstitutions();	1✔
119	}
120
121	public List<Institution> findAllInstitutionsByName(String name) {
122	return institutionDAO.findInstitutionsByName(name);	×
123	}
124
125	private void checkForEmptyName(Institution institution) {
126	String name = institution.getName();	1✔
127	if (Objects.isNull(name) \|\| name.isBlank()) {	1✔
128	throw new IllegalArgumentException("Institution name cannot be null or empty");	1✔
129	}
130	}	1✔
131
132	private void checkUserId(Integer userId) {
133	if (Objects.isNull(userId)) {	1✔
134	throw new IllegalArgumentException("User ID is a required parameter");	×
135	}
136	}	1✔
137
138	private void isInstitutionNull(Institution institution) {
139	if (Objects.isNull(institution)) {	1✔
140	throw new NotFoundException("Institution not found");	1✔
141	}
142	}	1✔
143	}

DataBiosphere / consent / #5692

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