use of com.linkedin.restli.restspec.ActionsSetSchema in project rest.li by linkedin.
the class RequestBuilderSpecGenerator method generateRootRequestBuilder.
private RootBuilderSpec generateRootRequestBuilder(RootBuilderSpec parentRootBuilder, ResourceSchema resource, String sourceFile, Map<String, String> pathKeyTypes) throws IOException {
ValidationResult validationResult = ValidateDataAgainstSchema.validate(resource.data(), resource.schema(), new ValidationOptions(RequiredMode.MUST_BE_PRESENT));
if (!validationResult.isValid()) {
throw new IllegalArgumentException(String.format("Resource validation error. Resource File '%s', Error Details '%s'", sourceFile, validationResult.toString()));
}
String packageName = resource.getNamespace();
String resourceName = CodeUtil.capitalize(resource.getName());
String className;
if (_version == RestliVersion.RESTLI_2_0_0) {
className = getBuilderClassNameByVersion(RestliVersion.RESTLI_2_0_0, null, resource.getName(), true);
} else {
className = getBuilderClassNameByVersion(RestliVersion.RESTLI_1_0_0, null, resource.getName(), true);
}
RootBuilderSpec rootBuilderSpec = null;
if (resource.hasCollection()) {
rootBuilderSpec = new CollectionRootBuilderSpec(resource);
} else if (resource.hasSimple()) {
rootBuilderSpec = new SimpleRootBuilderSpec(resource);
} else if (resource.hasActionsSet()) {
rootBuilderSpec = new ActionSetRootBuilderSpec(resource);
} else {
throw new IllegalArgumentException("unsupported resource type for resource: '" + resourceName + '\'');
}
rootBuilderSpec.setNamespace(packageName);
rootBuilderSpec.setClassName(className);
if (_version == RestliVersion.RESTLI_2_0_0) {
rootBuilderSpec.setBaseClassName("BuilderBase");
}
rootBuilderSpec.setSourceIdlName(sourceFile);
String resourcePath = getResourcePath(resource.getPath());
rootBuilderSpec.setResourcePath(resourcePath);
List<String> pathKeys = getPathKeys(resourcePath);
rootBuilderSpec.setPathKeys(pathKeys);
rootBuilderSpec.setParentRootBuilder(parentRootBuilder);
StringArray supportsList = null;
RestMethodSchemaArray restMethods = null;
FinderSchemaArray finders = null;
ResourceSchemaArray subresources = null;
ActionSchemaArray resourceActions = null;
ActionSchemaArray entityActions = null;
String keyClass = null;
if (resource.getCollection() != null) {
CollectionSchema collection = resource.getCollection();
String keyName = collection.getIdentifier().getName();
// Complex key is not supported
keyClass = collection.getIdentifier().getType();
pathKeyTypes.put(keyName, collection.getIdentifier().getType());
supportsList = collection.getSupports();
restMethods = collection.getMethods();
finders = collection.getFinders();
subresources = collection.getEntity().getSubresources();
resourceActions = collection.getActions();
entityActions = collection.getEntity().getActions();
} else if (resource.getSimple() != null) {
SimpleSchema simpleSchema = resource.getSimple();
keyClass = "Void";
supportsList = simpleSchema.getSupports();
restMethods = simpleSchema.getMethods();
subresources = simpleSchema.getEntity().getSubresources();
resourceActions = simpleSchema.getActions();
} else if (resource.getActionsSet() != null) {
ActionsSetSchema actionsSet = resource.getActionsSet();
resourceActions = actionsSet.getActions();
}
Set<ResourceMethod> supportedMethods = getSupportedMethods(supportsList);
if (!supportedMethods.isEmpty()) {
for (ResourceMethod resourceMethod : supportedMethods) {
validateResourceMethod(resource, resourceName, resourceMethod);
}
}
List<RootBuilderMethodSpec> restMethodSpecs = new ArrayList<RootBuilderMethodSpec>();
List<RootBuilderMethodSpec> finderSpecs = new ArrayList<RootBuilderMethodSpec>();
List<RootBuilderMethodSpec> resourceActionSpecs = new ArrayList<RootBuilderMethodSpec>();
List<RootBuilderMethodSpec> entityActionSpecs = new ArrayList<RootBuilderMethodSpec>();
List<RootBuilderSpec> subresourceSpecs = new ArrayList<RootBuilderSpec>();
String schemaClass = resource.getSchema();
if (restMethods != null) {
restMethodSpecs = generateBasicMethods(rootBuilderSpec, keyClass, schemaClass, supportedMethods, restMethods, resourceName, pathKeys, pathKeyTypes);
}
if (finders != null) {
finderSpecs = generateFinders(rootBuilderSpec, finders, keyClass, schemaClass, resourceName, pathKeys, pathKeyTypes);
}
if (resourceActions != null) {
resourceActionSpecs = generateActions(rootBuilderSpec, resourceActions, keyClass, resourceName, pathKeys, pathKeyTypes);
}
if (entityActions != null) {
entityActionSpecs = generateActions(rootBuilderSpec, entityActions, keyClass, resourceName, pathKeys, pathKeyTypes);
}
if (subresources != null) {
subresourceSpecs = generateSubResources(sourceFile, rootBuilderSpec, subresources, pathKeyTypes);
}
// assign to rootBuilderClass
if (rootBuilderSpec instanceof CollectionRootBuilderSpec) {
CollectionRootBuilderSpec rootBuilder = (CollectionRootBuilderSpec) rootBuilderSpec;
rootBuilder.setRestMethods(restMethodSpecs);
rootBuilder.setFinders(finderSpecs);
rootBuilder.setResourceActions(resourceActionSpecs);
rootBuilder.setEntityActions(entityActionSpecs);
rootBuilder.setSubresources(subresourceSpecs);
} else if (rootBuilderSpec instanceof SimpleRootBuilderSpec) {
SimpleRootBuilderSpec rootBuilder = (SimpleRootBuilderSpec) rootBuilderSpec;
rootBuilder.setRestMethods(restMethodSpecs);
rootBuilder.setResourceActions(resourceActionSpecs);
rootBuilder.setSubresources(subresourceSpecs);
} else if (rootBuilderSpec instanceof ActionSetRootBuilderSpec) {
ActionSetRootBuilderSpec rootBuilder = (ActionSetRootBuilderSpec) rootBuilderSpec;
rootBuilder.setResourceActions(resourceActionSpecs);
}
registerBuilderSpec(rootBuilderSpec);
return rootBuilderSpec;
}
use of com.linkedin.restli.restspec.ActionsSetSchema in project rest.li by linkedin.
the class ResourceModelEncoder method appendActionsModel.
private void appendActionsModel(final ResourceSchema resourceSchema, final ResourceModel resourceModel) {
appendCommon(resourceModel, resourceSchema);
ActionsSetSchema actionsNode = new ActionsSetSchema();
ActionSchemaArray actions = createActions(resourceModel, ResourceLevel.COLLECTION);
if (actions.size() > 0) {
actionsNode.setActions(actions);
}
resourceSchema.setActionsSet(actionsNode);
}
use of com.linkedin.restli.restspec.ActionsSetSchema in project rest.li by linkedin.
the class JavaRequestBuilderGenerator method generateResourceFacade.
private JDefinedClass generateResourceFacade(ResourceSchema resource, File sourceFile, Map<String, JClass> pathKeyTypes, Map<String, JClass> assocKeyTypes, Map<String, List<String>> pathToAssocKeys) throws JClassAlreadyExistsException, IOException {
final ValidationResult validationResult = ValidateDataAgainstSchema.validate(resource.data(), resource.schema(), new ValidationOptions(RequiredMode.MUST_BE_PRESENT));
if (!validationResult.isValid()) {
throw new IllegalArgumentException(String.format("Resource validation error. Resource File '%s', Error Details '%s'", sourceFile, validationResult.toString()));
}
final String packageName = resource.getNamespace();
final JPackage clientPackage = (packageName == null || packageName.isEmpty()) ? getPackage() : getPackage(packageName);
final String className;
if (_version == RestliVersion.RESTLI_2_0_0) {
className = getBuilderClassNameByVersion(RestliVersion.RESTLI_2_0_0, null, resource.getName(), true);
} else {
className = getBuilderClassNameByVersion(RestliVersion.RESTLI_1_0_0, null, resource.getName(), true);
}
final JDefinedClass facadeClass = clientPackage._class(className);
annotate(facadeClass, sourceFile.getAbsolutePath());
final JFieldVar baseUriField;
final JFieldVar requestOptionsField;
final JExpression baseUriGetter = JExpr.invoke("getBaseUriTemplate");
final JExpression requestOptionsGetter = JExpr.invoke("getRequestOptions");
if (_version == RestliVersion.RESTLI_2_0_0) {
baseUriField = null;
requestOptionsField = null;
facadeClass._extends(BuilderBase.class);
} else {
// for old builder, instead of extending from RequestBuilderBase, add fields and getters in the class
baseUriField = facadeClass.field(JMod.PRIVATE | JMod.FINAL, String.class, "_baseUriTemplate");
requestOptionsField = facadeClass.field(JMod.PRIVATE, RestliRequestOptions.class, "_requestOptions");
facadeClass.method(JMod.PRIVATE, String.class, "getBaseUriTemplate").body()._return(baseUriField);
facadeClass.method(JMod.PUBLIC, RestliRequestOptions.class, "getRequestOptions").body()._return(requestOptionsField);
}
// make the original resource path available via a private final static variable.
final JFieldVar originalResourceField = facadeClass.field(JMod.PRIVATE | JMod.STATIC | JMod.FINAL, String.class, "ORIGINAL_RESOURCE_PATH");
final String resourcePath = getResourcePath(resource.getPath());
originalResourceField.init(JExpr.lit(resourcePath));
// create reference to RestliRequestOptions.DEFAULT_OPTIONS
final JClass restliRequestOptionsClass = getCodeModel().ref(RestliRequestOptions.class);
final JFieldRef defaultOptionsField = restliRequestOptionsClass.staticRef("DEFAULT_OPTIONS");
if (_version == RestliVersion.RESTLI_1_0_0) {
// same getPathComponents() logic as in RequestBuilderBase
final JMethod pathComponentsGetter = facadeClass.method(JMod.PUBLIC, String[].class, "getPathComponents");
pathComponentsGetter.body()._return(getCodeModel().ref(URIParamUtils.class).staticInvoke("extractPathComponentsFromUriTemplate").arg(baseUriField));
// method that expresses the following logic
// (requestOptions == null) ? return RestliRequestOptions.DEFAULT_OPTIONS : requestOptions;
final JMethod requestOptionsAssigner = facadeClass.method(JMod.PRIVATE | JMod.STATIC, RestliRequestOptions.class, "assignRequestOptions");
final JVar requestOptionsAssignerParam = requestOptionsAssigner.param(RestliRequestOptions.class, "requestOptions");
final JConditional requestNullCheck = requestOptionsAssigner.body()._if(requestOptionsAssignerParam.eq(JExpr._null()));
requestNullCheck._then().block()._return(defaultOptionsField);
requestNullCheck._else().block()._return(requestOptionsAssignerParam);
}
/*
There will be 4 constructors:
()
(RestliRequestOptions)
(String)
(String, RestliRequestOptions)
*/
final JMethod noArgConstructor = facadeClass.constructor(JMod.PUBLIC);
final JMethod requestOptionsOverrideConstructor = facadeClass.constructor(JMod.PUBLIC);
final JMethod resourceNameOverrideConstructor = facadeClass.constructor(JMod.PUBLIC);
final JMethod mainConstructor = facadeClass.constructor(JMod.PUBLIC);
// no-argument constructor, delegates to the request options override constructor
noArgConstructor.body().invoke(THIS).arg(defaultOptionsField);
// request options override constructor
final JVar requestOptionsOverrideOptionsParam = requestOptionsOverrideConstructor.param(RestliRequestOptions.class, "requestOptions");
if (_version == RestliVersion.RESTLI_2_0_0) {
requestOptionsOverrideConstructor.body().invoke(SUPER).arg(originalResourceField).arg(requestOptionsOverrideOptionsParam);
} else {
requestOptionsOverrideConstructor.body().assign(baseUriField, originalResourceField);
final JInvocation requestOptionsOverrideAssignRequestOptions = new JBlock().invoke("assignRequestOptions").arg(requestOptionsOverrideOptionsParam);
requestOptionsOverrideConstructor.body().assign(requestOptionsField, requestOptionsOverrideAssignRequestOptions);
}
// primary resource name override constructor, delegates to the main constructor
final JVar resourceNameOverrideResourceNameParam = resourceNameOverrideConstructor.param(_stringClass, "primaryResourceName");
resourceNameOverrideConstructor.body().invoke(THIS).arg(resourceNameOverrideResourceNameParam).arg(defaultOptionsField);
// main constructor
final JVar mainConsResourceNameParam = mainConstructor.param(_stringClass, "primaryResourceName");
final JVar mainConsOptionsParam = mainConstructor.param(RestliRequestOptions.class, "requestOptions");
final JExpression baseUriExpr;
if (resourcePath.contains("/")) {
baseUriExpr = originalResourceField.invoke("replaceFirst").arg(JExpr.lit("[^/]*/")).arg(mainConsResourceNameParam.plus(JExpr.lit("/")));
} else {
baseUriExpr = mainConsResourceNameParam;
}
if (_version == RestliVersion.RESTLI_2_0_0) {
mainConstructor.body().invoke(SUPER).arg(baseUriExpr).arg(mainConsOptionsParam);
} else {
final JInvocation mainAssignRequestOptions = new JBlock().invoke("assignRequestOptions").arg(mainConsOptionsParam);
mainConstructor.body().assign(baseUriField, baseUriExpr);
mainConstructor.body().assign(requestOptionsField, mainAssignRequestOptions);
}
final String resourceName = CodeUtil.capitalize(resource.getName());
final JMethod primaryResourceGetter = facadeClass.method(JMod.PUBLIC | JMod.STATIC, String.class, "getPrimaryResource");
primaryResourceGetter.body()._return(originalResourceField);
final List<String> pathKeys = getPathKeys(resourcePath, pathToAssocKeys);
JClass keyTyperefClass = null;
final JClass keyClass;
JClass keyKeyClass = null;
JClass keyParamsClass = null;
final Class<?> resourceSchemaClass;
Map<String, AssocKeyTypeInfo> assocKeyTypeInfos = Collections.emptyMap();
StringArray supportsList = null;
RestMethodSchemaArray restMethods = null;
FinderSchemaArray finders = null;
ResourceSchemaArray subresources = null;
ActionSchemaArray resourceActions = null;
ActionSchemaArray entityActions = null;
if (resource.getCollection() != null) {
resourceSchemaClass = CollectionSchema.class;
final CollectionSchema collection = resource.getCollection();
final String keyName = collection.getIdentifier().getName();
// ComplexKeyResource parameterized by those two.
if (collection.getIdentifier().getParams() == null) {
keyClass = getJavaBindingType(collection.getIdentifier().getType(), facadeClass).valueClass;
final JClass declaredClass = getClassRefForSchema(RestSpecCodec.textToSchema(collection.getIdentifier().getType(), _schemaResolver), facadeClass);
if (!declaredClass.equals(keyClass)) {
keyTyperefClass = declaredClass;
}
} else {
keyKeyClass = getJavaBindingType(collection.getIdentifier().getType(), facadeClass).valueClass;
keyParamsClass = getJavaBindingType(collection.getIdentifier().getParams(), facadeClass).valueClass;
keyClass = getCodeModel().ref(ComplexResourceKey.class).narrow(keyKeyClass, keyParamsClass);
}
pathKeyTypes.put(keyName, keyClass);
supportsList = collection.getSupports();
restMethods = collection.getMethods();
finders = collection.getFinders();
subresources = collection.getEntity().getSubresources();
resourceActions = collection.getActions();
entityActions = collection.getEntity().getActions();
} else if (resource.getAssociation() != null) {
resourceSchemaClass = AssociationSchema.class;
final AssociationSchema association = resource.getAssociation();
keyClass = getCodeModel().ref(CompoundKey.class);
supportsList = association.getSupports();
restMethods = association.getMethods();
finders = association.getFinders();
subresources = association.getEntity().getSubresources();
resourceActions = association.getActions();
entityActions = association.getEntity().getActions();
assocKeyTypeInfos = generateAssociationKey(facadeClass, association);
final String keyName = getAssociationKey(resource, association);
pathKeyTypes.put(keyName, keyClass);
final List<String> assocKeys = new ArrayList<String>(4);
for (Map.Entry<String, AssocKeyTypeInfo> entry : assocKeyTypeInfos.entrySet()) {
assocKeys.add(entry.getKey());
assocKeyTypes.put(entry.getKey(), entry.getValue().getBindingType());
}
pathToAssocKeys.put(keyName, assocKeys);
} else if (resource.getSimple() != null) {
resourceSchemaClass = SimpleSchema.class;
final SimpleSchema simpleSchema = resource.getSimple();
keyClass = _voidClass;
supportsList = simpleSchema.getSupports();
restMethods = simpleSchema.getMethods();
subresources = simpleSchema.getEntity().getSubresources();
resourceActions = simpleSchema.getActions();
} else if (resource.getActionsSet() != null) {
resourceSchemaClass = ActionsSetSchema.class;
final ActionsSetSchema actionsSet = resource.getActionsSet();
resourceActions = actionsSet.getActions();
keyClass = _voidClass;
} else {
throw new IllegalArgumentException("unsupported resource type for resource: '" + resourceName + '\'');
}
generateOptions(facadeClass, baseUriGetter, requestOptionsGetter);
final JFieldVar resourceSpecField = facadeClass.field(JMod.PRIVATE | JMod.STATIC | JMod.FINAL, _resourceSpecClass, "_resourceSpec");
if (resourceSchemaClass == CollectionSchema.class || resourceSchemaClass == AssociationSchema.class || resourceSchemaClass == SimpleSchema.class) {
final JClass schemaClass = getJavaBindingType(resource.getSchema(), null).schemaClass;
final Set<ResourceMethod> supportedMethods = getSupportedMethods(supportsList);
final JInvocation supportedMethodsExpr;
if (supportedMethods.isEmpty()) {
supportedMethodsExpr = _enumSetClass.staticInvoke("noneOf").arg(_resourceMethodClass.dotclass());
} else {
supportedMethodsExpr = _enumSetClass.staticInvoke("of");
for (ResourceMethod resourceMethod : supportedMethods) {
validateResourceMethod(resourceSchemaClass, resourceName, resourceMethod);
supportedMethodsExpr.arg(_resourceMethodClass.staticRef(resourceMethod.name()));
}
}
final JBlock staticInit = facadeClass.init();
final JVar methodSchemaMap = methodMetadataMapInit(facadeClass, resourceActions, entityActions, staticInit);
final JVar responseSchemaMap = responseMetadataMapInit(facadeClass, resourceActions, entityActions, staticInit);
if (resourceSchemaClass == CollectionSchema.class || resourceSchemaClass == AssociationSchema.class) {
final JClass assocKeyClass = getCodeModel().ref(TypeInfo.class);
final JClass hashMapClass = getCodeModel().ref(HashMap.class).narrow(_stringClass, assocKeyClass);
final JVar keyPartsVar = staticInit.decl(hashMapClass, "keyParts").init(JExpr._new(hashMapClass));
for (Map.Entry<String, AssocKeyTypeInfo> typeInfoEntry : assocKeyTypeInfos.entrySet()) {
final AssocKeyTypeInfo typeInfo = typeInfoEntry.getValue();
final JInvocation typeArg = JExpr._new(assocKeyClass).arg(typeInfo.getBindingType().dotclass()).arg(typeInfo.getDeclaredType().dotclass());
staticInit.add(keyPartsVar.invoke("put").arg(typeInfoEntry.getKey()).arg(typeArg));
}
staticInit.assign(resourceSpecField, JExpr._new(_resourceSpecImplClass).arg(supportedMethodsExpr).arg(methodSchemaMap).arg(responseSchemaMap).arg(keyTyperefClass == null ? keyClass.dotclass() : keyTyperefClass.dotclass()).arg(keyKeyClass == null ? JExpr._null() : keyKeyClass.dotclass()).arg(keyKeyClass == null ? JExpr._null() : keyParamsClass.dotclass()).arg(schemaClass.dotclass()).arg(keyPartsVar));
} else //simple schema
{
staticInit.assign(resourceSpecField, JExpr._new(_resourceSpecImplClass).arg(supportedMethodsExpr).arg(methodSchemaMap).arg(responseSchemaMap).arg(schemaClass.dotclass()));
}
generateBasicMethods(facadeClass, baseUriGetter, keyClass, schemaClass, supportedMethods, restMethods, resourceSpecField, resourceName, pathKeys, pathKeyTypes, assocKeyTypes, pathToAssocKeys, requestOptionsGetter, resource.data().getDataMap("annotations"));
if (resourceSchemaClass == CollectionSchema.class || resourceSchemaClass == AssociationSchema.class) {
generateFinders(facadeClass, baseUriGetter, finders, keyClass, schemaClass, assocKeyTypeInfos, resourceSpecField, resourceName, pathKeys, pathKeyTypes, assocKeyTypes, pathToAssocKeys, requestOptionsGetter);
}
generateSubResources(sourceFile, subresources, pathKeyTypes, assocKeyTypes, pathToAssocKeys);
} else //action set
{
final JBlock staticInit = facadeClass.init();
final JInvocation supportedMethodsExpr = _enumSetClass.staticInvoke("noneOf").arg(_resourceMethodClass.dotclass());
final JVar methodSchemaMap = methodMetadataMapInit(facadeClass, resourceActions, entityActions, staticInit);
final JVar responseSchemaMap = responseMetadataMapInit(facadeClass, resourceActions, entityActions, staticInit);
staticInit.assign(resourceSpecField, JExpr._new(_resourceSpecImplClass).arg(supportedMethodsExpr).arg(methodSchemaMap).arg(responseSchemaMap).arg(keyClass.dotclass()).arg(JExpr._null()).arg(JExpr._null()).arg(JExpr._null()).arg(getCodeModel().ref(Collections.class).staticInvoke("<String, Class<?>>emptyMap")));
}
generateActions(facadeClass, baseUriGetter, resourceActions, entityActions, keyClass, resourceSpecField, resourceName, pathKeys, pathKeyTypes, assocKeyTypes, pathToAssocKeys, requestOptionsGetter);
generateClassJavadoc(facadeClass, resource);
if (!checkVersionAndDeprecateBuilderClass(facadeClass, true)) {
checkRestSpecAndDeprecateRootBuildersClass(facadeClass, resource);
}
return facadeClass;
}
use of com.linkedin.restli.restspec.ActionsSetSchema in project rest.li by linkedin.
the class ResourceSchemaCollection method processResourceSchema.
private static void processResourceSchema(ResourceSchemaVisitior visitor, List<ResourceSchema> hierarchy, ResourceSchema resourceSchema) {
hierarchy.add(resourceSchema);
final ResourceSchemaVisitior.VisitContext context = buildContext(hierarchy);
visitor.visitResourceSchema(context, resourceSchema);
if (resourceSchema.hasCollection()) {
final CollectionSchema collectionSchema = resourceSchema.getCollection();
visitor.visitCollectionResource(context, collectionSchema);
processRestMethods(visitor, context, collectionSchema, collectionSchema.getMethods());
processFinders(visitor, context, collectionSchema, collectionSchema.getFinders());
processActions(visitor, context, collectionSchema, collectionSchema.getActions());
processEntitySchema(visitor, context, collectionSchema.getEntity());
} else if (resourceSchema.hasAssociation()) {
final AssociationSchema associationSchema = resourceSchema.getAssociation();
visitor.visitAssociationResource(context, associationSchema);
processRestMethods(visitor, context, associationSchema, associationSchema.getMethods());
processFinders(visitor, context, associationSchema, associationSchema.getFinders());
processActions(visitor, context, associationSchema, associationSchema.getActions());
processEntitySchema(visitor, context, associationSchema.getEntity());
} else if (resourceSchema.hasSimple()) {
final SimpleSchema simpleSchema = resourceSchema.getSimple();
visitor.visitSimpleResource(context, simpleSchema);
processRestMethods(visitor, context, simpleSchema, simpleSchema.getMethods());
processActions(visitor, context, simpleSchema, simpleSchema.getActions());
processEntitySchema(visitor, context, simpleSchema.getEntity());
} else if (resourceSchema.hasActionsSet()) {
final ActionsSetSchema actionsSet = resourceSchema.getActionsSet();
visitor.visitActionSetResource(context, actionsSet);
processActions(visitor, context, actionsSet, actionsSet.getActions());
}
hierarchy.remove(hierarchy.size() - 1);
}
Aggregations