/*
Copyright (c) 2012 LinkedIn Corp.
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 com.linkedin.restli.docgen;
import com.linkedin.data.Data;
import com.linkedin.data.DataMap;
import com.linkedin.data.codec.JacksonDataCodec;
import com.linkedin.data.schema.NamedDataSchema;
import com.linkedin.restli.common.RestConstants;
import com.linkedin.restli.internal.server.RestLiInternalException;
import com.linkedin.restli.restspec.ResourceSchema;
import com.linkedin.restli.server.RoutingException;
import java.io.IOException;
import java.io.OutputStream;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
/**
* Renders JSON representation of resources and data models. When rendering for resource, all subresources
* and related data models accessible are also returned. When rendering for data model, only the model itself
* is returned.
*
* @author Keren Jin
*/
public class RestLiJSONDocumentationRenderer implements RestLiDocumentationRenderer
{
/**
* @param relationships relationship of all the resources and data models to be rendered
*/
public RestLiJSONDocumentationRenderer(RestLiResourceRelationship relationships)
{
_relationships = relationships;
}
@Override
public void renderHome(OutputStream out)
{
renderResourceHome(out);
}
@Override
public void renderResourceHome(OutputStream out)
{
final DataMap outputMap = createEmptyOutput();
try
{
for (ResourceSchema resourceSchema:
new HashSet<ResourceSchema>(_relationships.getResourceSchemaCollection().getResources().values()))
{
renderResource(resourceSchema, outputMap);
}
_codec.writeMap(outputMap, out);
}
catch (IOException e)
{
throw new RestLiInternalException(e);
}
}
@Override
public void renderResource(String resourceName, OutputStream out)
{
final ResourceSchema resourceSchema = _relationships.getResourceSchemaCollection().getResource(resourceName);
if (resourceSchema == null)
{
throw new RoutingException(String.format("Resource named '%s' does not exist", resourceName), 404) ;
}
final DataMap outputMap = createEmptyOutput();
try
{
renderResource(resourceSchema, outputMap);
_codec.writeMap(outputMap, out);
}
catch (IOException e)
{
throw new RestLiInternalException(e);
}
}
@Override
public void renderDataModelHome(OutputStream out)
{
final DataMap outputMap = createEmptyOutput();
try
{
for (NamedDataSchema schema: new HashSet<NamedDataSchema>(_relationships.getDataModels().values()))
{
renderDataModel(schema, outputMap);
}
_codec.writeMap(outputMap, out);
}
catch (IOException e)
{
throw new RestLiInternalException(e);
}
}
@Override
public void renderDataModel(String dataModelName, OutputStream out)
{
final NamedDataSchema schema = _relationships.getDataModels().get(dataModelName);
if (schema == null)
{
throw new RoutingException(String.format("Data model named '%s' does not exist", dataModelName), 404) ;
}
final DataMap outputMap = createEmptyOutput();
try
{
renderDataModel(schema, outputMap);
_codec.writeMap(outputMap, out);
}
catch (IOException e)
{
throw new RestLiInternalException(e);
}
}
@Override
public boolean handleException(RuntimeException e, OutputStream out)
{
return false;
}
@Override
public String getMIMEType()
{
return RestConstants.HEADER_VALUE_APPLICATION_JSON;
}
private DataMap createEmptyOutput()
{
final DataMap emptyOutputMap = new DataMap();
emptyOutputMap.put("resources", new DataMap());
emptyOutputMap.put("models", new DataMap());
return emptyOutputMap;
}
private void addRelatedModels(ResourceSchema resourceSchema, DataMap models) throws IOException
{
Map<String, DataMap> relatedSchemas;
synchronized (this)
{
relatedSchemas = _relatedSchemaCache.get(resourceSchema);
if (relatedSchemas == null)
{
relatedSchemas = new HashMap<String, DataMap>();
final Node<?> node = _relationships.getRelationships(resourceSchema);
final Iterator<Node<NamedDataSchema>> schemaItr = node.getAdjacency(NamedDataSchema.class).iterator();
while (schemaItr.hasNext())
{
final NamedDataSchema currResource = (NamedDataSchema) schemaItr.next().getObject();
relatedSchemas.put(currResource.getFullName(), _codec.stringToMap(currResource.toString()));
}
_relatedSchemaCache.put(resourceSchema, relatedSchemas);
}
}
models.putAll(relatedSchemas);
}
private void renderResource(ResourceSchema resourceSchema, DataMap outputMap) throws IOException
{
final DataMap resources = outputMap.getDataMap("resources");
final DataMap models = outputMap.getDataMap("models");
resources.put(ResourceSchemaUtil.getFullName(resourceSchema), resourceSchema.data());
addRelatedModels(resourceSchema, models);
final List<ResourceSchema> subresources = _relationships.getResourceSchemaCollection().getAllSubResources(
resourceSchema);
if (subresources != null)
{
for (ResourceSchema subresource: subresources)
{
resources.put(ResourceSchemaUtil.getFullName(subresource), subresource.data());
addRelatedModels(subresource, models);
}
}
}
private void renderDataModel(NamedDataSchema schema, DataMap outputMap) throws IOException
{
final DataMap models = outputMap.getDataMap("models");
final DataMap schemaData = _codec.stringToMap(schema.toString());
models.put(schema.getFullName(), schemaData);
}
private final RestLiResourceRelationship _relationships;
private final JacksonDataCodec _codec = new JacksonDataCodec();
private final Map<ResourceSchema, Map<String, DataMap>> _relatedSchemaCache =
new HashMap<ResourceSchema, Map<String, DataMap>>();
}