@atomist/skill/lib/parameter_prompt.js

"use strict";
/*
 * Copyright © 2020 Atomist, Inc.
 *
 * 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.
 */
Object.defineProperty(exports, "__esModule", { value: true });
const cloneDeep = require("lodash.clonedeep");
const map = require("lodash.map");
const set = require("lodash.set");
/**
 * Different strategies to ask for parameters in chat or web
 */
var ParameterStyle;
(function (ParameterStyle) {
    /** Parameter questions will be prompted in a dialog */
    ParameterStyle["Dialog"] = "dialog";
    /** Parameter questions will be prompted in a thread */
    ParameterStyle["Threaded"] = "threaded";
    /**
     * Parameter questions will be prompted in the channel where the
     * command is being run
     */
    ParameterStyle["Unthreaded"] = "unthreaded";
    /**
     * Parameter questions will be prompted in a dialog if the command
     * is triggered from a button or menu
     */
    ParameterStyle["DialogAction"] = "dialog_action";
})(ParameterStyle = exports.ParameterStyle || (exports.ParameterStyle = {}));
exports.AtomistContinuationMimeType = "application/x-atomist-continuation+json";
/**
 * Default ParameterPromptFactory that uses the WebSocket connection to send parameter prompts to the backend.
 * @param ctx
 */
function commandRequestParameterPromptFactory(messageClient, payload) {
    return async (parameters, options = {}) => {
        var _a, _b, _c;
        const existingParameters = payload.parameters;
        const newParameters = cloneDeep(parameters);
        // Find out if - and if - which parameters are actually missing
        let requiredMissing = false;
        const params = {};
        for (const parameter in parameters) {
            const existingParameter = existingParameters.find(p => p.name === parameter);
            if (!existingParameter) {
                // If required isn't defined it means the parameter is required
                if (newParameters[parameter].required || newParameters[parameter].required === undefined) {
                    requiredMissing = true;
                }
            }
            else {
                params[parameter] = existingParameter.value;
                delete newParameters[parameter];
            }
        }
        // If no parameters are missing we can return the already collected parameters
        if (!requiredMissing) {
            return params;
        }
        // Set up the thread_ts for this response message
        let threadTs;
        if (options.thread === true && !!payload.source) {
            threadTs = (_c = (_b = (_a = payload === null || payload === void 0 ? void 0 : payload.source) === null || _a === void 0 ? void 0 : _a.slack) === null || _b === void 0 ? void 0 : _b.message) === null || _c === void 0 ? void 0 : _c.ts;
        }
        else if (typeof options.thread === "string") {
            threadTs = options.thread;
        }
        const destination = cloneDeep(payload.source);
        set(destination, "slack.thread_ts", threadTs);
        // Create a continuation message using the existing HandlerResponse and mixing in parameters
        // and parameter_specs
        const response = {
            api_version: "1",
            correlation_id: payload.correlation_id,
            team: payload.team,
            command: payload.command,
            source: payload.source,
            destinations: [destination],
            parameters: payload.parameters,
            auto_submit: options.autoSubmit ? options.autoSubmit : undefined,
            question: options.parameterStyle ? options.parameterStyle.toString() : undefined,
            parameter_specs: map(newParameters, (v, k) => (Object.assign(Object.assign({}, v), { name: k, required: v.required !== undefined ? v.required : true, pattern: v.pattern ? v.pattern.source : undefined }))),
            content_type: exports.AtomistContinuationMimeType,
        };
        await messageClient.respond(response);
        throw new CommandListenerExecutionInterruptError("Prompting for parameters");
    };
}
exports.commandRequestParameterPromptFactory = commandRequestParameterPromptFactory;
class CommandListenerExecutionInterruptError extends Error {
    constructor(message) {
        super(message);
        this.message = message;
    }
}
exports.CommandListenerExecutionInterruptError = CommandListenerExecutionInterruptError;
//# sourceMappingURL=parameter_prompt.js.map