com.bebound.plugins.beapp.poet.ReceiverPoet Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of plugins Show documentation
Be-Bound gradle plugins
There is a newer version: 1.1.0
package com.bebound.plugins.beapp.poet;

import com.bebound.plugins.beapp.model.BeApplication;
import com.bebound.plugins.beapp.model.Operation;
import com.bebound.plugins.beapp.poet.utils.CaseFormat;
import com.squareup.javapoet.ClassName;
import com.squareup.javapoet.FieldSpec;
import com.squareup.javapoet.MethodSpec;
import com.squareup.javapoet.TypeSpec;

import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

import javax.lang.model.element.Modifier;

import com.bebound.plugins.beapp.poet.utils.PoetUtils;

import static com.bebound.plugins.beapp.poet.PojoPoet.generatePushClassName;
import static com.bebound.plugins.beapp.poet.PojoPoet.generateRequestClassName;
import static com.bebound.plugins.beapp.poet.PojoPoet.generateResponseClassName;


@SuppressWarnings("Duplicates")
public class ReceiverPoet {

    private static final String CLASS_NAME_RESPONSE = "ResponseReceiver";
    private static final String CLASS_NAME_ERROR = "ErrorReceiver";
    private static final String CLASS_NAME_PUSH = "PushReceiver";
    private static final ClassName TYPE_SUCCESS_RECEIVER = ClassName.get("com.bebound.sdk.receiver", "SuccessRequestReceiver");
    private static final ClassName TYPE_ERROR_RECEIVER = ClassName.get("com.bebound.sdk.receiver", "FailureRequestReceiver");
    private static final ClassName TYPE_PUSH_RECEIVER = ClassName.get("com.bebound.sdk.receiver", "PushReceiver");

    /**
     * Generate a class containing a method to parse each response
     */
    public static TypeSpec generateResponseReceiver(BeApplication application) throws IOException {
        TypeSpec.Builder typeBuilder = TypeSpec.classBuilder(CLASS_NAME_RESPONSE)
                                               .addModifiers(Modifier.PUBLIC, Modifier.STATIC, Modifier.ABSTRACT)
                                               .superclass(TYPE_SUCCESS_RECEIVER);

        typeBuilder.addField(FieldSpec.builder(String.class, "TAG", Modifier.PROTECTED, Modifier.FINAL)
                                      .initializer("$S", CLASS_NAME_RESPONSE)
                                      .build());

        MethodSpec.Builder method = MethodSpec.methodBuilder("onSuccess").addModifiers(Modifier.PUBLIC)
                                              .addAnnotation(Override.class)
                                              .addParameter(PoetUtils.TYPE_CONTEXT, "context")
                                              .addParameter(PoetUtils.TYPE_REQUEST, "request")
                                              .addParameter(PoetUtils.TYPE_RESPONSE, "response")
                                              .addStatement("$T operationName = request.getOperationName()", String.class)
                                              .addStatement("$T.d(TAG, \"Response received for request \" + operationName)", PoetUtils.TYPE_LOG)
                                              .addCode("\n");


        List methods = new ArrayList<>();
        for (Operation operation : application.getServerOperations()) {
            String methodName = "on" + CaseFormat.toCamelCase(operation.getName());
            ClassName requestType = ClassName.get("", generateRequestClassName(operation.getName()));
            ClassName responseType = ClassName.get("", generateResponseClassName(operation.getName()));

            method.beginControlFlow("if (operationName.equalsIgnoreCase($S))", operation.getName())
                  .addStatement("$L(context, request, response, $T.fromValueMap(request.getParameters()), $T.fromResponse(response))",
                                methodName, requestType, responseType)
                  .addStatement("return")
                  .endControlFlow()
                  .addCode("\n");

            methods.add(MethodSpec.methodBuilder(methodName).addModifiers(Modifier.PUBLIC, Modifier.ABSTRACT)
                                  .addParameter(PoetUtils.TYPE_CONTEXT, "context")
                                  .addParameter(PoetUtils.TYPE_REQUEST, "rawRequest")
                                  .addParameter(PoetUtils.TYPE_RESPONSE, "rawResponse")
                                  .addParameter(requestType, "request")
                                  .addParameter(responseType, "response")
                                  .build());
        }

        typeBuilder.addMethod(method.build());
        typeBuilder.addMethods(methods);
        return typeBuilder.build();
    }

    /**
     * Generate a class containing a method to parse each error received
     */
    public static TypeSpec generateErrorReceiver(BeApplication application) throws IOException {
        TypeSpec.Builder typeBuilder = TypeSpec.classBuilder(CLASS_NAME_ERROR)
                                               .addModifiers(Modifier.PUBLIC, Modifier.STATIC, Modifier.ABSTRACT)
                                               .superclass(TYPE_ERROR_RECEIVER);

        typeBuilder.addField(FieldSpec.builder(String.class, "TAG", Modifier.PROTECTED, Modifier.FINAL)
                                      .initializer("$S", CLASS_NAME_ERROR)
                                      .build());

        MethodSpec.Builder responseErrorMethod
                = MethodSpec.methodBuilder("onResponseError").addModifiers(Modifier.PUBLIC)
                            .addAnnotation(Override.class)
                            .addParameter(PoetUtils.TYPE_CONTEXT, "context")
                            .addParameter(PoetUtils.TYPE_REQUEST, "request")
                            .addParameter(PoetUtils.TYPE_RESPONSE, "response")
                            .addStatement("$T operationName = request.getOperationName()", String.class)
                            .addStatement(
                                    "$T.e(TAG, \"ResponseError received for request \" + operationName + \": \" + response.getStatusCode() + \" \" + response.getStatusMessage())",
                                    PoetUtils.TYPE_LOG)
                            .addCode("\n");

        MethodSpec.Builder requestFailedMethod
                = MethodSpec.methodBuilder("onRequestFailed").addModifiers(Modifier.PUBLIC)
                            .addAnnotation(Override.class)
                            .addParameter(PoetUtils.TYPE_CONTEXT, "context")
                            .addParameter(PoetUtils.TYPE_REQUEST, "request")
                            .addStatement("$T operationName = request.getOperationName()", String.class)
                            .addStatement(
                                    "$T.e(TAG, \"RequestFailed received for request \" + operationName + \": \" + request.getRequestStatusCode() + \" \" + request.getRequestStatusMessage())",
                                    PoetUtils.TYPE_LOG)
                            .addCode("\n");

        MethodSpec timeoutMethod = MethodSpec.methodBuilder("onRequestTimeout").addModifiers(Modifier.PUBLIC)
                                             .addAnnotation(Override.class)
                                             .addParameter(PoetUtils.TYPE_CONTEXT, "context")
                                             .addParameter(PoetUtils.TYPE_REQUEST, "request")
                                             .addStatement("onRequestFailed(context, request)").build();

        List methods = new ArrayList<>();
        for (Operation operation : application.getServerOperations()) {
            String methodNameError = "on" + CaseFormat.toCamelCase(operation.getName() + "Error");
            String methodNameFailed = "on" + CaseFormat.toCamelCase(operation.getName() + "Failed");
            ClassName requestType = ClassName.get("", generateRequestClassName(operation.getName()));
            ClassName responseType = ClassName.get("", generateResponseClassName(operation.getName()));

            responseErrorMethod.beginControlFlow("if (operationName.equalsIgnoreCase($S))", operation.getName())
                               .addStatement("$L(context, request, response)", methodNameError)
                               .addStatement("return")
                               .endControlFlow()
                               .addCode("\n");

            requestFailedMethod.beginControlFlow("if (operationName.equalsIgnoreCase($S))", operation.getName())
                               .addStatement("$L(context, request)", methodNameFailed)
                               .addStatement("return")
                               .endControlFlow()
                               .addCode("\n");

            methods.add(MethodSpec.methodBuilder(methodNameError).addModifiers(Modifier.PUBLIC, Modifier.ABSTRACT)
                                  .addParameter(PoetUtils.TYPE_CONTEXT, "context")
                                  .addParameter(PoetUtils.TYPE_REQUEST, "request")
                                  .addParameter(PoetUtils.TYPE_RESPONSE, "response")
                                  .build());

            methods.add(MethodSpec.methodBuilder(methodNameFailed).addModifiers(Modifier.PUBLIC, Modifier.ABSTRACT)
                                  .addParameter(PoetUtils.TYPE_CONTEXT, "context")
                                  .addParameter(PoetUtils.TYPE_REQUEST, "request")
                                  .build());
        }

        typeBuilder.addMethod(responseErrorMethod.build());
        typeBuilder.addMethod(requestFailedMethod.build());
        typeBuilder.addMethod(timeoutMethod);
        typeBuilder.addMethods(methods);
        return typeBuilder.build();
    }

    /**
     * Generate a class containing a method to parse each push message
     */
    public static TypeSpec generatePushReceiver(BeApplication application) throws IOException {
        TypeSpec.Builder typeBuilder = TypeSpec.classBuilder(CLASS_NAME_PUSH)
                                               .addModifiers(Modifier.PUBLIC, Modifier.STATIC, Modifier.ABSTRACT)
                                               .superclass(TYPE_PUSH_RECEIVER);

        typeBuilder.addField(FieldSpec.builder(String.class, "TAG", Modifier.PROTECTED, Modifier.FINAL)
                                      .initializer("$S", CLASS_NAME_PUSH)
                                      .build());

        MethodSpec.Builder method = MethodSpec.methodBuilder("onReceivedPushMessage").addModifiers(Modifier.PUBLIC)
                                              .addAnnotation(Override.class)
                                              .addParameter(PoetUtils.TYPE_CONTEXT, "context")
                                              .addParameter(PoetUtils.TYPE_PUSH_MESSAGE, "message")
                                              .addStatement("$T operationName = message.getOperationName()", String.class)
                                              .addStatement("$T.d(TAG, \"Push received for operation \" + operationName)", PoetUtils.TYPE_LOG)
                                              .addCode("\n");


        List methods = new ArrayList<>();
        for (Operation operation : application.getDeviceOperations()) {
            String methodName = "on" + CaseFormat.toCamelCase(operation.getName());
            ClassName classType = ClassName.get("", generatePushClassName(operation.getName()));

            method.beginControlFlow("if (operationName.equalsIgnoreCase($S))", operation.getName())
                  .addStatement("$L(context, message, $T.fromPushMessage(message))", methodName, classType)
                  .addStatement("return")
                  .endControlFlow()
                  .addCode("\n");

            methods.add(MethodSpec.methodBuilder(methodName).addModifiers(Modifier.PUBLIC, Modifier.ABSTRACT)
                                  .addParameter(PoetUtils.TYPE_CONTEXT, "context")
                                  .addParameter(PoetUtils.TYPE_PUSH_MESSAGE, "rawMessage")
                                  .addParameter(classType, "message")
                                  .build());
        }

        typeBuilder.addMethod(method.build());
        typeBuilder.addMethods(methods);
        return typeBuilder.build();
    }
}