path: root/appc-inbound/appc-artifact-handler/provider/src/main/java/org/onap/appc/artifact/handler/node/ArtifactHandlerNode.java

/*-
 * ============LICENSE_START=======================================================
 * ONAP : APPC
 * ================================================================================
 * Copyright (C) 2017-2019 AT&T Intellectual Property. All rights reserved.
 * ================================================================================
 * Copyright (C) 2017 Amdocs
 * ================================================================================
 * Modifications Copyright (C) 2019 Ericsson
 * =============================================================================
 * 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.
 *
 * ============LICENSE_END=========================================================
 */

package org.onap.appc.artifact.handler.node;

import static org.onap.appc.artifact.handler.utils.SdcArtifactHandlerConstants.ACTION;
import static org.onap.appc.artifact.handler.utils.SdcArtifactHandlerConstants.ACTION_LEVEL;
import static org.onap.appc.artifact.handler.utils.SdcArtifactHandlerConstants.ACTION_LEVEL_VF_MODULE;
import static org.onap.appc.artifact.handler.utils.SdcArtifactHandlerConstants.ACTION_LEVEL_VM;
import static org.onap.appc.artifact.handler.utils.SdcArtifactHandlerConstants.ACTION_LEVEL_VNF;
import static org.onap.appc.artifact.handler.utils.SdcArtifactHandlerConstants.ACTION_LEVEL_VNFC;
import static org.onap.appc.artifact.handler.utils.SdcArtifactHandlerConstants.ARTIFACT_CONTENTS;
import static org.onap.appc.artifact.handler.utils.SdcArtifactHandlerConstants.ARTIFACT_DESRIPTION;
import static org.onap.appc.artifact.handler.utils.SdcArtifactHandlerConstants.ARTIFACT_NAME;
import static org.onap.appc.artifact.handler.utils.SdcArtifactHandlerConstants.ARTIFACT_NAME_CAPABILITY;
import static org.onap.appc.artifact.handler.utils.SdcArtifactHandlerConstants.ARTIFACT_NAME_REFERENCE;
import static org.onap.appc.artifact.handler.utils.SdcArtifactHandlerConstants.ARTIFACT_TYPE;
import static org.onap.appc.artifact.handler.utils.SdcArtifactHandlerConstants.ARTIFACT_UUID;
import static org.onap.appc.artifact.handler.utils.SdcArtifactHandlerConstants.ARTIFACT_VERSION;
import static org.onap.appc.artifact.handler.utils.SdcArtifactHandlerConstants.CAPABILITY;
import static org.onap.appc.artifact.handler.utils.SdcArtifactHandlerConstants.DB_CONFIG_ACTION_DG;
import static org.onap.appc.artifact.handler.utils.SdcArtifactHandlerConstants.DB_DEVICE_AUTHENTICATION;
import static org.onap.appc.artifact.handler.utils.SdcArtifactHandlerConstants.DB_DEVICE_INTERFACE_PROTOCOL;
import static org.onap.appc.artifact.handler.utils.SdcArtifactHandlerConstants.DB_DOWNLOAD_DG_REFERENCE;
import static org.onap.appc.artifact.handler.utils.SdcArtifactHandlerConstants.DB_SDC_REFERENCE;
import static org.onap.appc.artifact.handler.utils.SdcArtifactHandlerConstants.DEVICE_PROTOCOL;
import static org.onap.appc.artifact.handler.utils.SdcArtifactHandlerConstants.DISTRIBUTION_ID;
import static org.onap.appc.artifact.handler.utils.SdcArtifactHandlerConstants.DOCUMENT_PARAMETERS;
import static org.onap.appc.artifact.handler.utils.SdcArtifactHandlerConstants.DOWNLOAD_DG_REFERENCE;
import static org.onap.appc.artifact.handler.utils.SdcArtifactHandlerConstants.FILE_CATEGORY;
import static org.onap.appc.artifact.handler.utils.SdcArtifactHandlerConstants.GROUP_NOTATION_TYPE;
import static org.onap.appc.artifact.handler.utils.SdcArtifactHandlerConstants.GROUP_NOTATION_VALUE;
import static org.onap.appc.artifact.handler.utils.SdcArtifactHandlerConstants.IPADDRESS_V4_OAM_VIP;
import static org.onap.appc.artifact.handler.utils.SdcArtifactHandlerConstants.PARAMETER_YANG;
import static org.onap.appc.artifact.handler.utils.SdcArtifactHandlerConstants.PD;
import static org.onap.appc.artifact.handler.utils.SdcArtifactHandlerConstants.PORT_NUMBER;
import static org.onap.appc.artifact.handler.utils.SdcArtifactHandlerConstants.REFERENCE;
import static org.onap.appc.artifact.handler.utils.SdcArtifactHandlerConstants.REQUEST_ID;
import static org.onap.appc.artifact.handler.utils.SdcArtifactHandlerConstants.REQUEST_INFORMATION;
import static org.onap.appc.artifact.handler.utils.SdcArtifactHandlerConstants.RESOURCE_INSTANCE_NAME;
import static org.onap.appc.artifact.handler.utils.SdcArtifactHandlerConstants.RESOURCE_NAME;
import static org.onap.appc.artifact.handler.utils.SdcArtifactHandlerConstants.RESOURCE_TYPE;
import static org.onap.appc.artifact.handler.utils.SdcArtifactHandlerConstants.RESOURCE_UUID;
import static org.onap.appc.artifact.handler.utils.SdcArtifactHandlerConstants.RESOURCE_VERSION;
import static org.onap.appc.artifact.handler.utils.SdcArtifactHandlerConstants.SERVICE_DESCRIPTION;
import static org.onap.appc.artifact.handler.utils.SdcArtifactHandlerConstants.SERVICE_NAME;
import static org.onap.appc.artifact.handler.utils.SdcArtifactHandlerConstants.SERVICE_UUID;
import static org.onap.appc.artifact.handler.utils.SdcArtifactHandlerConstants.TEMPLATE;
import static org.onap.appc.artifact.handler.utils.SdcArtifactHandlerConstants.TEMPLATE_ID;
import static org.onap.appc.artifact.handler.utils.SdcArtifactHandlerConstants.TOSCA_MODEL;
import static org.onap.appc.artifact.handler.utils.SdcArtifactHandlerConstants.USER_NAME;
import static org.onap.appc.artifact.handler.utils.SdcArtifactHandlerConstants.VM;
import static org.onap.appc.artifact.handler.utils.SdcArtifactHandlerConstants.VM_INSTANCE;
import static org.onap.appc.artifact.handler.utils.SdcArtifactHandlerConstants.VNFC;
import static org.onap.appc.artifact.handler.utils.SdcArtifactHandlerConstants.VNFC_FUNCTION_CODE;
import static org.onap.appc.artifact.handler.utils.SdcArtifactHandlerConstants.VNFC_FUNCTION_CODE_LIST;
import static org.onap.appc.artifact.handler.utils.SdcArtifactHandlerConstants.VNFC_INSTANCE;
import static org.onap.appc.artifact.handler.utils.SdcArtifactHandlerConstants.VNFC_TYPE;
import static org.onap.appc.artifact.handler.utils.SdcArtifactHandlerConstants.VNFC_TYPE_LIST;
import static org.onap.appc.artifact.handler.utils.SdcArtifactHandlerConstants.VNF_TYPE;
import static org.onap.appc.artifact.handler.utils.SdcArtifactHandlerConstants.URL;
import static org.onap.appc.artifact.handler.utils.SdcArtifactHandlerConstants.OPENSTACK;
import static org.onap.appc.artifact.handler.utils.SdcArtifactHandlerConstants.ANSIBLE;
import com.att.eelf.configuration.EELFLogger;
import com.att.eelf.configuration.EELFManager;
import java.io.ByteArrayOutputStream;
import java.io.OutputStream;
import java.sql.SQLException;
import java.util.Map;
import java.util.function.Function;
import org.apache.commons.configuration.ConfigurationException;
import org.apache.commons.lang.StringUtils;
import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;
import org.onap.appc.artifact.handler.dbservices.DBException;
import org.onap.appc.artifact.handler.dbservices.DBService;
import org.onap.appc.artifact.handler.utils.ArtifactHandlerProviderUtil;
import org.onap.appc.yang.YANGGenerator;
import org.onap.appc.yang.impl.YANGGeneratorFactory;
import org.onap.ccsdk.sli.core.sli.SvcLogicContext;
import org.onap.ccsdk.sli.core.sli.SvcLogicException;
import org.onap.ccsdk.sli.core.sli.SvcLogicJavaPlugin;
import org.onap.sdnc.config.params.transformer.tosca.ArtifactProcessorImpl;
import org.onap.sdnc.config.params.transformer.tosca.exceptions.ArtifactProcessorException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;

public class ArtifactHandlerNode implements SvcLogicJavaPlugin {

    private static final EELFLogger log = EELFManager.getInstance().getLogger(ArtifactHandlerNode.class);
    private static final String TOSCA_PARAM = "Tosca";
    private static final String YANG_PARAM = "Yang";
    private static final String ARTIFACT_LIST_PARAM = "artifact-list";
    private static final String CONFIGURE_PARAM = "Configure";
    private static final String CONFIG_SCALE_OUT_PARAM = "ConfigScaleOut";
    private static final String CONFIG_MODIFY_PARAM = "ConfigModify";
    private static final String GET_CONFIG = "GetConfig";
    private static final String POST_EVACUATE = "PostEvacuate";
    private static final String PRE_EVACUATE = "PreEvacuate";
    private static final String POST_MIGRATE = "PostMigrate";
    private static final String PRE_MIGRATE = "PreMigrate";
    private static final String PRE_REBUILD = "PreRebuild";
    private static final String POST_REBUILD = "PostRebuild";
    private static final String STOP_TRAFFIC = "StopTraffic";
    private static final String CONFIG_SCALE_IN_PARAM = "ConfigScaleIn";
    
    public void processArtifact(Map<String, String> inParams, SvcLogicContext ctx) throws ArtifactProcessorException {

        if (inParams == null || inParams.isEmpty()) {
            return;
        }
        String postData = inParams.get("postData");
        if (StringUtils.isBlank(postData)) {
            return;
        }
        try {
            log.info("Received request for process Artifact with params: " + inParams.toString());
            JSONObject input = new JSONObject(postData).getJSONObject("input");
            storeUpdateSdcArtifacts(input);
        } catch (Exception e) {
            log.error("Error when processing artifact", e);
            throw new ArtifactProcessorException("Error occurred while processing artifact, " + e.getMessage(), e);
        }
    }

    private boolean storeUpdateSdcArtifacts(JSONObject postDataJson) throws ArtifactHandlerInternalException {
        log.info("Starting processing of SDC Artifacts into Handler with Data: " + postDataJson.toString());
        try {
            JSONObject requestInfo = (JSONObject) postDataJson.get(REQUEST_INFORMATION);
            JSONObject documentInfo = (JSONObject) postDataJson.get(DOCUMENT_PARAMETERS);
            String artifactName = documentInfo.getString(ARTIFACT_NAME);

            if (StringUtils.isBlank(artifactName)) {
                throw new ArtifactHandlerInternalException("Missing Artifact Name");
            }

            if (artifactName.toLowerCase().startsWith(ANSIBLE)) {
                validateAnsibleAdminArtifact(documentInfo);
                log.info("validateAnsibleAdminArtifact sucessfully done");
            }

            updateStoreArtifacts(requestInfo, documentInfo);

            if (artifactName.toLowerCase().startsWith(REFERENCE)) {
                return storeReferenceData(requestInfo, documentInfo);
            } else if (artifactName.toLowerCase().startsWith(PD)) {
                return createDataForPD(requestInfo, documentInfo);
            }

        } catch (Exception e) {
            log.error("Error while processing request with id: "
                    + ((JSONObject) postDataJson.get(REQUEST_INFORMATION)).getString(REQUEST_ID), e);
            throw new ArtifactHandlerInternalException("Error while processing request with id: "
                    + ((JSONObject) postDataJson.get(REQUEST_INFORMATION)).getString(REQUEST_ID)
                    + ", Exception Message: " + e.getMessage(), e);
        }
        return false;
    }

    public void validateAnsibleAdminArtifact(JSONObject documentInfo) throws ArtifactHandlerInternalException {

        String fn = "ArtifactHandlerNode.validateAnsibleAdminArtifact";
        String artifactName = documentInfo.getString(ARTIFACT_NAME);
        log.info(fn + ": Received Admin File Name: " + artifactName
                + ", ArtifactContent: " + documentInfo.getString(ARTIFACT_CONTENTS));
        try {
            ArtifactHandlerProviderUtil ahpUtil = new ArtifactHandlerProviderUtil();
            String contentString = ahpUtil.escapeSql(documentInfo.getString(ARTIFACT_CONTENTS));
            JSONObject artifact = new JSONObject(contentString);
            JSONArray fqdnList = artifact.getJSONArray("fqdn-list");
            Map<String, List<String>> artifactMap = new HashMap<>();

            for (int i = 0; i < fqdnList.length(); i++) {
                JSONObject fqdn = fqdnList.getJSONObject(i);
                List<String> valuesforFQDN = populateValueForFQDN(fqdn);
                artifactMap.put(fqdn.getString("vnf-management-server-fqdn"), valuesforFQDN);
            }

            validateKeyValue(artifactMap);

        } catch (JSONException je) {
            log.error(fn + " ansible admin artifact content may not be a valid JSON, error message: "
                    + je.getMessage());
            throw new ArtifactHandlerInternalException(
                    "JSON Exception:ansible admin artifact content may not be a valid JSON, error message: "
                    + je.getMessage(),
                    je);
        } catch (ArtifactHandlerInternalException ae) {
            throw ae;
        } catch (Exception e) {
            log.error(fn + "Error while creating Admin data records", e);
            throw new ArtifactHandlerInternalException(
                    "Error while processing ansible admin artifact: " + e.getMessage(), e);
        }

    }

    private void validateKeyValue(Map<String, List<String>> artifactMap) throws ArtifactHandlerInternalException {
        for (String fqdn1 : artifactMap.keySet()) {

            for (String value : artifactMap.get(fqdn1)) {

                for (String fqdn2 : artifactMap.keySet()) {

                    if (!fqdn1.equals(fqdn2) && artifactMap.get(fqdn2).contains(value)) {
                        String msg = "Validation Failure: Ansible Admin artifact has CloudOwner-RegionId-Tenant: "
                                + value + " mapped to multiple FQDN: " + fqdn1 + " & " + fqdn2;
                        log.info(msg);
                        throw new ArtifactHandlerInternalException(msg);
                    }

                }
            }

        }

    }

    private List<String> populateValueForFQDN(JSONObject fqdn) {
        log.info("Inside populateValueForFQDN: " + fqdn.getString("vnf-management-server-fqdn"));
        List<String> valuesforFQDN = new ArrayList<>();
        JSONArray cloudJsonList = fqdn.getJSONArray("cloud-owner-list");
        for (int j = 0; j < cloudJsonList.length(); j++) {
            String cloudOwner = cloudJsonList.getJSONObject(j).getString("cloud-owner");
            JSONArray regionList = cloudJsonList.getJSONObject(j).getJSONArray("region-id-list");

            for (int i = 0; i < regionList.length(); i++) {

                String region = regionList.getJSONObject(i).getString("region-id");

                JSONArray tenantList = regionList.getJSONObject(i).getJSONArray("tenant-id-list");

                for (int k = 0; k < tenantList.length(); k++) {
                    String tenant = tenantList.getString(k);
                    String valueforFQDN = cloudOwner + "-" + region + "-" + tenant;
                    log.info("valueforFQDN for i " + i + " & j " + j + ": " + valueforFQDN);
                    valuesforFQDN.add(valueforFQDN);
                }
            }
        }

        return valuesforFQDN;
    }

    private boolean createDataForPD(JSONObject requestInfo, JSONObject documentInfo)
            throws ArtifactHandlerInternalException {

        String fn = "ArtifactHandlerNode.createReferenceDataForPD";
        String artifactName = documentInfo.getString(ARTIFACT_NAME);
        log.info(fn + " Received PD File Name: " + artifactName + " and suffix length " + PD.length());
        try {

            String suffix = artifactName.substring(PD.length());
            createArtifactRecords(requestInfo, documentInfo, suffix);
        } catch (Exception e) {
            log.error("Error while creating PD data records", e);
            throw new ArtifactHandlerInternalException("Error while creating PD data records", e);
        }
        return true;
    }

    private void createArtifactRecords(JSONObject requestInfo, JSONObject documentInfo, String suffix)
            throws ArtifactHandlerInternalException {

        try {
            log.info("Creating Tosca Records and storing into SDC Artifacts");
            String[] docs = { TOSCA_PARAM, YANG_PARAM };
            ArtifactHandlerProviderUtil ahpUtil = new ArtifactHandlerProviderUtil();
            String pdFileContents = documentInfo.getString(ARTIFACT_CONTENTS);

            // Tosca generation
            OutputStream toscaStream = new ByteArrayOutputStream();
            String toscaContents;
            ArtifactProcessorImpl toscaGenerator = getArtifactProcessorImpl();
            toscaGenerator.generateArtifact(pdFileContents, toscaStream);
            toscaContents = toscaStream.toString();
            log.info("Generated Tosca File: " + toscaContents);

            String yangContents = "YANG generation is in Progress";
            String yangName = null;

            for (String doc : docs) {
                documentInfo.put(ARTIFACT_TYPE, doc.concat("Type"));
                documentInfo.put(ARTIFACT_DESRIPTION, doc.concat("Model"));
                if (doc.equals(TOSCA_PARAM)) {
                    documentInfo.put(ARTIFACT_CONTENTS, ahpUtil.escapeSql(toscaContents));
                } else if (doc.equals(YANG_PARAM)) {
                    documentInfo.put(ARTIFACT_CONTENTS, ahpUtil.escapeSql(yangContents));
                }
                documentInfo.put(ARTIFACT_NAME, doc.concat(suffix));
                yangName = doc.concat(suffix);
                updateStoreArtifacts(requestInfo, documentInfo);
            }

            String artifactId = getArtifactID(yangName);
            OutputStream yangStream = new ByteArrayOutputStream();
            YANGGenerator yangGenerator = YANGGeneratorFactory.getYANGGenerator();
            yangGenerator.generateYANG(artifactId, toscaContents, yangStream);
            yangContents = yangStream.toString();

            if (yangContents != null) {
                updateYangContents(artifactId, ahpUtil.escapeSql(yangContents));
            }
        } catch (Exception e) {
            log.error("Error while creating artifact records", e);
            throw new ArtifactHandlerInternalException("Error while creating artifact records", e);
        }

    }

    private void updateYangContents(String artifactId, String yangContents) throws SvcLogicException {
        SvcLogicContext context = new SvcLogicContext();
        DBService dbservice = DBService.initialise();
        dbservice.updateYangContents(context, artifactId, yangContents);
    }

    private String getArtifactID(String yangName) throws SvcLogicException {
        SvcLogicContext context = new SvcLogicContext();
        DBService dbservice = DBService.initialise();
        return dbservice.getArtifactID(context, yangName);
    }

    protected boolean updateStoreArtifacts(JSONObject requestInfo, JSONObject documentInfo)
            throws SvcLogicException, SQLException {
        log.info("updateStoreArtifacts started storing of SDC Artifacts");

        SvcLogicContext context = new SvcLogicContext();
        DBService dbservice = DBService.initialise();
        ArtifactHandlerProviderUtil ahpUtil = new ArtifactHandlerProviderUtil();
        int intversion = 0;
        context.setAttribute("artifact_name", documentInfo.getString(ARTIFACT_NAME));
        String internalVersion =
                dbservice.getInternalVersionNumber(context, documentInfo.getString(ARTIFACT_NAME), null);
        log.info("Internal Version number received from Database: " + internalVersion);
        if (internalVersion != null) {
            intversion = Integer.parseInt(internalVersion);
            intversion++;
        }
        setAttribute(context, documentInfo::getString, SERVICE_UUID);
        setAttribute(context, documentInfo::getString, DISTRIBUTION_ID);
        setAttribute(context, documentInfo::getString, SERVICE_NAME);
        setAttribute(context, documentInfo::getString, SERVICE_DESCRIPTION);
        setAttribute(context, documentInfo::getString, RESOURCE_UUID);
        setAttribute(context, documentInfo::getString, RESOURCE_INSTANCE_NAME);
        setAttribute(context, documentInfo::getString, RESOURCE_VERSION);
        setAttribute(context, documentInfo::getString, RESOURCE_NAME);
        setAttribute(context, documentInfo::getString, RESOURCE_TYPE);
        setAttribute(context, documentInfo::getString, ARTIFACT_UUID);
        setAttribute(context, documentInfo::getString, ARTIFACT_TYPE);
        setAttribute(context, documentInfo::getString, ARTIFACT_VERSION);
        setAttribute(context, documentInfo::getString, ARTIFACT_DESRIPTION);
        setAttribute(context, documentInfo::getString, ARTIFACT_NAME);
        setAttribute(context, s -> ahpUtil.escapeSql(documentInfo.getString(s)), ARTIFACT_CONTENTS);

        dbservice.saveArtifacts(context, intversion);
        return true;
    }

    public boolean storeReferenceData(JSONObject requestInfo, JSONObject documentInfo)
            throws ArtifactHandlerInternalException {
        log.info("Started storing of SDC Artifacts into Handler");
        try {
            DBService dbservice = DBService.initialise();
            ArtifactHandlerProviderUtil ahpUtil = new ArtifactHandlerProviderUtil();
            String contentString = ahpUtil.escapeSql(documentInfo.getString(ARTIFACT_CONTENTS));
            String artifactName = ahpUtil.escapeSql(documentInfo.getString(ARTIFACT_NAME));
            String capabilityArtifactName =
                    StringUtils.replace(artifactName, ARTIFACT_NAME_REFERENCE, ARTIFACT_NAME_CAPABILITY);
            JSONObject capabilities = new JSONObject();
            JSONArray vnfActionList = new JSONArray();
            JSONArray vfModuleActionList = new JSONArray();
            JSONArray vnfcActionList = new JSONArray();
            JSONArray vmActionVnfcFunctionCodesList = new JSONArray();
            String vnfType = null;
            JSONObject contentObject = new JSONObject(contentString);
            JSONArray contentArray = contentObject.getJSONArray("reference_data");
            boolean storeCapabilityArtifact = true;

            for (int a = 0; a < contentArray.length(); a++) {
                JSONObject content = contentArray.getJSONObject(a);
                log.info("contentString = " + content.toString());
                JSONObject scope = content.getJSONObject("scope");
                log.info("scope: " + scope);
                SvcLogicContext context = new SvcLogicContext();
                vnfType = scope.getString(VNF_TYPE);
                setAttribute(context, scope::getString, VNF_TYPE);
                setAttribute(context, content::getString, ACTION);
                String actionLevel = content.getString(ACTION_LEVEL);
                setAttribute(context, content::getString, ACTION_LEVEL);
                setAttribute(context, documentInfo::getString, ARTIFACT_TYPE);
                processActionLists(content, actionLevel, vnfcActionList, vfModuleActionList, vnfActionList,
                        vmActionVnfcFunctionCodesList);
                JSONArray vnfcTypeList = setVnfcTypeInformation(scope, context);
                storeCapabilityArtifact = isCapabilityArtifactNeeded(context);

                if (content.has(DEVICE_PROTOCOL)) {
                    setAttribute(context, content::getString, DEVICE_PROTOCOL);
                }
                if (content.has(USER_NAME)) {
                    setAttribute(context, content::getString, USER_NAME);
                }
                if (content.has(PORT_NUMBER)) {
                    setAttribute(context, content::getString, PORT_NUMBER);
                }
                if (content.has(URL)) {
                    setAttribute(context, content::getString, URL);
                }
                processArtifactList(content, dbservice, context, vnfcTypeList);
                processConfigTypeActions(content, dbservice, context);
                dbservice.processDeviceAuthentication(context,
                        dbservice.isArtifactUpdateRequired(context, DB_DEVICE_AUTHENTICATION));

                String actionProtocol = tryGetProtocol(content);
                if (!StringUtils.equalsIgnoreCase(actionProtocol, OPENSTACK)) {
                    populateProtocolReference(dbservice, content);
                }
                context.setAttribute(VNFC_TYPE, null);
                if (content.has(VM) && content.get(VM) instanceof JSONArray) {
                    processVmList(content, context, dbservice);
                }
            }
            if (storeCapabilityArtifact) {
                capabilities.put("vnf", vnfActionList);
                capabilities.put("vf-module", vfModuleActionList);
                capabilities.put("vnfc", vnfcActionList);
                capabilities.put("vm", vmActionVnfcFunctionCodesList);
                processAndStoreCapabilitiesArtifact(dbservice, documentInfo, capabilities, capabilityArtifactName,
                        vnfType);
            }

        } catch (Exception e) {

            log.error("Error while storing reference data", e);
            throw new ArtifactHandlerInternalException("Error while storing reference data", e);
        }

        return true;
    }

    public boolean isCapabilityArtifactNeeded(SvcLogicContext context) {
        String vnfcType = context.getAttribute(VNFC_TYPE);
        if (StringUtils.isNotBlank(vnfcType)) {
            log.info("No capability Artifact for this reference data as it is at VNFC level!!");
            return false;
        } else {
            return true;
        }
    }

    public JSONArray setVnfcTypeInformation(JSONObject scope, SvcLogicContext context) {
        JSONArray vnfcTypeList = null;
        if (scope.has(VNFC_TYPE) && !scope.isNull(VNFC_TYPE)) {
            String vnfcTypeScope = scope.getString(VNFC_TYPE);
            if (StringUtils.isNotBlank(vnfcTypeScope)) {
                setAttribute(context, scope::getString, VNFC_TYPE);
                log.info("VNFC type has been set for this reference artifact!! " + vnfcTypeScope);
            } else {
                context.setAttribute(VNFC_TYPE, null);
            }
        } else {
            context.setAttribute(VNFC_TYPE, null);
        }
        if (scope.has(VNFC_TYPE_LIST) && !scope.isNull(VNFC_TYPE_LIST)
                && scope.get(VNFC_TYPE_LIST) instanceof JSONArray) {
            vnfcTypeList = scope.getJSONArray(VNFC_TYPE_LIST);
            log.info("VNFC TYPE LIST found for this artifact!! " + vnfcTypeList.toString());
        }
        return vnfcTypeList;
    }

    public void processActionLists(JSONObject content, String actionLevel, JSONArray vnfcActionList,
            JSONArray vfModuleActionList, JSONArray vnfActionList, JSONArray vmActionVnfcFunctionCodesList) {
        if (validateActionLevel(actionLevel, ACTION_LEVEL_VNFC)) {
            vnfcActionList.put(content.getString(ACTION));
        }
        if (validateActionLevel(actionLevel, ACTION_LEVEL_VF_MODULE)) {
            vfModuleActionList.put(content.getString(ACTION));
        }
        if (validateActionLevel(actionLevel, ACTION_LEVEL_VNF)) {
            vnfActionList.put(content.getString(ACTION));
        }
        if (validateActionLevel(actionLevel, ACTION_LEVEL_VM)) {
            if (content.has(VNFC_FUNCTION_CODE_LIST)
                    && !content.isNull(VNFC_FUNCTION_CODE_LIST)
                    && content.get(VNFC_FUNCTION_CODE_LIST) instanceof JSONArray) {
                log.info("Found vnfc-function-code-list!!");
                JSONArray vnfcList = content.getJSONArray(VNFC_FUNCTION_CODE_LIST);
                JSONObject obj = new JSONObject();
                obj.put(content.getString(ACTION), vnfcList);
                vmActionVnfcFunctionCodesList.put(obj);
            } else {
                log.info("Not getting JSONArray for VNFC FUNCTION CODES");
            }
        }

    }

    private boolean validateActionLevel(String actionLevel, String actionLevelVnfc) {
        return null != actionLevel && actionLevel.equalsIgnoreCase(actionLevelVnfc);
    }

    public void processArtifactList(JSONObject content, DBService dbservice, SvcLogicContext context,
            JSONArray vnfcTypeList)
            throws ArtifactHandlerInternalException {

        try {
            if (content.has(ARTIFACT_LIST_PARAM) && content.get(ARTIFACT_LIST_PARAM) instanceof JSONArray) {
                JSONArray artifactLists = (JSONArray) content.get(ARTIFACT_LIST_PARAM);
                JSONArray templateIdList = null;
                if (content.has("template-id-list") && null != content.get("template-id-list")
                        && content.get("template-id-list") instanceof JSONArray) {
                    templateIdList = content.getJSONArray("template-id-list");
                }
                doProcessArtifactList(dbservice, context, artifactLists, templateIdList, vnfcTypeList);
            }
        } catch (Exception e) {
            log.error("An error occurred when processing artifact list", e);
            throw new ArtifactHandlerInternalException(e);
        }
    }

    private void doProcessArtifactList(DBService dbservice, SvcLogicContext context, JSONArray artifactLists,
            JSONArray templateIdList, JSONArray vnfcTypeList)
            throws SvcLogicException, SQLException, ConfigurationException, DBException {
        boolean pdFile = false;
        int modelInd = 0;
        int vnfcRefInd = 0;

        for (int i = 0; i < artifactLists.length(); i++) {
            String suffix = null;
            String model = null;
            JSONObject artifact = (JSONObject) artifactLists.get(i);
            log.info("artifact is " + artifact);

            // Get Model details
            if (null != templateIdList && i > 0 && i % 2 == 0) { // Should this be changed to 3
                modelInd++; // to account for 3 artifacts
            }
            if (null != vnfcTypeList && i > 0 && i % 3 == 0) {
                // TDP 517180 - CD tool has made changes to send 3 artifacts instead of 2
                vnfcRefInd++;
            }
            setAttribute(context, artifact::getString, ARTIFACT_NAME);
            context.setAttribute(FILE_CATEGORY, artifact.getString(ARTIFACT_TYPE));

            if (artifact.getString(ARTIFACT_NAME) != null
                    && artifact.getString(ARTIFACT_NAME).toLowerCase().startsWith(PD)) {

                suffix = artifact.getString(ARTIFACT_NAME).substring(PD.length());
                pdFile = true;
            }
            log.info("Artifact-type = " + context.getAttribute(FILE_CATEGORY));
            log.info("Artifact-name = " + context.getAttribute(ARTIFACT_NAME));

            if (null != templateIdList && modelInd < templateIdList.length()) {
                model = templateIdList.getString(modelInd);
                log.info("Model is ::: " + model + ", modelInd = " + modelInd);
            }
            if (null != vnfcTypeList && vnfcRefInd < vnfcTypeList.length()) {
                String vnfcType = vnfcTypeList.getString(vnfcRefInd);
                if (StringUtils.isNotBlank(vnfcType)) {
                    context.setAttribute(VNFC_TYPE, vnfcType);
                }
                log.info("Setting vnfc type from vnfc-type-list :: " + vnfcType);
            }
            if (StringUtils.isNotBlank(model)) {
                dbservice.processSdcReferences(context,
                        dbservice.isArtifactUpdateRequired(context, DB_SDC_REFERENCE, model),
                        model);
            } else {
                dbservice.processSdcReferences(context, dbservice.isArtifactUpdateRequired(context, DB_SDC_REFERENCE));
            }

            cleanArtifactInstanceData(context);
            // Moving this into the for loop to account for mulitple artifact sets with pds
            if (pdFile) {
                log.info("Sending information related to pdfile Artifact");
                tryUpdateContext(dbservice, context, pdFile, suffix, model);
                pdFile = false; // set to false after processing yang and Tosca
            }
        }
    }

    private void tryUpdateContext(DBService dbservice, SvcLogicContext context, boolean pdFile, String suffix,
            String model)
            throws SvcLogicException, SQLException, ConfigurationException, DBException {
        if (pdFile) {
            context.setAttribute(ARTIFACT_NAME, "Tosca".concat(suffix));
            context.setAttribute(FILE_CATEGORY, TOSCA_MODEL);
            dbservice.processSdcReferences(context,
                    dbservice.isArtifactUpdateRequired(context, DB_SDC_REFERENCE, model), model);
            context.setAttribute(ARTIFACT_NAME, "Yang".concat(suffix));
            context.setAttribute(FILE_CATEGORY, PARAMETER_YANG);
            dbservice.processSdcReferences(context,
                    dbservice.isArtifactUpdateRequired(context, DB_SDC_REFERENCE, model), model);
        }
    }

    public void processConfigTypeActions(JSONObject content, DBService dbservice, SvcLogicContext context)
            throws ArtifactHandlerInternalException {

        try {
            if (contentsActionEquals(content, CONFIGURE_PARAM)
                    || contentsActionEquals(content, CONFIG_MODIFY_PARAM)
                    || contentsActionEquals(content, CONFIG_SCALE_OUT_PARAM)
                    || contentsActionEquals(content, CONFIG_SCALE_IN_PARAM)
                    || contentsActionEquals(content, GET_CONFIG)
                    || contentsActionEquals(content, POST_EVACUATE)
                    || contentsActionEquals(content, PRE_EVACUATE)
                    || contentsActionEquals(content, POST_MIGRATE)
                    || contentsActionEquals(content, PRE_MIGRATE)
                    || contentsActionEquals(content, POST_REBUILD)
                    || contentsActionEquals(content, PRE_REBUILD)
                    || contentsActionEquals(content, STOP_TRAFFIC)
                    ) {

                if (content.has(DOWNLOAD_DG_REFERENCE) && content.getString(DOWNLOAD_DG_REFERENCE).length() > 0) {

                    setAttribute(context, content::getString, DOWNLOAD_DG_REFERENCE);
                    dbservice.processDownloadDgReference(context,
                            dbservice.isArtifactUpdateRequired(context, DB_DOWNLOAD_DG_REFERENCE));
                }
                if (StringUtils.isBlank(context.getAttribute(DOWNLOAD_DG_REFERENCE))) {
                    context.setAttribute(DOWNLOAD_DG_REFERENCE, dbservice.getDownLoadDGReference(context));
                }
                dbservice.processConfigActionDg(context,
                        dbservice.isArtifactUpdateRequired(context, DB_CONFIG_ACTION_DG));

                tryProcessInterfaceProtocol(content, dbservice, context);
            }
        } catch (Exception e) {
            log.error("An error occurred when processing config type actions", e);
            throw new ArtifactHandlerInternalException(e);
        }
    }

    private void tryProcessInterfaceProtocol(JSONObject content, DBService dbservice, SvcLogicContext context)
            throws SvcLogicException, SQLException, ConfigurationException, DBException {

        if (contentsActionEquals(content, CONFIGURE_PARAM) || contentsActionEquals(content, CONFIG_SCALE_OUT_PARAM)
                || contentsActionEquals(content, CONFIG_SCALE_IN_PARAM)) {
            boolean isUpdateRequired = dbservice.isArtifactUpdateRequired(context, DB_DEVICE_INTERFACE_PROTOCOL);
            if (contentsActionEquals(content, CONFIGURE_PARAM) || (contentsActionEquals(content, CONFIG_SCALE_OUT_PARAM)
                    || contentsActionEquals(content, CONFIG_SCALE_IN_PARAM)
                        && !isUpdateRequired)) {

                dbservice.processDeviceInterfaceProtocol(context, isUpdateRequired);
            }
        }
    }

    private boolean contentsActionEquals(JSONObject content, String action) {
        return content.getString(ACTION).equals(action);
    }

    public void processVmList(JSONObject content, SvcLogicContext context, DBService dbservice)
            throws SvcLogicException {
        JSONArray vmList = (JSONArray) content.get(VM);
        dbservice.cleanUpVnfcReferencesForVnf(context);
        for (int i = 0; i < vmList.length(); i++) {
            JSONObject vmInstance = (JSONObject) vmList.get(i);
            setAttribute(context, s -> String.valueOf(vmInstance.getInt(s)), VM_INSTANCE);
            log.info("VALUE = " + context.getAttribute(VM_INSTANCE));
            String templateId = vmInstance.optString(TEMPLATE_ID);
            trySetContext(context, vmInstance, templateId);
            if (vmInstance.get(VNFC) instanceof JSONArray) {
                JSONArray vnfcInstanceList = (JSONArray) vmInstance.get(VNFC);
                for (int k = 0; k < vnfcInstanceList.length(); k++) {
                    JSONObject vnfcInstance = (JSONObject) vnfcInstanceList.get(k);

                    setAttribute(context, s -> String.valueOf(vnfcInstance.getInt(s)), VNFC_INSTANCE);
                    setAttribute(context, vnfcInstance::getString, VNFC_TYPE);
                    setAttribute(context, vnfcInstance::getString, VNFC_FUNCTION_CODE);
                    resolveContext(context, vnfcInstance);
                    tryProcessVnfcReference(content, context, dbservice);
                    cleanVnfcInstance(context);
                }
                context.setAttribute(VM_INSTANCE, null);
                context.setAttribute(TEMPLATE_ID, null);
            }
        }
    }

    private void trySetContext(SvcLogicContext context, JSONObject vmInstance, String templateId) {
        if (StringUtils.isNotBlank(templateId)) {
            setAttribute(context, vmInstance::optString, TEMPLATE_ID);
        }
    }

    private void tryProcessVnfcReference(JSONObject content, SvcLogicContext context, DBService dbservice)
            throws SvcLogicException {
        if (content.getString(ACTION).equals(CONFIGURE_PARAM)
                || content.getString(ACTION).equals(CONFIG_SCALE_OUT_PARAM)
                || content.getString(ACTION).equals(CONFIG_SCALE_IN_PARAM)) {

            dbservice.processVnfcReference(context, false);
        }
    }

    private void resolveContext(SvcLogicContext context, JSONObject vnfcInstance) {
        if (vnfcInstance.has(IPADDRESS_V4_OAM_VIP)) {
            setAttribute(context, vnfcInstance::getString, IPADDRESS_V4_OAM_VIP);
        }
        if (vnfcInstance.has(GROUP_NOTATION_TYPE)) {
            setAttribute(context, vnfcInstance::getString, GROUP_NOTATION_TYPE);
        }
        if (vnfcInstance.has(GROUP_NOTATION_VALUE)) {
            setAttribute(context, vnfcInstance::getString, GROUP_NOTATION_VALUE);
        }
    }

    private void cleanArtifactInstanceData(SvcLogicContext context) {
        context.setAttribute(ARTIFACT_NAME, null);
        context.setAttribute(FILE_CATEGORY, null);
    }

    private void cleanVnfcInstance(SvcLogicContext context) {

        context.setAttribute(VNFC_INSTANCE, null);
        context.setAttribute(VNFC_TYPE, null);
        context.setAttribute(VNFC_FUNCTION_CODE, null);
        context.setAttribute(IPADDRESS_V4_OAM_VIP, null);
        context.setAttribute(GROUP_NOTATION_TYPE, null);
        context.setAttribute(GROUP_NOTATION_VALUE, null);

    }

    private void processAndStoreCapabilitiesArtifact(DBService dbService, JSONObject documentInfo,
            JSONObject capabilities, String capabilityArtifactName, String vnfType)
            throws ArtifactHandlerInternalException {

        log.info("Begin-->processAndStoreCapabilitiesArtifact");

        try {
            JSONObject newCapabilitiesObject = new JSONObject();
            newCapabilitiesObject.put("capabilities", capabilities);
            SvcLogicContext context = new SvcLogicContext();
            context.setAttribute(ARTIFACT_NAME, capabilityArtifactName);
            context.setAttribute(FILE_CATEGORY, CAPABILITY);
            context.setAttribute(ACTION, null);
            context.setAttribute(VNFC_TYPE, null);
            context.setAttribute(ARTIFACT_TYPE, null);
            context.setAttribute(VNF_TYPE, vnfType);
            context.setAttribute(ARTIFACT_CONTENTS, newCapabilitiesObject.toString());
            dbService.processSdcReferences(context, dbService.isArtifactUpdateRequired(context, DB_SDC_REFERENCE));
            int intVersion = 0;
            String internalVersion =
                    dbService.getInternalVersionNumber(context, context.getAttribute(ARTIFACT_NAME), null);
            log.info("Internal Version number received from Database: " + internalVersion);
            if (internalVersion != null) {
                intVersion = Integer.parseInt(internalVersion) + 1;
            }
            setAttribute(context, documentInfo::getString, SERVICE_UUID);
            setAttribute(context, documentInfo::getString, DISTRIBUTION_ID);
            setAttribute(context, documentInfo::getString, SERVICE_NAME);
            setAttribute(context, documentInfo::getString, SERVICE_DESCRIPTION);
            setAttribute(context, documentInfo::getString, RESOURCE_UUID);
            setAttribute(context, documentInfo::getString, RESOURCE_INSTANCE_NAME);
            setAttribute(context, documentInfo::getString, RESOURCE_VERSION);
            setAttribute(context, documentInfo::getString, RESOURCE_TYPE);
            setAttribute(context, documentInfo::getString, ARTIFACT_UUID);
            setAttribute(context, documentInfo::getString, ARTIFACT_VERSION);
            setAttribute(context, documentInfo::getString, ARTIFACT_DESRIPTION);
            dbService.saveArtifacts(context, intVersion);
        } catch (Exception e) {
            log.error("Error saving capabilities artifact to DB", e);
            throw new ArtifactHandlerInternalException("Error saving capabilities artifact to DB", e);
        } finally {
            log.info("End-->processAndStoreCapabilitiesArtifact");
        }
    }

    private void setAttribute(SvcLogicContext context, Function<String, String> value, String key) {
        context.setAttribute(key, value.apply(key));
    }

    private void populateProtocolReference(DBService dbservice, JSONObject content)
            throws ArtifactHandlerInternalException {
        log.info("Begin-->populateProtocolReference");
        try {
            SvcLogicContext context = new SvcLogicContext();
            JSONObject scope = content.getJSONObject("scope");
            String vnfType = tryGetVnfType(scope);
            String protocol = tryGetProtocol(content);
            String action = tryGetAction(content);
            String actionLevel = tryGetActionLevel(content);
            String template = tryGetTemplate(content);

            boolean isUpdateNeeded = dbservice.isProtocolReferenceUpdateRequired(context, vnfType, protocol, action,
                    actionLevel, template);
            if (isUpdateNeeded) {
                dbservice.updateProtocolReference(context, vnfType, protocol, action, actionLevel, template);
            } else {
                dbservice.insertProtocolReference(context, vnfType, protocol, action, actionLevel, template);
            }
        } catch (Exception e) {
            log.error("Error inserting record into protocolReference", e);
            throw new ArtifactHandlerInternalException("Error inserting record into protocolReference", e);
        } finally {
            log.info("End-->populateProtocolReference");
        }
    }

    private String tryGetVnfType(JSONObject scope) {
        if (scope.has(VNF_TYPE) && !scope.isNull(VNF_TYPE)) {
            return scope.getString(VNF_TYPE);
        }
        return null;
    }

    private String tryGetProtocol(JSONObject content) {
        if (content.has(DEVICE_PROTOCOL)) {
            return content.getString(DEVICE_PROTOCOL);
        }
        return null;
    }

    private String tryGetAction(JSONObject content) {
        if (content.has(ACTION)) {
            return content.getString(ACTION);
        }
        return null;
    }

    private String tryGetActionLevel(JSONObject content) {
        if (content.has(ACTION_LEVEL)) {
            return content.getString(ACTION_LEVEL);
        }
        return null;
    }

    private String tryGetTemplate(JSONObject content) {
        if (content.has(TEMPLATE) && !content.isNull(TEMPLATE)) {
            return content.getString(TEMPLATE);
        }
        return null;
    }

    protected ArtifactProcessorImpl getArtifactProcessorImpl() {
        return new ArtifactProcessorImpl();
    }
}