com.ionos.go.plugin.notifier.ValidateConfigurationHandler Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of go-gchat-notifier Show documentation
GoCD plugin to send notifications to GChat when pipeline states change
There is a newer version: 0.5.9
package com.ionos.go.plugin.notifier;

import com.google.gson.Gson;
import com.ionos.go.plugin.notifier.message.GoPluginApiRequestHandler;
import com.ionos.go.plugin.notifier.message.incoming.StageStatusRequest;
import com.ionos.go.plugin.notifier.message.incoming.ValidateConfigurationRequest;
import com.ionos.go.plugin.notifier.message.outgoing.ValidateConfigurationResponse;
import com.ionos.go.plugin.notifier.template.TemplateHandler;
import com.ionos.go.plugin.notifier.util.Helper;
import com.ionos.go.plugin.notifier.util.JsonUtil;
import com.thoughtworks.go.plugin.api.logging.Logger;
import com.thoughtworks.go.plugin.api.request.GoPluginApiRequest;
import com.thoughtworks.go.plugin.api.response.DefaultGoPluginApiResponse;
import lombok.NonNull;

import java.io.IOException;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;

import static com.ionos.go.plugin.notifier.util.JsonUtil.fromJsonString;
import static com.ionos.go.plugin.notifier.util.JsonUtil.toJsonString;
import static com.thoughtworks.go.plugin.api.response.DefaultGoPluginApiResponse.success;

class ValidateConfigurationHandler implements GoPluginApiRequestHandler {
    private static final Logger LOGGER = Logger.getLoggerFor(GoNotifierPlugin.class);

    private final Map serverInfo;

    ValidateConfigurationHandler(@NonNull Map serverInfo) {
        this.serverInfo = serverInfo;
    }

    /** Creates sample objects for testing the condition and the template with.
     * */
    private List newSampleStageStatusRequests() throws IOException {
        List response = new ArrayList<>();

        Gson gson = new Gson();
        StageStatusRequest success = JsonUtil.fromJsonString(
                Helper.readResource("/sampleSuccess.json"),
                StageStatusRequest.class);
        response.add(success);

        StageStatusRequest failed = JsonUtil.fromJsonString(
                Helper.readResource("/sampleFailed.json"),
                StageStatusRequest.class);
        response.add(failed);

        return response;
    }

    @Override
    public DefaultGoPluginApiResponse handle(@NonNull GoPluginApiRequest request) {
        LOGGER.info("Request: " + request.requestBody());
        ValidateConfigurationRequest validateRequest = fromJsonString(request.requestBody(), ValidateConfigurationRequest.class);
        List response = new ArrayList<>();

        if (validateRequest.getPluginSettings() != null) {
            if (validateNonNull(validateRequest, response, Constants.PARAM_WEBHOOK_URL)) {
                validateWebhookUrl(validateRequest, response);
            }
            if (validateNonNull(validateRequest, response, Constants.PARAM_CONDITION)) {
                validateCondition(validateRequest, response);
            }
            if (validateNonNull(validateRequest, response, Constants.PARAM_TEMPLATE)) {
                validateTemplate(validateRequest, response);
            }
            validateProxyUrl(validateRequest, response);
        } else {
            return DefaultGoPluginApiResponse.error("Illegal request");
        }

        return success(toJsonString(response));
    }

    private static boolean validateNonNull(ValidateConfigurationRequest validateRequest, List response, String parameterName) {
        if (validateRequest != null) {
            if (validateRequest.getPluginSettings() != null) {
                Map valueMap = validateRequest.getPluginSettings().get(parameterName);
                if (valueMap != null) {
                    if (valueMap.get(Constants.FIELD_VALUE) != null) {
                        return true;
                    } else {
                        response.add(new ValidateConfigurationResponse(parameterName, "Request pluginSettings parameter '"+parameterName+"' value is missing"));
                    }
                } else {
                    response.add(new ValidateConfigurationResponse(parameterName, "Request pluginSettings parameter '"+parameterName+"' is null"));
                }
            } else {
                response.add(new ValidateConfigurationResponse(parameterName, "Request pluginSettings is null"));
            }
        } else {
            response.add(new ValidateConfigurationResponse(parameterName, "Request is null"));
        }
        return false;
    }


    private static void validateProxyUrl(ValidateConfigurationRequest validateRequest, List response) {
        if (validateRequest == null
                || validateRequest.getPluginSettings() == null
                || validateRequest.getPluginSettings().get(Constants.PARAM_PROXY_URL) == null
                || validateRequest.getPluginSettings().get(Constants.PARAM_PROXY_URL).get(Constants.FIELD_VALUE) == null) {
            return;
        }
        String proxyUrl = validateRequest.getPluginSettings().get(Constants.PARAM_PROXY_URL).get(Constants.FIELD_VALUE);
        if (!proxyUrl.isEmpty()) {
            try {
                new URL(proxyUrl);
            } catch (MalformedURLException e) {
                response.add(new ValidateConfigurationResponse(Constants.PARAM_PROXY_URL, "Malformed url: " + e.getMessage()));
            }
        }
    }

    private void validateTemplate(ValidateConfigurationRequest validateRequest, List response) {
        String template = validateRequest.getPluginSettings().get(Constants.PARAM_TEMPLATE).get(Constants.FIELD_VALUE);
        if (template.isEmpty()) {
            response.add(new ValidateConfigurationResponse(Constants.PARAM_TEMPLATE, Constants.PARAM_TEMPLATE + " is empty"));
        } else {
            try {
                TemplateHandler handler = new TemplateHandler("template", template);
                for (StageStatusRequest sample : newSampleStageStatusRequests()) {
                    handler.eval(sample, serverInfo);
                }
            }
            catch (Exception e) {
                LOGGER.warn("Exception in " + Constants.PARAM_TEMPLATE, e);
                response.add(new ValidateConfigurationResponse(Constants.PARAM_TEMPLATE, "Malformed template: " + e.getMessage()));
            }
        }
    }

    private void validateCondition(ValidateConfigurationRequest validateRequest, List response) {
        String condition = validateRequest.getPluginSettings().get(Constants.PARAM_CONDITION).get(Constants.FIELD_VALUE);
        if (condition.isEmpty()) {
            response.add(new ValidateConfigurationResponse(Constants.PARAM_CONDITION, Constants.PARAM_CONDITION + " is empty"));
        } else {
            try {
                String nonTrueOrFalse = null;
                TemplateHandler handler = new TemplateHandler(Constants.PARAM_CONDITION, condition);
                for (StageStatusRequest sample : newSampleStageStatusRequests()) {
                    String shouldBeBool = handler.eval(sample, serverInfo);
                    if (!(shouldBeBool.equals("true") || shouldBeBool.equals("false"))) {
                        nonTrueOrFalse = shouldBeBool;
                    }
                }
                if (nonTrueOrFalse != null) {
                    response.add(new ValidateConfigurationResponse(Constants.PARAM_CONDITION, "Condition should eval to true or false, but evals to: " + nonTrueOrFalse));
                }
            }
            catch (Exception e) {
                LOGGER.warn("Exception in " + Constants.PARAM_CONDITION, e);
                response.add(new ValidateConfigurationResponse(Constants.PARAM_CONDITION, "Malformed condition: " + e.getMessage()));
            }
        }
    }

    private static void validateWebhookUrl(ValidateConfigurationRequest validateRequest, List response) {
        try {
            String webhookUrl = validateRequest.getPluginSettings().get(Constants.PARAM_WEBHOOK_URL).get(Constants.FIELD_VALUE);
            new URL(webhookUrl);
        } catch (NullPointerException | MalformedURLException e) {
            response.add(new ValidateConfigurationResponse(Constants.PARAM_WEBHOOK_URL, "Malformed url: " + e.getMessage()));
        }
    }

}