How to use org.cedj.geekseek.web.rest.core

  @Override
  public ResourceMetadata getResourceMetadata() {
    return new ResourceMetadata(Session.class)
      .incoming(new Relation("presented_by"))
      .outgoing(new NamedRelation("attachments", "attached_to"))
      .outgoing(new NamedRelation("speakers", "presented_by"))
      .outgoing(new NamedRelation("attendees", "attended_by"))
      .outgoing(new NamedRelation("locations", "located_in"));
  }
}

@Override
public ResourceMetadata getResourceMetadata() {
  return new ResourceMetadata(Conference.class)
    .outgoing(new NamedRelation("attachments", "attached_to"))
    .outgoing(new NamedRelation("trackers", "tracked_by"))
    .outgoing(new NamedRelation("attendees", "attended_by"))
    .outgoing(new NamedRelation("locations", "located_at"));
}

  @Override
  public ResourceMetadata getResourceMetadata() {
    return new ResourceMetadata(Attachment.class)
      .incoming(new Relation("attached_to"));
  }
}

private ResourceLink generateResourceLink(Resource source, String id, UriInfo uriInfo) {
  UriBuilder builder = uriInfo.getBaseUriBuilder();
  URI uri = builder.path(BookmarkResource.class)
    .path(getResourceTypeName(source))
    .path(id)
    .build();
  return new ResourceLink("bookmark", uri, source.getResourceMediaType());
}

public void addLink(ResourceLink link) {
  getLinks().add(link);
}

public Collection<NamedRelation> match(ResourceMetadata source) {
  List<NamedRelation> relations = new ArrayList<NamedRelation>();
  for(NamedRelation sourceRel : source.outgoing) {
    for(Relation targetRel : this.incoming) {
      if(targetRel.getType().equals(sourceRel.getType())) {
        relations.add(sourceRel);
      }
    }
  }
  return relations;
}

private String getMediaType() {
  return matchMediaType(getMediaTypes()[0], getMediaTypes()[1]);
}

@PostConstruct
public void initialize() {
  for(MetadataResource resource : resources) {
    ResourceMetadata meta = resource.getResourceMetadata();
    this.metadata.put(meta.getModel(), meta);
  }
}

private Resource getResource(LinkableRepresentation<?> representation) {
  for(Resource resource: resources) {
    if(representation.getRepresentationType().equals(getResourceTypeName(resource))) {
      return resource;
    }
  }
  return null;
}

@PATCH
public Response patch() {
  return Response.ok().build();
}

  private String getResourceTypeName(Resource resource) {
    MediaType mediaType = MediaType.valueOf(resource.getResourceMediaType());
    return mediaType.getParameters().get("type");
  }
}

  private void link(LinkableRepresentation<?> linkable) {
    for(LinkProvider linker : linkProviers) {
      linker.appendLinks(linkable);
    }
  }
}

public boolean doesNotContainRel(String rel) {
  return !containRel(rel);
}

public boolean containRel(String rel) {
  if(links == null || links.size() == 0) {
    return false;
  }
  for(ResourceLink link : links) {
    if(rel.equals(link.getRel())) {
      return true;
    }
  }
  return false;
}

@Override
public Collection<REST> from(UriInfo uriInfo, Collection<SOURCE> ins) {
  Collection<REST> out = new ArrayList<REST>();
  for(SOURCE in : ins) {
    out.add(from(uriInfo, in));
  }
  return out;
}

  @Override
  public Collection<SOURCE> to(UriInfo uriInfo, Collection<REST> ins) {
    Collection<SOURCE> out = new ArrayList<SOURCE>();
    for(REST in : ins) {
      out.add(to(uriInfo, in));
    }
    return out;
  }
}

  @Override
  public ResourceMetadata getResourceMetadata() {
    return new ResourceMetadata(User.class)
      .incoming(new Relation("presented_by"))
      .incoming(new Relation("tracked_by"))
      .incoming(new Relation("attended_by"))
      .outgoing(new NamedRelation("attachments", "attached_to"))
      .outgoing(new NamedRelation("sessions", "presented_by"));
  }
}

@Override
public ResourceMetadata getResourceMetadata() {
  return new ResourceMetadata(TargetObject.class)
    .incoming(new Relation("connected_to"));
}

@Override
public ResourceMetadata getResourceMetadata() {
  return new ResourceMetadata(SourceObject.class)
    .outgoing(new NamedRelation("connections", "connected_to"))
    .outgoing(new NamedRelation("notdeployed", "no_matching_relation"));
}

  private Resource locateResource(String type) {
    for(Resource resource : resources) {
      MediaType media = MediaType.valueOf(resource.getResourceMediaType());
      if(type.equalsIgnoreCase(media.getParameters().get("type"))) {
        return resource;
      }
    }
    return null;
  }
}