google-nomulus/java/google/registry/rdap/RdapEntityAction.java

// Copyright 2017 The Nomulus Authors. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

package google.registry.rdap;

import static google.registry.model.ofy.ObjectifyService.ofy;
import static google.registry.rdap.RdapUtils.getRegistrarByIanaIdentifier;
import static google.registry.request.Action.Method.GET;
import static google.registry.request.Action.Method.HEAD;

import com.google.common.collect.ImmutableMap;
import com.google.common.primitives.Longs;
import com.google.re2j.Pattern;
import com.googlecode.objectify.Key;
import google.registry.model.contact.ContactResource;
import google.registry.model.registrar.Registrar;
import google.registry.rdap.RdapJsonFormatter.OutputDataType;
import google.registry.rdap.RdapMetrics.EndpointType;
import google.registry.request.Action;
import google.registry.request.HttpException.BadRequestException;
import google.registry.request.HttpException.NotFoundException;
import google.registry.request.auth.Auth;
import java.util.Optional;
import javax.inject.Inject;
import org.joda.time.DateTime;

/**
 * RDAP (new WHOIS) action for entity (contact and registrar) requests. the ICANN operational
 * profile dictates that the "handle" for registrars is to be the IANA registrar ID:
 *
 * <p>2.8.3. Registries MUST support lookup for entities with the registrar role within other
 * objects using the handle (as described in 3.1.5 of RFC7482). The handle of the entity with the
 * registrar role MUST be equal to IANA Registrar ID. The entity with the registrar role in the RDAP
 * response MUST contain a publicIDs member to identify the IANA Registrar ID from the IANA’s
 * Registrar ID registry. The type value of the publicID object MUST be equal to IANA Registrar ID.
 */
@Action(
    service = Action.Service.PUBAPI,
    path = RdapEntityAction.PATH,
    method = {GET, HEAD},
    isPrefix = true,
    auth = Auth.AUTH_PUBLIC)
public class RdapEntityAction extends RdapActionBase {

  public static final String PATH = "/rdap/entity/";

  private static final Pattern ROID_PATTERN = Pattern.compile("[-_.a-zA-Z0-9]+");

  @Inject public RdapEntityAction() {}

  @Override
  public String getHumanReadableObjectTypeName() {
    return "entity";
  }

  @Override
  public EndpointType getEndpointType() {
    return EndpointType.ENTITY;
  }

  @Override
  public String getActionPath() {
    return PATH;
  }

  @Override
  public ImmutableMap<String, Object> getJsonObjectForResource(
      String pathSearchString, boolean isHeadRequest) {
    DateTime now = clock.nowUtc();
    // The query string is not used; the RDAP syntax is /rdap/entity/handle (the handle is the roid
    // for contacts and the client identifier for registrars). Since RDAP's concept of an entity
    // includes both contacts and registrars, search for one first, then the other.
    boolean wasValidKey = false;
    if (ROID_PATTERN.matcher(pathSearchString).matches()) {
      wasValidKey = true;
      Key<ContactResource> contactKey = Key.create(ContactResource.class, pathSearchString);
      ContactResource contactResource = ofy().load().key(contactKey).now();
      // As per Andy Newton on the regext mailing list, contacts by themselves have no role, since
      // they are global, and might have different roles for different domains.
      if ((contactResource != null) && shouldBeVisible(contactResource, now)) {
        return rdapJsonFormatter.makeRdapJsonForContact(
            contactResource,
            true,
            Optional.empty(),
            fullServletPath,
            rdapWhoisServer,
            now,
            OutputDataType.FULL,
            getAuthorization());
      }
    }
    Long ianaIdentifier = Longs.tryParse(pathSearchString);
    if (ianaIdentifier != null) {
      wasValidKey = true;
      Optional<Registrar> registrar = getRegistrarByIanaIdentifier(ianaIdentifier);
      if (registrar.isPresent() && shouldBeVisible(registrar.get())) {
        return rdapJsonFormatter.makeRdapJsonForRegistrar(
            registrar.get(), true, fullServletPath, rdapWhoisServer, now, OutputDataType.FULL);
      }
    }
    // At this point, we have failed to find either a contact or a registrar.
    throw wasValidKey
        ? new NotFoundException(pathSearchString + " not found")
        : new BadRequestException(pathSearchString + " is not a valid entity handle");
  }
}