Use Jurisdiction, TylerEnv, and TylerDomain internally everywhere

Jurisdiction is vendor agnostic, and also contains info about API type
(will be helpful with ECF5 changes).

Instead of strings, which could be accidentally switched, or not verified.
Yay more solid typings!

TylerDomains get used mostly everywhere.

Still TODO:

* config: many things in environment variables (specifically `TYLER_JURISDICTIONS`
  and `TOGA_CLIENT_KEYS`) are still Tyler only. This stuff can't easily be fixed
  until we have a better config / secret setup, which can come after we make it
  easier to handle jurisdictions.
* Setup in JurisdictionSwitch, TylerModuleSetup, JeffNetModuleSetup, etc. can still
  be simplified based on the Jurisdiction value it gets. Haven't integrated that
  yet, and the Module setup is still hard-coded to either Tyler or JeffNet.

Fix #283, #284

Author: BryceStevenWilley

EfspCommons/src/main/java/edu/suffolk/litlab/efsp/Jurisdiction.java

@@ -0,0 +1,60 @@
+package edu.suffolk.litlab.efsp;
+
+/**
+ * The jurisdictions (states) that our code works in and that we support. Even though all possible
+ * jurisdictions might be listed here, only those set to the <code>TYLER_JURISDICTIONS</code> env
+ * var are supported at runtime.
+ *
+ * <p>At the moment, each jurisdiction is uniquely mapped to a single API and Vendor of that API
+ * (i.e. ECF, and Tyler). This is for when we expand to having multiple APIs (i.e. ECF v4 and ECF
+ * v5) and multiple vendors(Tyler and SoftImage).
+ */
+public enum Jurisdiction {
+  CALIFORNIA("california", Api.ECF_4, Vendor.TYLER),
+  INDIANA("indiana", Api.ECF_4, Vendor.TYLER),
+  ILLINOIS("illinois", Api.ECF_4_Schedule, Vendor.TYLER),
+  LOUISIANA("louisiana", Api.JEFFNET, Vendor.JEFFERSON_PARISH),
+  MASSACHUSETTS("massachusetts", Api.ECF_4, Vendor.TYLER),
+  TEXAS("texas", Api.ECF_4, Vendor.TYLER),
+  VERMONT("vermont", Api.ECF_4, Vendor.TYLER);
+
+  private enum Api {
+    JEFFNET,
+    ECF_4,
+    // Illinois uses a custom Tyler ECF4 version, which includes a pre-release ECF 5
+    // version of the Court Scheduling MDE.
+    ECF_4_Schedule;
+  }
+
+  private enum Vendor {
+    JEFFERSON_PARISH,
+    TYLER;
+  }
+
+  private String name;
+  private Api api;
+  private Vendor vendor;
+
+  private Jurisdiction(String name, Api api, Vendor vendor) {
+    this.name = name;
+    this.api = api;
+    this.vendor = vendor;
+  }
+
+  public String getName() {
+    return name;
+  }
+
+  public Vendor getVendor() {
+    return vendor;
+  }
+
+  public static Jurisdiction parse(String value) {
+    for (var jurisdiction : Jurisdiction.values()) {
+      if (value.equalsIgnoreCase(jurisdiction.getName())) {
+        return jurisdiction;
+      }
+    }
+    throw new IllegalArgumentException("Can't make a `Jurisdiction` from: `" + value + "`");
+  }
+}

TylerEfmClient/src/main/java/edu/suffolk/litlab/efsp/tyler/TylerClients.java

@@ -1,5 +1,6 @@
 package edu.suffolk.litlab.efsp.tyler;
 
+import edu.suffolk.litlab.efsp.Jurisdiction;
 import java.net.URL;
 import java.util.Map;
 import java.util.Optional;
@@ -14,80 +15,85 @@ public class TylerClients {
   private static final String USER_WSDL = "-EFMUserServiceSingle.svc.wsdl";
   private static final String FIRM_WSDL = "-EFMFirmServiceSingle.svc.wsdl";
 
-  private static final Map<String, TylerVersion> STAGE_VERSION_MAP =
+  private static final Map<Jurisdiction, TylerVersion> STAGE_VERSION_MAP =
       Map.of(
-          "california", TylerVersion.v2024_6,
-          "illinois", TylerVersion.v2024_6,
-          "indiana", TylerVersion.v2024_6,
-          "massachusetts", TylerVersion.v2025_0,
-          "texas", TylerVersion.v2024_6,
-          "vermont", TylerVersion.v2024_6);
+          Jurisdiction.CALIFORNIA, TylerVersion.v2024_6,
+          Jurisdiction.ILLINOIS, TylerVersion.v2024_6,
+          Jurisdiction.INDIANA, TylerVersion.v2024_6,
+          Jurisdiction.MASSACHUSETTS, TylerVersion.v2025_0,
+          Jurisdiction.TEXAS, TylerVersion.v2024_6,
+          Jurisdiction.VERMONT, TylerVersion.v2024_6);
 
-  private static final Map<String, TylerVersion> PROD_VERSION_MAP =
+  private static final Map<Jurisdiction, TylerVersion> PROD_VERSION_MAP =
       Map.of(
-          "illinois", TylerVersion.v2024_6,
-          "massachusetts", TylerVersion.v2022_1);
+          Jurisdiction.ILLINOIS, TylerVersion.v2024_6,
+          Jurisdiction.MASSACHUSETTS, TylerVersion.v2022_1);
 
   /**
    * Gets the EfmUserService from the individual jursdiction and env arguments.
    *
-   * @param jurisdiction e.g. "illinois".
-   * @param env e.g. "stage", "test", or "prod"
+   * @param domain e.g. Jurisdiction.ILLINOIS, TylerEnv.STAGE.
    */
-  public static Optional<TylerUserFactory> getEfmUserFactory(String jurisdiction, TylerEnv env) {
-    var version = getVersion(jurisdiction, env);
+  public static Optional<TylerUserFactory> getEfmUserFactory(TylerDomain domain) {
+    var version = getVersion(domain);
     return version.flatMap(
         v -> {
-          var url = createLocalWsdlUrl(jurisdiction, env, v, USER_WSDL);
+          var url = createLocalWsdlUrl(domain, v, USER_WSDL);
           return url.map(u -> new TylerUserFactory(new EfmUserService(u), v));
         });
   }
 
-  public static Optional<TylerFirmFactory> getEfmFirmFactory(String jurisdiction, TylerEnv env) {
-    var version = getVersion(jurisdiction, env);
+  public static Optional<TylerFirmFactory> getEfmFirmFactory(TylerDomain domain) {
+    var version = getVersion(domain);
     return version.flatMap(
         v -> {
-          var url = createLocalWsdlUrl(jurisdiction, env, v, FIRM_WSDL);
+          var url = createLocalWsdlUrl(domain, v, FIRM_WSDL);
           return url.map(u -> new TylerFirmFactory(new EfmFirmService(u), v));
         });
   }
 
   /**
    * Gets Tyler server's root URL for a given jurisdiction / Tyler Env (i.e. california stage).
    *
-   * @param jurisdiction
-   * @param envEnum
+   * <p>TODO(brycew): turn this into a URL type? Find where it's used.
+   *
+   * @param domain
    * @return
    */
-  public static String getTylerServerRootUrl(String jurisdiction, TylerEnv envEnum) {
-    String env = envEnum.name().toLowerCase();
-    if (jurisdiction.equalsIgnoreCase("california")) {
-      return "https://california-efm-" + env + ".tylertech.cloud/";
+  public static String getTylerServerRootUrl(TylerDomain domain) {
+    if (domain.jurisdiction() == Jurisdiction.CALIFORNIA) {
+      return "https://california-efm-" + domain.env().getName() + ".tylertech.cloud/";
     }
-    if (envEnum.equals(TylerEnv.PROD)) {
-      return "https://" + jurisdiction + ".tylertech.cloud/";
+    if (domain.env() == TylerEnv.PROD) {
+      return "https://" + domain.jurisdiction().getName() + ".tylertech.cloud/";
     }
-    return "https://" + jurisdiction + "-" + env + ".tylertech.cloud/";
+    return "https://" + domain.getName() + ".tylertech.cloud/";
   }
 
-  private static Optional<TylerVersion> getVersion(String jurisdiction, TylerEnv tylerEnv) {
-    Map<String, TylerVersion> versionMap =
-        switch (tylerEnv) {
+  private static Optional<TylerVersion> getVersion(TylerDomain domain) {
+    Map<Jurisdiction, TylerVersion> versionMap =
+        switch (domain.env()) {
           case TylerEnv.STAGE -> STAGE_VERSION_MAP;
           case TylerEnv.PROD -> PROD_VERSION_MAP;
         };
 
-    if (!versionMap.containsKey(jurisdiction)) {
+    if (!versionMap.containsKey(domain.jurisdiction())) {
       return Optional.empty();
     }
 
-    return Optional.of(versionMap.get(jurisdiction));
+    return Optional.of(versionMap.get(domain.jurisdiction()));
   }
 
   private static Optional<URL> createLocalWsdlUrl(
-      String jurisdiction, TylerEnv env, TylerVersion version, String suffix) {
+      TylerDomain domain, TylerVersion version, String suffix) {
     String wsdlPath =
-        "wsdl/" + version.getVersionPath() + "/" + env.getPath() + "/" + jurisdiction + suffix;
+        "wsdl/"
+            + version.getVersionPath()
+            + "/"
+            + domain.env().getName()
+            + "/"
+            + domain.jurisdiction().getName()
+            + suffix;
     URL url = TylerClients.class.getClassLoader().getResource(wsdlPath);
     if (url == null) {
       log.warn("Could not find the wsdl at the classpath:{}", wsdlPath);

TylerEfmClient/src/main/java/edu/suffolk/litlab/efsp/tyler/TylerDomain.java

@@ -0,0 +1,13 @@
+package edu.suffolk.litlab.efsp.tyler;
+
+import edu.suffolk.litlab.efsp.Jurisdiction;
+
+/**
+ * A combination of a Tyler jurisdiction and env, resulting in a specific set of servers to send
+ * requests to.
+ */
+public record TylerDomain(Jurisdiction jurisdiction, TylerEnv env) {
+  public String getName() {
+    return jurisdiction.getName() + "-" + env.getName();
+  }
+}

TylerEfmClient/src/main/java/edu/suffolk/litlab/efsp/tyler/TylerEnv.java

@@ -13,22 +13,16 @@ private TylerEnv(String name) {
     this.name = name;
   }
 
-  // ** Used for when the env determines a URL / filepath. */
-  public String getPath() {
-    return name;
-  }
-
   public String getName() {
     return name;
   }
 
   public static TylerEnv parse(String value) {
-    if (value.equalsIgnoreCase(STAGE.getName())) {
-      return STAGE;
-    } else if (value.equalsIgnoreCase(PROD.getName())) {
-      return PROD;
-    } else {
-      throw new IllegalArgumentException("Can't make a `TylerEnv` from: `" + value + "`'");
+    for (var env : TylerEnv.values()) {
+      if (value.equalsIgnoreCase(env.getName())) {
+        return env;
+      }
     }
+    throw new IllegalArgumentException("Can't make a `TylerEnv` from: `" + value + "`");
   }
 }

TylerEfmClient/src/test/java/edu/suffolk/litlab/efsp/tyler/TylerClientsTest.java

@@ -1,7 +1,10 @@
 package edu.suffolk.litlab.efsp.tyler;
 
+import static edu.suffolk.litlab.efsp.Jurisdiction.*;
+import static edu.suffolk.litlab.efsp.tyler.TylerEnv.*;
 import static org.assertj.core.api.Assertions.assertThat;
 
+import edu.suffolk.litlab.efsp.Jurisdiction;
 import java.io.IOException;
 import java.net.HttpURLConnection;
 import java.net.URI;
@@ -16,41 +19,41 @@ public class TylerClientsTest {
 
   @Test
   public void allFactoriesShouldNotThrow() {
-    for (String jurisdiction :
-        List.of("texas", "massachusetts", "illinois", "indiana", "california", "wales")) {
+    for (Jurisdiction jurisdiction :
+        List.of(TEXAS, MASSACHUSETTS, ILLINOIS, INDIANA, CALIFORNIA, VERMONT)) {
       for (TylerEnv env : TylerEnv.values()) {
-        assertThat(TylerClients.getEfmFirmFactory(jurisdiction, env)).isNotNull();
-        assertThat(TylerClients.getEfmUserFactory(jurisdiction, env)).isNotNull();
+        var domain = new TylerDomain(jurisdiction, env);
+        assertThat(TylerClients.getEfmFirmFactory(domain)).isNotNull();
+        assertThat(TylerClients.getEfmUserFactory(domain)).isNotNull();
       }
     }
-    assertThat(TylerClients.getEfmUserFactory("antartica", TylerEnv.STAGE)).isEmpty();
-    assertThat(TylerClients.getEfmUserFactory("massachusetts", TylerEnv.PROD)).isNotEmpty();
-    assertThat(TylerClients.getEfmUserFactory("illinois", TylerEnv.STAGE)).isNotEmpty();
+    assertThat(TylerClients.getEfmUserFactory(new TylerDomain(MASSACHUSETTS, PROD))).isNotEmpty();
+    assertThat(TylerClients.getEfmUserFactory(new TylerDomain(ILLINOIS, STAGE))).isNotEmpty();
   }
 
   @Test
   public void testJurisdictionEnvUrls() throws IOException, URISyntaxException {
     testJurisdictionEnvUrl(
         "https://texas-stage.tylertech.cloud/",
-        TylerClients.getTylerServerRootUrl("texas", TylerEnv.STAGE));
+        TylerClients.getTylerServerRootUrl(new TylerDomain(TEXAS, STAGE)));
     testJurisdictionEnvUrl(
         "https://texas.tylertech.cloud/",
-        TylerClients.getTylerServerRootUrl("texas", TylerEnv.PROD));
+        TylerClients.getTylerServerRootUrl(new TylerDomain(TEXAS, PROD)));
     testJurisdictionEnvUrl(
         "https://massachusetts-stage.tylertech.cloud/",
-        TylerClients.getTylerServerRootUrl("massachusetts", TylerEnv.STAGE));
+        TylerClients.getTylerServerRootUrl(new TylerDomain(MASSACHUSETTS, STAGE)));
     testJurisdictionEnvUrl(
         "https://massachusetts.tylertech.cloud/",
-        TylerClients.getTylerServerRootUrl("massachusetts", TylerEnv.PROD));
+        TylerClients.getTylerServerRootUrl(new TylerDomain(MASSACHUSETTS, PROD)));
     testJurisdictionEnvUrl(
         "https://illinois-stage.tylertech.cloud/",
-        TylerClients.getTylerServerRootUrl("illinois", TylerEnv.STAGE));
+        TylerClients.getTylerServerRootUrl(new TylerDomain(ILLINOIS, STAGE)));
     testJurisdictionEnvUrl(
         "https://illinois.tylertech.cloud/",
-        TylerClients.getTylerServerRootUrl("illinois", TylerEnv.PROD));
+        TylerClients.getTylerServerRootUrl(new TylerDomain(ILLINOIS, PROD)));
   }
 
-  public void testJurisdictionEnvUrl(String urlExpected, String urlGenerated)
+  private void testJurisdictionEnvUrl(String urlExpected, String urlGenerated)
       throws IOException, URISyntaxException {
     assertThat(urlGenerated).isEqualTo(urlExpected);
     URL url = (new URI(urlGenerated)).toURL();

proxyserver/src/main/java/edu/suffolk/litlab/efsp/ecfcodes/CodeDatabaseAPI.java

@@ -1,6 +1,7 @@
 package edu.suffolk.litlab.efsp.ecfcodes;
 
 import edu.suffolk.litlab.efsp.db.Database;
+import edu.suffolk.litlab.efsp.tyler.TylerDomain;
 import jakarta.xml.bind.JAXBContext;
 import jakarta.xml.bind.JAXBException;
 import jakarta.xml.bind.Unmarshaller;
@@ -34,7 +35,7 @@ public CodeDatabaseAPI(Connection conn) {
    * The domain (the juristiction + environment, e.g. illinois-stage) that this database is working
    * over.
    */
-  public abstract String getDomain();
+  public abstract TylerDomain getDomain();
 
   /**
    * Gets all court location identifiers (CLI) stored in the database.