Remove more unused contact references

This avoids changing any functionality, including the bits of
DomainCommand (representations of XML files) that reference contacts.
Currently, we "allow" parsing of contacts in DomainCommands and fail
later as part of the domain flow,  even though in practice the parsing itself will fail now that no
contacts exist in the database.

Because we wish to keep the "contacts aren't allowed in flows" tests
active (e.g.
DomainUpdateFlowTest::testFailure_minimumDataset_whenAddingNewContacts)
we have to keep the usages of contacts in DomainCommand active for now.

Author: gbrodman

core/src/main/java/google/registry/batch/DeleteLoadTestDataAction.java

@@ -29,7 +29,6 @@
 import google.registry.flows.poll.PollFlowUtils;
 import google.registry.model.EppResource;
 import google.registry.model.EppResourceUtils;
-import google.registry.model.contact.Contact;
 import google.registry.model.domain.Domain;
 import google.registry.model.host.Host;
 import google.registry.model.poll.PollMessage;
@@ -94,7 +93,6 @@ public void run() {
             TRANSACTION_REPEATABLE_READ,
             () -> {
               LOAD_TEST_REGISTRARS.forEach(this::deletePollMessages);
-              tm().loadAllOfStream(Contact.class).forEach(this::deleteContact);
               tm().loadAllOfStream(Host.class).forEach(this::deleteHost);
             });
   }
@@ -110,21 +108,6 @@ private void deletePollMessages(String registrarId) {
     }
   }
 
-  private void deleteContact(Contact contact) {
-    if (!LOAD_TEST_REGISTRARS.contains(contact.getPersistedCurrentSponsorRegistrarId())) {
-      return;
-    }
-    // We cannot remove contacts from domains in the general case, so we cannot delete contacts
-    // that are linked to domains (since it would break the foreign keys)
-    if (EppResourceUtils.isLinked(contact.createVKey(), clock.nowUtc())) {
-      logger.atWarning().log(
-          "Cannot delete contact with repo ID %s since it is referenced from a domain.",
-          contact.getRepoId());
-      return;
-    }
-    deleteResource(contact);
-  }
-
   private void deleteHost(Host host) {
     if (!LOAD_TEST_REGISTRARS.contains(host.getPersistedCurrentSponsorRegistrarId())) {
       return;

core/src/main/java/google/registry/beam/resave/ResaveAllEppResourcesPipeline.java

@@ -25,7 +25,6 @@
 import google.registry.beam.common.RegistryJpaIO;
 import google.registry.beam.common.RegistryJpaIO.Read;
 import google.registry.model.EppResource;
-import google.registry.model.contact.Contact;
 import google.registry.model.domain.Domain;
 import google.registry.model.domain.DomainBase;
 import google.registry.model.host.Host;
@@ -56,7 +55,7 @@
 public class ResaveAllEppResourcesPipeline implements Serializable {
 
   private static final ImmutableSet<Class<? extends EppResource>> EPP_RESOURCE_CLASSES =
-      ImmutableSet.of(Contact.class, Domain.class, Host.class);
+      ImmutableSet.of(Domain.class, Host.class);
 
   /**
    * There exist three possible situations where we know we'll want to project domains to the
@@ -92,25 +91,12 @@ PipelineResult run() {
 
   void setupPipeline(Pipeline pipeline) {
     if (options.getFast()) {
-      fastResaveContacts(pipeline);
       fastResaveDomains(pipeline);
     } else {
       EPP_RESOURCE_CLASSES.forEach(clazz -> forceResaveAllResources(pipeline, clazz));
     }
   }
 
-  /** Projects to the current time and saves any contacts with expired transfers. */
-  private void fastResaveContacts(Pipeline pipeline) {
-    Read<String, String> repoIdRead =
-        RegistryJpaIO.read(
-                "SELECT repoId FROM Contact WHERE transferData.transferStatus = 'PENDING' AND"
-                    + " transferData.pendingTransferExpirationTime < current_timestamp()",
-                String.class,
-                r -> r)
-            .withCoder(StringUtf8Coder.of());
-    projectAndResaveResources(pipeline, Contact.class, repoIdRead);
-  }
-
   /**
    * Projects to the current time and saves any domains with expired pending actions (e.g.
    * transfers, grace periods).

core/src/main/java/google/registry/flows/ResourceFlowUtils.java

@@ -34,14 +34,14 @@
 import google.registry.flows.exceptions.TooManyResourceChecksException;
 import google.registry.model.EppResource;
 import google.registry.model.EppResource.ForeignKeyedEppResource;
-import google.registry.model.EppResource.ResourceWithTransferData;
 import google.registry.model.ForeignKeyUtils;
 import google.registry.model.domain.Domain;
 import google.registry.model.domain.DomainBase;
 import google.registry.model.domain.Period;
 import google.registry.model.domain.rgp.GracePeriodStatus;
 import google.registry.model.eppcommon.AuthInfo;
 import google.registry.model.eppcommon.StatusValue;
+import google.registry.model.host.Host;
 import google.registry.model.transfer.TransferStatus;
 import google.registry.persistence.VKey;
 import java.util.List;
@@ -63,30 +63,26 @@ public static void verifyResourceOwnership(String myRegistrarId, EppResource res
     }
   }
 
-  /**
-   * Check whether if there are domains linked to the resource to be deleted. Throws an exception if
-   * so.
-   */
-  public static <R extends EppResource> void checkLinkedDomains(
-      final String targetId, final DateTime now, final Class<R> resourceClass) throws EppException {
-    VKey<R> key =
-        ForeignKeyUtils.loadKey(resourceClass, targetId, now)
-            .orElseThrow(() -> new ResourceDoesNotExistException(resourceClass, targetId));
+  /** Check if there are domains linked to the host to be deleted. Throws an exception if so. */
+  public static void checkLinkedDomains(final String targetId, final DateTime now)
+      throws EppException {
+    VKey<Host> key =
+        ForeignKeyUtils.loadKey(Host.class, targetId, now)
+            .orElseThrow(() -> new ResourceDoesNotExistException(Host.class, targetId));
     if (isLinked(key, now)) {
       throw new ResourceToDeleteIsReferencedException();
     }
   }
 
-  public static <R extends EppResource & ResourceWithTransferData> void verifyHasPendingTransfer(
-      R resource) throws NotPendingTransferException {
-    if (resource.getTransferData().getTransferStatus() != TransferStatus.PENDING) {
-      throw new NotPendingTransferException(resource.getForeignKey());
+  public static void verifyHasPendingTransfer(Domain domain) throws NotPendingTransferException {
+    if (domain.getTransferData().getTransferStatus() != TransferStatus.PENDING) {
+      throw new NotPendingTransferException(domain.getForeignKey());
     }
   }
 
-  public static <R extends EppResource & ResourceWithTransferData> void verifyTransferInitiator(
-      String registrarId, R resource) throws NotTransferInitiatorException {
-    if (!resource.getTransferData().getGainingRegistrarId().equals(registrarId)) {
+  public static void verifyTransferInitiator(String registrarId, Domain domain)
+      throws NotTransferInitiatorException {
+    if (!domain.getTransferData().getGainingRegistrarId().equals(registrarId)) {
       throw new NotTransferInitiatorException();
     }
   }

core/src/main/java/google/registry/flows/host/HostDeleteFlow.java

@@ -84,7 +84,7 @@ public EppResponse run() throws EppException {
     extensionManager.validate();
     DateTime now = tm().getTransactionTime();
     validateHostName(targetId);
-    checkLinkedDomains(targetId, now, Host.class);
+    checkLinkedDomains(targetId, now);
     Host existingHost = loadAndVerifyExistence(Host.class, targetId, now);
     verifyNoDisallowedStatuses(existingHost, ImmutableSet.of(StatusValue.PENDING_DELETE));
     if (!isSuperuser) {

core/src/main/java/google/registry/model/EppResourceUtils.java

@@ -23,17 +23,14 @@
 
 import com.google.common.collect.ImmutableSet;
 import com.google.common.flogger.FluentLogger;
-import google.registry.model.EppResource.BuilderWithTransferData;
-import google.registry.model.EppResource.ResourceWithTransferData;
-import google.registry.model.contact.Contact;
 import google.registry.model.domain.Domain;
+import google.registry.model.domain.DomainBase;
 import google.registry.model.eppcommon.StatusValue;
 import google.registry.model.host.Host;
 import google.registry.model.reporting.HistoryEntry;
 import google.registry.model.reporting.HistoryEntryDao;
 import google.registry.model.tld.Tld;
 import google.registry.model.transfer.DomainTransferData;
-import google.registry.model.transfer.TransferData;
 import google.registry.model.transfer.TransferStatus;
 import google.registry.persistence.VKey;
 import jakarta.persistence.Query;
@@ -48,14 +45,6 @@ public final class EppResourceUtils {
 
   private static final FluentLogger logger = FluentLogger.forEnclosingClass();
 
-  private static final String CONTACT_LINKED_DOMAIN_QUERY =
-      "SELECT repoId FROM Domain "
-          + "WHERE (adminContact = :fkRepoId "
-          + "OR billingContact = :fkRepoId "
-          + "OR techContact = :fkRepoId "
-          + "OR registrantContact = :fkRepoId) "
-          + "AND deletionTime > :now";
-
   // We have to use the native SQL query here because DomainHost table doesn't have its entity
   // class, so we cannot reference its property like domainHost.hostRepoId in a JPQL query.
   private static final String HOST_LINKED_DOMAIN_QUERY =
@@ -105,41 +94,34 @@ public static boolean isDeleted(EppResource resource, DateTime time) {
     return !isActive(resource, time);
   }
 
-  /** Process an automatic transfer on a resource. */
-  public static <
-          T extends TransferData,
-          B extends EppResource.Builder<?, B> & BuilderWithTransferData<T, B>>
-      void setAutomaticTransferSuccessProperties(B builder, TransferData transferData) {
+  /** Process an automatic transfer on a domain. */
+  public static void setAutomaticTransferSuccessProperties(
+      DomainBase.Builder<?, ?> builder, DomainTransferData transferData) {
     checkArgument(TransferStatus.PENDING.equals(transferData.getTransferStatus()));
-    TransferData.Builder transferDataBuilder = transferData.asBuilder();
+    DomainTransferData.Builder transferDataBuilder = transferData.asBuilder();
     transferDataBuilder.setTransferStatus(TransferStatus.SERVER_APPROVED);
-    transferDataBuilder.setServerApproveEntities(null, null, null);
-    if (transferData instanceof DomainTransferData) {
-      ((DomainTransferData.Builder) transferDataBuilder)
-          .setServerApproveBillingEvent(null)
-          .setServerApproveAutorenewEvent(null)
-          .setServerApproveAutorenewPollMessage(null);
-    }
+    transferDataBuilder
+        .setServerApproveEntities(null, null, null)
+        .setServerApproveBillingEvent(null)
+        .setServerApproveAutorenewEvent(null)
+        .setServerApproveAutorenewPollMessage(null);
     builder
         .removeStatusValue(StatusValue.PENDING_TRANSFER)
-        .setTransferData((T) transferDataBuilder.build())
+        .setTransferData(transferDataBuilder.build())
         .setLastTransferTime(transferData.getPendingTransferExpirationTime())
         .setPersistedCurrentSponsorRegistrarId(transferData.getGainingRegistrarId());
   }
 
   /**
-   * Perform common operations for projecting an {@link EppResource} at a given time:
+   * Perform common operations for projecting a {@link Domain} at a given time:
    *
    * <ul>
    *   <li>Process an automatic transfer.
    * </ul>
    */
-  public static <
-          T extends TransferData,
-          E extends EppResource & ResourceWithTransferData<T>,
-          B extends EppResource.Builder<?, B> & BuilderWithTransferData<T, B>>
-      void projectResourceOntoBuilderAtTime(E resource, B builder, DateTime now) {
-    T transferData = resource.getTransferData();
+  public static void projectResourceOntoBuilderAtTime(
+      DomainBase domain, DomainBase.Builder<?, ?> builder, DateTime now) {
+    DomainTransferData transferData = domain.getTransferData();
     // If there's a pending transfer that has expired, process it.
     DateTime expirationTime = transferData.getPendingTransferExpirationTime();
     if (TransferStatus.PENDING.equals(transferData.getTransferStatus())
@@ -207,36 +189,21 @@ private static <T extends EppResource> T loadMostRecentRevisionAtTime(
   }
 
   /**
-   * Returns a set of {@link VKey} for domains that reference a specified contact or host.
-   *
-   * <p>This is an eventually consistent query if used for the database.
+   * Returns a set of {@link VKey} for domains that reference a specified host.
    *
    * @param key the referent key
    * @param now the logical time of the check
    * @param limit the maximum number of returned keys, unlimited if null
    */
   public static ImmutableSet<VKey<Domain>> getLinkedDomainKeys(
-      VKey<? extends EppResource> key, DateTime now, @Nullable Integer limit) {
-    checkArgument(
-        key.getKind().equals(Contact.class) || key.getKind().equals(Host.class),
-        "key must be either VKey<Contact> or VKey<Host>, but it is %s",
-        key);
-    boolean isContactKey = key.getKind().equals(Contact.class);
+      VKey<Host> key, DateTime now, @Nullable Integer limit) {
     return tm().reTransact(
             () -> {
-              Query query;
-              if (isContactKey) {
-                query =
-                    tm().query(CONTACT_LINKED_DOMAIN_QUERY, String.class)
-                        .setParameter("fkRepoId", key)
-                        .setParameter("now", now);
-              } else {
-                query =
-                    tm().getEntityManager()
-                        .createNativeQuery(HOST_LINKED_DOMAIN_QUERY)
-                        .setParameter("fkRepoId", key.getKey())
-                        .setParameter("now", now.toDate());
-              }
+              Query query =
+                  tm().getEntityManager()
+                      .createNativeQuery(HOST_LINKED_DOMAIN_QUERY)
+                      .setParameter("fkRepoId", key.getKey())
+                      .setParameter("now", now.toDate());
               if (limit != null) {
                 query.setMaxResults(limit);
               }
@@ -252,12 +219,12 @@ public static ImmutableSet<VKey<Domain>> getLinkedDomainKeys(
   }
 
   /**
-   * Returns whether the given contact or host is linked to (that is, referenced by) a domain.
+   * Returns whether the given host is linked to (that is, referenced by) a domain.
    *
    * @param key the referent key
    * @param now the logical time of the check
    */
-  public static boolean isLinked(VKey<? extends EppResource> key, DateTime now) {
+  public static boolean isLinked(VKey<Host> key, DateTime now) {
     return !getLinkedDomainKeys(key, now, 1).isEmpty();
   }