path: root/auth/cli-codegen/src/main/java/org/onap/policy/apex/auth/clicodegen/CodeGeneratorCliEditor.java

/*-
 * ============LICENSE_START=======================================================
 *  Copyright (C) 2016-2018 Ericsson. All rights reserved.
 *  Modifications Copyright (C) 2019 Samsung Electronics Co., Ltd.
 * ================================================================================
 * 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.
 *
 * SPDX-License-Identifier: Apache-2.0
 * ============LICENSE_END=========================================================
 */

package org.onap.policy.apex.auth.clicodegen;

import static org.onap.policy.apex.auth.clicodegen.CliEditorContants.ALBUM_NAME;
import static org.onap.policy.apex.auth.clicodegen.CliEditorContants.ALBUM_VERSION;
import static org.onap.policy.apex.auth.clicodegen.CliEditorContants.CONTEXT_REFS;
import static org.onap.policy.apex.auth.clicodegen.CliEditorContants.CTX_REFS;
import static org.onap.policy.apex.auth.clicodegen.CliEditorContants.DECLARATION;
import static org.onap.policy.apex.auth.clicodegen.CliEditorContants.DEFAULT_TASK;
import static org.onap.policy.apex.auth.clicodegen.CliEditorContants.DEFAULT_TASK_VERSION;
import static org.onap.policy.apex.auth.clicodegen.CliEditorContants.DEFAULT_VALUE;
import static org.onap.policy.apex.auth.clicodegen.CliEditorContants.DEFINITIONS;
import static org.onap.policy.apex.auth.clicodegen.CliEditorContants.DESCRIPTION;
import static org.onap.policy.apex.auth.clicodegen.CliEditorContants.EVENT_NAME;
import static org.onap.policy.apex.auth.clicodegen.CliEditorContants.EVENT_VERSION;
import static org.onap.policy.apex.auth.clicodegen.CliEditorContants.FIELDS;
import static org.onap.policy.apex.auth.clicodegen.CliEditorContants.FIELD_NAME;
import static org.onap.policy.apex.auth.clicodegen.CliEditorContants.FIELD_SCHEMA;
import static org.onap.policy.apex.auth.clicodegen.CliEditorContants.FIELD_SCHEMA_VERSION;
import static org.onap.policy.apex.auth.clicodegen.CliEditorContants.FINALIZER_LOGICS;
import static org.onap.policy.apex.auth.clicodegen.CliEditorContants.FINALIZER_LOGIC_NAME;
import static org.onap.policy.apex.auth.clicodegen.CliEditorContants.FIRST_STATE;
import static org.onap.policy.apex.auth.clicodegen.CliEditorContants.FLAVOUR;
import static org.onap.policy.apex.auth.clicodegen.CliEditorContants.INFIELDS;
import static org.onap.policy.apex.auth.clicodegen.CliEditorContants.LOGIC;
import static org.onap.policy.apex.auth.clicodegen.CliEditorContants.LOGIC_FLAVOUR;
import static org.onap.policy.apex.auth.clicodegen.CliEditorContants.NAME;
import static org.onap.policy.apex.auth.clicodegen.CliEditorContants.NAME_SPACE;
import static org.onap.policy.apex.auth.clicodegen.CliEditorContants.NEXT_STATE;
import static org.onap.policy.apex.auth.clicodegen.CliEditorContants.OPTIONAL;
import static org.onap.policy.apex.auth.clicodegen.CliEditorContants.OUTFIELDS;
import static org.onap.policy.apex.auth.clicodegen.CliEditorContants.OUTPUTS;
import static org.onap.policy.apex.auth.clicodegen.CliEditorContants.OUTPUT_NAME;
import static org.onap.policy.apex.auth.clicodegen.CliEditorContants.OUTPUT_TYPE;
import static org.onap.policy.apex.auth.clicodegen.CliEditorContants.PARAMS;
import static org.onap.policy.apex.auth.clicodegen.CliEditorContants.PAR_NAME;
import static org.onap.policy.apex.auth.clicodegen.CliEditorContants.POLICY_NAME;
import static org.onap.policy.apex.auth.clicodegen.CliEditorContants.SCHEMA;
import static org.onap.policy.apex.auth.clicodegen.CliEditorContants.SCHEMA_NAME;
import static org.onap.policy.apex.auth.clicodegen.CliEditorContants.SCHEMA_VERSION;
import static org.onap.policy.apex.auth.clicodegen.CliEditorContants.SCOPE;
import static org.onap.policy.apex.auth.clicodegen.CliEditorContants.SOURCE;
import static org.onap.policy.apex.auth.clicodegen.CliEditorContants.STATES;
import static org.onap.policy.apex.auth.clicodegen.CliEditorContants.STATE_NAME;
import static org.onap.policy.apex.auth.clicodegen.CliEditorContants.TARGET;
import static org.onap.policy.apex.auth.clicodegen.CliEditorContants.TASKS;
import static org.onap.policy.apex.auth.clicodegen.CliEditorContants.TASK_LOCAL_NAME;
import static org.onap.policy.apex.auth.clicodegen.CliEditorContants.TASK_NAME;
import static org.onap.policy.apex.auth.clicodegen.CliEditorContants.TASK_VERSION;
import static org.onap.policy.apex.auth.clicodegen.CliEditorContants.TEMPLATE;
import static org.onap.policy.apex.auth.clicodegen.CliEditorContants.TRIGGER_NAME;
import static org.onap.policy.apex.auth.clicodegen.CliEditorContants.TRIGGER_VERSION;
import static org.onap.policy.apex.auth.clicodegen.CliEditorContants.TS_LOGIC;
import static org.onap.policy.apex.auth.clicodegen.CliEditorContants.UUID;
import static org.onap.policy.apex.auth.clicodegen.CliEditorContants.VERSION;
import static org.onap.policy.apex.auth.clicodegen.CliEditorContants.WRITABLE;

import java.util.List;

import org.stringtemplate.v4.ST;
import org.stringtemplate.v4.STGroupFile;

/**
 * Code generator generating expressions for the APEX CLI Editor.
 *
 * @author Sven van der Meer (sven.van.der.meer@ericsson.com)
 */
public class CodeGeneratorCliEditor {

    // CHECKSTYLE:OFF: ParameterNumber

    /**
     * The name of the STG file for the code generator.
     */
    public static final String STG_FILE = "org/onap/policy/apex/auth/clicodegen/cli-editor.stg";

    /**
     * The String Template Group, taken from the context.
     */
    private final STGroupFile stg;

    /**
     * The ST for the model, loaded from the STG.
     */
    private final ST model;

    /**
     * A default name space, set from specification.
     */
    private String defaultNamespace;

    /**
     * Creates a new code generator.
     */
    public CodeGeneratorCliEditor() {
        stg = new STGroupFile(STG_FILE);
        stg.registerRenderer(String.class, new CgStringRenderer(), true);
        model = stg.getInstanceOf("policyModel");
    }

    /**
     * Adds model parameters to the template.
     *
     * @param name the name of the mode, must not be blank
     * @param version a version, can be null
     * @param uuid a UUID, can be null
     * @param description a description, must not be blank
     */
    public void addModelParams(final String name, final String version, final String uuid, final String description) {
        if (name == null || name.isEmpty()) {
            throw new IllegalArgumentException("model name should not be blank");
        }
        if (description == null || description.isEmpty()) {
            throw new IllegalArgumentException("model description should not be blank");
        }

        model.add(NAME, name);
        model.add(VERSION, version);
        model.add(UUID, uuid);
        model.add(DESCRIPTION, description);
    }

    /**
     * Returns the model.
     *
     * @return the model
     */
    public ST getModel() {
        return model;
    }

    /**
     * Sets the default name space.
     *
     * @param nameSpace new name space, ignored if blank
     */
    public void setDefaultNamespace(final String nameSpace) {
        if (nameSpace != null && !nameSpace.isEmpty()) {
            defaultNamespace = nameSpace;
        }
    }

    /**
     * Adds a new schema declaration to the model.
     *
     * @param name the name of the schema
     * @param version the version of the declaration
     * @param uuid the UUID for the declaration
     * @param description a description of the schema
     * @param flavour the flavour of the schema declaration, e.g. Java or Avro
     * @param schema the actual schema declaration, either a string or as <code>LS schema LE</code>
     */
    public void addSchemaDeclaration(final String name, final String version, final String uuid,
            final String description, final String flavour, final String schema) {
        final ST st = stg.getInstanceOf("schemaDecl");
        st.add(NAME, name);
        st.add(VERSION, version);
        st.add(UUID, uuid);
        st.add(DESCRIPTION, description);
        st.add(FLAVOUR, flavour);
        st.add(SCHEMA, schema);
        model.add(DECLARATION, st);
    }

    /**
     * Adds a new context album declaration to the model.
     *
     * @param codeGenCliEditorBuilder The parameters for the context album
     */
    public void addContextAlbumDeclaration(CodeGenCliEditorBuilder codeGenCliEditorBuilder) {
        final ST st = stg.getInstanceOf("ctxAlbumDecl");
        st.add(NAME, codeGenCliEditorBuilder.getName());
        st.add(VERSION, codeGenCliEditorBuilder.getVersion());
        st.add(UUID, codeGenCliEditorBuilder.getUuid());
        st.add(DESCRIPTION, codeGenCliEditorBuilder.getDescription());
        st.add(SCOPE, codeGenCliEditorBuilder.getScope());
        st.add(WRITABLE, codeGenCliEditorBuilder.isWritable());
        st.add(SCHEMA_NAME, codeGenCliEditorBuilder.getSchemaName());
        st.add(SCHEMA_VERSION, codeGenCliEditorBuilder.getSchemaVersion());
        model.add(DECLARATION, st);
    }

    /**
     * Creates a new event field definition which belongs to an event.
     *
     * @param eventName the event name
     * @param version the event version
     * @param fieldName the name for the field in the event
     * @param fieldSchema the schema of the field
     * @param fieldSchemaVersion the version of the schema
     * @param optional a flag for optional fields
     * @return a CLI command for event field definition
     */
    public ST createEventFieldDefinition(final String eventName, final String version, final String fieldName,
            final String fieldSchema, final String fieldSchemaVersion, final boolean optional) {
        final ST st = stg.getInstanceOf("eventDefField");
        st.add(EVENT_NAME, eventName);
        st.add(VERSION, version);
        st.add(FIELD_NAME, fieldName);
        st.add(FIELD_SCHEMA, fieldSchema);
        st.add(FIELD_SCHEMA_VERSION, fieldSchemaVersion);
        st.add(OPTIONAL, optional);
        return st;
    }

    /**
     * Creates a new task logic definition which belongs to a task.
     *
     * @param taskName the name of the task
     * @param version the task version
     * @param flavour the flavour, e.g. JAVA or JAVASCRIPT
     * @param logic the actual logic (use either a string or a multi-line with <code>LS some code LE</code>
     * @return a CLI command for task definition, logic
     */
    public ST createTaskDefLogic(final String taskName, final String version, final String flavour,
            final String logic) {
        final ST st = stg.getInstanceOf("taskDefLogic");
        st.add(TASK_NAME, taskName);
        st.add(VERSION, version);
        st.add(FLAVOUR, flavour);
        st.add(LOGIC, logic);
        return st;
    }

    /**
     * Adds a new event declaration to the model.
     *
     * @param eventDeclarationBuilder param object for event declaration
     */
    public void addEventDeclaration(EventDeclarationBuilder eventDeclarationBuilder) {
        final ST st = stg.getInstanceOf("eventDecl");
        st.add(NAME, eventDeclarationBuilder.getName());
        st.add(VERSION, eventDeclarationBuilder.getVersion());
        st.add(UUID, eventDeclarationBuilder.getUuid());
        st.add(DESCRIPTION, eventDeclarationBuilder.getDescription());
        st.add(SOURCE, eventDeclarationBuilder.getSource());
        st.add(TARGET, eventDeclarationBuilder.getTarget());
        st.add(FIELDS, eventDeclarationBuilder.getFields());

        if (eventDeclarationBuilder.getNameSpace() != null) {
            st.add(NAME_SPACE, eventDeclarationBuilder.getNameSpace());
        } else if (defaultNamespace != null) {
            st.add(NAME_SPACE, defaultNamespace);
        }

        model.add(DECLARATION, st);
    }

    /**
     * Adds a new task declaration to the model.
     *
     * @param name the name of the task
     * @param version the version of the task
     * @param uuid a UUID for the definition
     * @param description a description of the task
     * @param infields all infields for the task
     * @param outfields all outfields for the task
     * @param logic the logic for the task
     * @param parameters any task parameter
     * @param contextRefs any context reference
     */
    public void addTaskDeclaration(TaskDeclarationBuilder taskDeclarationBuilder) {
        final ST st = stg.getInstanceOf("taskDecl");
        st.add(NAME, taskDeclarationBuilder.getName());
        st.add(VERSION, taskDeclarationBuilder.getVersion());
        st.add(UUID, taskDeclarationBuilder.getUuid());
        st.add(DESCRIPTION, taskDeclarationBuilder.getDescription());
        st.add(INFIELDS, taskDeclarationBuilder.getInfields());
        st.add(OUTFIELDS, taskDeclarationBuilder.getOutfields());
        st.add(LOGIC, taskDeclarationBuilder.getLogic());
        st.add(PARAMS, taskDeclarationBuilder.getParameters());
        st.add(CONTEXT_REFS, taskDeclarationBuilder.getContextRefs());
        model.add(DECLARATION, st);
    }

    /**
     * Adds a new policy definition to the model.
     *
     * @param name the name of the policy
     * @param version the version of the policy
     * @param uuid a UUID for the definition
     * @param description a description of the policy
     * @param template the template type for this policy
     * @param firstState the first state of the policy
     * @param states all policy states
     */
    public void addPolicyDefinition(final String name, final String version, final String uuid,
            final String description, final String template, final String firstState, final List<ST> states) {
        final ST st = stg.getInstanceOf("policyDef");
        st.add(NAME, name);
        st.add(VERSION, version);
        st.add(UUID, uuid);
        st.add(DESCRIPTION, description);
        st.add(TEMPLATE, template);
        st.add(FIRST_STATE, firstState);
        st.add(STATES, states);
        model.add(DEFINITIONS, st);
    }

    /**
     * Creates a new task infield definition.
     *
     * @param taskName the name of the task
     * @param version the version of the task
     * @param fieldName the name of the infield
     * @param fieldSchema the schema for the infield
     * @param fieldSchemaVersion the version of the schema
     * @return a CLI command for task infield definition
     */
    public ST createTaskDefinitionInfields(final String taskName, final String version, final String fieldName,
            final String fieldSchema, final String fieldSchemaVersion) {
        final ST st = stg.getInstanceOf("taskDefInputFields");
        st.add(TASK_NAME, taskName);
        st.add(VERSION, version);
        st.add(FIELD_NAME, fieldName);
        st.add(FIELD_SCHEMA, fieldSchema);
        st.add(FIELD_SCHEMA_VERSION, fieldSchemaVersion);
        return st;
    }

    /**
     * Creates a new task outfield definition.
     *
     * @param taskName the name of the task
     * @param version the version of the task
     * @param fieldName the name of the outfield
     * @param fieldSchema the schema for the outfield
     * @param fieldSchemaVersion the version of the schema
     * @return a CLI command for task outfield definition
     */
    public ST createTaskDefinitionOutfields(final String taskName, final String version, final String fieldName,
            final String fieldSchema, final String fieldSchemaVersion) {
        final ST st = stg.getInstanceOf("taskDefOutputFields");
        st.add(TASK_NAME, taskName);
        st.add(VERSION, version);
        st.add(FIELD_NAME, fieldName);
        st.add(FIELD_SCHEMA, fieldSchema);
        st.add(FIELD_SCHEMA_VERSION, fieldSchemaVersion);
        return st;
    }

    /**
     * Creates a new task parameter definition belonging to a task.
     *
     * @param name the name of the task
     * @param version the version of the task
     * @param parName the parameter name
     * @param defaultValue a default value for the parameter
     * @return a CLI command for a task parameter definition
     */
    public ST createTaskDefinitionParameters(final String name, final String version, final String parName,
            final String defaultValue) {
        final ST st = stg.getInstanceOf("taskDefParameter");
        st.add(NAME, name);
        st.add(VERSION, version);
        st.add(PAR_NAME, parName);
        st.add(DEFAULT_VALUE, defaultValue);
        return st;
    }

    /**
     * Creates a new task definition context reference which belongs to a task.
     *
     * @param name the name of the task
     * @param version the version of the task
     * @param albumName the name of the context album
     * @param albumVersion the version of the context album
     * @return a CLI command for a task context reference definition
     */
    public ST createTaskDefinitionContextRef(final String name, final String version, final String albumName,
            final String albumVersion) {
        final ST st = stg.getInstanceOf("taskDefCtxRef");
        st.add(NAME, name);
        st.add(VERSION, version);
        st.add(ALBUM_NAME, albumName);
        st.add(ALBUM_VERSION, albumVersion);
        return st;
    }

    /**
     * Creates a new policy state task definition for a task which belongs to a state which belongs to a policy.
     *
     * @param policyName the name of the policy
     * @param version the version of the policy
     * @param stateName the name of the new state
     * @param taskLocalName the local (in policy and state) name of the task
     * @param taskName the identifier of the task (previously defined as a task)
     * @param taskVersion the version of the task definition
     * @param outputType the output type
     * @param outputName the output name
     * @return a CLI command for a policy state task definition
     */
    public ST createPolicyStateTask(PolicyStateTaskBuilder policyStateTaskBuilder) {
        final ST st = stg.getInstanceOf("policyStateTask");
        st.add(POLICY_NAME, policyStateTaskBuilder.getPolicyName());
        st.add(VERSION, policyStateTaskBuilder.getVersion());
        st.add(STATE_NAME, policyStateTaskBuilder.getStateName());
        st.add(TASK_LOCAL_NAME, policyStateTaskBuilder.getTaskLocalName());
        st.add(TASK_NAME, policyStateTaskBuilder.getTaskName());
        st.add(TASK_VERSION, policyStateTaskBuilder.getTaskVersion());
        st.add(OUTPUT_TYPE, policyStateTaskBuilder.getOutputType());
        st.add(OUTPUT_NAME, policyStateTaskBuilder.getOutputName());
        return st;
    }

    /**
     * Creates a new policy state output definition for a state which belongs to a policy.
     *
     * @param policyName the name of the policy
     * @param version the version of the policy
     * @param stateName the name of the new state
     * @param outputName the name of the new output
     * @param eventName the event name for the output
     * @param eventVersion the version of the event for the output
     * @param nextState the next state if any
     * @return a CLI command for a state output definition
     */
    public ST createPolicyStateOutput(final String policyName, final String version, final String stateName,
            final String outputName, final String eventName, final String eventVersion,
            final String nextState) {
        final ST st = stg.getInstanceOf("policyStateOutput");
        st.add(POLICY_NAME, policyName);
        st.add(VERSION, version);
        st.add(STATE_NAME, stateName);
        st.add(OUTPUT_NAME, outputName);
        st.add(EVENT_NAME, eventName);
        st.add(EVENT_VERSION, eventVersion);
        st.add(NEXT_STATE, nextState);
        return st;
    }

    /**
     * Creates a new policy state definition for a state which belongs to a policy.
     *
     * @param policyName the name of the policy
     * @param version the version of the policy
     * @param stateName the name of the new state
     * @param triggerName the name of the trigger event
     * @param triggerVersion the version of the trigger event
     * @param defaultTask the identifier of the default task
     * @param defaultTaskVersion the version of the default task
     * @param outputs the output definitions of the state
     * @param tasks the task definition of the state
     * @param tsLogic the task selection logic of the state
     * @param finalizerLogics the finalizer logics for the state
     * @param ctxRefs any context reference for the state
     * @return a CLI command for a policy state definition
     */
    public ST createPolicyStateDef(PolicyStateDefBuilder policyStateDefBuilder) {
        final ST st = stg.getInstanceOf("policyStateDef");
        st.add(POLICY_NAME, policyStateDefBuilder.getPolicyName());
        st.add(VERSION, policyStateDefBuilder.getVersion());
        st.add(STATE_NAME, policyStateDefBuilder.getStateName());
        st.add(TRIGGER_NAME, policyStateDefBuilder.getTriggerName());
        st.add(TRIGGER_VERSION, policyStateDefBuilder.getTriggerVersion());
        st.add(DEFAULT_TASK, policyStateDefBuilder.getDefaultTask());
        st.add(DEFAULT_TASK_VERSION, policyStateDefBuilder.getDefaultTaskVersion());
        st.add(OUTPUTS, policyStateDefBuilder.getOutputs());
        st.add(TASKS, policyStateDefBuilder.getTasks());
        st.add(TS_LOGIC, policyStateDefBuilder.getTsLogic());
        st.add(FINALIZER_LOGICS, policyStateDefBuilder.getFinalizerLogics());
        st.add(CTX_REFS, policyStateDefBuilder.getCtxRefs());
        return st;
    }

    /**
     * Creates a new task selection logic definition for a state which belongs to a policy.
     *
     * @param name the name of the policy
     * @param version the version of the policy
     * @param stateName the name of the state
     * @param logicFlavour the flavour, e.g. JAVA or JAVASCRIPT
     * @param logic the actual logic (use either a string or a multi-line with <code>LS some code LE</code>
     * @return a CLI command for task selection logic definition
     */
    public ST createPolicyStateDefTaskSelLogic(final String name, final String version, final String stateName,
            final String logicFlavour, final String logic) {
        final ST st = stg.getInstanceOf("policyStateTaskSelectionLogic");
        st.add(NAME, name);
        st.add(VERSION, version);
        st.add(STATE_NAME, stateName);
        st.add(LOGIC_FLAVOUR, logicFlavour);
        st.add(LOGIC, logic);
        return st;
    }

    /**
     * Creates a new state finalizer definition for a state which belongs to a policy.
     *
     * @param name the name of the policy
     * @param version the version of the policy
     * @param stateName the name of the state
     * @param finalizerLogicName name of the finalizer logic
     * @param logicFlavour the flavour, e.g. JAVA or JAVASCRIPT
     * @param logic the actual logic (use either a string or a multi-line with <code>LS some code LE</code>
     * @return a CLI command for finalizer definition
     */
    public ST createPolicyStateDefFinalizerLogic(final String name, final String version, final String stateName,
            final String finalizerLogicName, final String logicFlavour, final String logic) {
        final ST st = stg.getInstanceOf("policyStateFinalizerLogic");
        st.add(NAME, name);
        st.add(VERSION, version);
        st.add(STATE_NAME, stateName);
        st.add(FINALIZER_LOGIC_NAME, finalizerLogicName);
        st.add(LOGIC_FLAVOUR, logicFlavour);
        st.add(LOGIC, logic);
        return st;
    }

    /**
     * Creates a new policy state context reference for a state which belongs to a policy.
     *
     * @param name the name of the policy
     * @param version the version of the policy
     * @param stateName the name of the state
     * @param albumName the name of the album
     * @param albumVersion the version of the album
     * @return a CLI command for state context reference
     */
    public ST createPolicyStateDefContextRef(final String name, final String version, final String stateName,
            final String albumName, final String albumVersion) {
        final ST st = stg.getInstanceOf("policyStateContextRef");
        st.add(NAME, name);
        st.add(VERSION, version);
        st.add(STATE_NAME, stateName);
        st.add(ALBUM_NAME, albumName);
        st.add(ALBUM_VERSION, albumVersion);
        return st;
    }

}