mirror of
https://github.com/google/nomulus.git
synced 2025-05-02 04:57:51 +02:00
c458c05801
The dark lord Gosling designed the Java package naming system so that ownership flows from the DNS system. Since we own the domain name registry.google, it seems only appropriate that we should use google.registry as our package name.
104 lines
3.7 KiB
Java
104 lines
3.7 KiB
Java
// Copyright 2016 The Domain Registry 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.model.domain;
|
|
|
|
import com.googlecode.objectify.Ref;
|
|
import com.googlecode.objectify.annotation.Embed;
|
|
import com.googlecode.objectify.annotation.Ignore;
|
|
import com.googlecode.objectify.annotation.Index;
|
|
|
|
import google.registry.model.EppResource;
|
|
import google.registry.model.ImmutableObject;
|
|
import google.registry.model.contact.ContactResource;
|
|
import google.registry.model.host.HostResource;
|
|
|
|
import java.io.Serializable;
|
|
|
|
import javax.xml.bind.annotation.adapters.XmlAdapter;
|
|
|
|
/**
|
|
* A "union" type to represent referenced objects as either a foreign key or as a link to another
|
|
* object in the datastore.
|
|
* <p>
|
|
* This type always marshals as the "foreign key". When it is explicitly storing a foreign key it
|
|
* gets the value from its own string field. When it is linked to another object, it gets the value
|
|
* from the other object.
|
|
* <p>
|
|
* When a {@link ReferenceUnion} comes in from Epp, either in an update or a delete, it fills in the
|
|
* "foreign key" string field, but as soon as the relevant Flow runs it deletes that field and
|
|
* replaces it with a linked {@link Ref} to the object named by that string. We can't do this in a
|
|
* {@code XmlJavaTypeAdapter} because failing a lookup is a business logic error, not a failure to
|
|
* parse the XML.
|
|
*
|
|
* @param <T> the type being referenced
|
|
*/
|
|
@Embed
|
|
public class ReferenceUnion<T extends EppResource> extends ImmutableObject implements Serializable {
|
|
|
|
@Index
|
|
Ref<T> linked;
|
|
|
|
/** This is never persisted, and only ever populated to marshal or unmarshal to or from XML. */
|
|
@Ignore
|
|
String foreignKey;
|
|
|
|
public Ref<T> getLinked() {
|
|
return linked;
|
|
}
|
|
|
|
public String getForeignKey() {
|
|
return foreignKey;
|
|
}
|
|
|
|
/** An adapter that is aware of the union inside {@link ReferenceUnion}. */
|
|
public static class Adapter<T extends EppResource>
|
|
extends XmlAdapter<String, ReferenceUnion<T>> {
|
|
|
|
@Override
|
|
public ReferenceUnion<T> unmarshal(String foreignKey) throws Exception {
|
|
return ReferenceUnion.<T>create(foreignKey);
|
|
}
|
|
|
|
@Override
|
|
public String marshal(ReferenceUnion<T> reference) throws Exception {
|
|
return reference.getForeignKey() == null
|
|
? reference.getLinked().get().getForeignKey()
|
|
: reference.getForeignKey();
|
|
}
|
|
}
|
|
|
|
/** An adapter for references to contacts. */
|
|
static class ContactReferenceUnionAdapter extends ReferenceUnion.Adapter<ContactResource>{}
|
|
|
|
/** An adapter for references to hosts. */
|
|
static class HostReferenceUnionAdapter extends ReferenceUnion.Adapter<HostResource>{}
|
|
|
|
public static <T extends EppResource> ReferenceUnion<T> create(String foreignKey) {
|
|
ReferenceUnion<T> instance = new ReferenceUnion<>();
|
|
instance.foreignKey = foreignKey;
|
|
return instance;
|
|
}
|
|
|
|
public static <T extends EppResource> ReferenceUnion<T> create(Ref<T> linked) {
|
|
ReferenceUnion<T> instance = new ReferenceUnion<>();
|
|
instance.linked = linked;
|
|
return instance;
|
|
}
|
|
|
|
/** Convenience method. */
|
|
public static <T extends EppResource> ReferenceUnion<T> create(T resource) {
|
|
return create(Ref.create(resource));
|
|
}
|
|
}
|