node.js.mustache

'use strict';
var lib = require('./lib.js');

module.exports = function (RED) {
    function {{&className}}Node(config) {
        RED.nodes.createNode(this, config);
        {{#hasServiceParams}}
        this.service = RED.nodes.getNode(config.service);
        {{/hasServiceParams}}
        this.method = config.method;
        {{#methods}}
        {{#parameters}}
        this.{{&methodName}}_{{&camelCaseName}} = config.{{&methodName}}_{{&camelCaseName}};
        this.{{&methodName}}_{{&camelCaseName}}Type = config.{{&methodName}}_{{&camelCaseName}}Type || 'str';
        {{/parameters}}
        {{/methods}}
        var node = this;

        node.on('input', function (msg) {
            var errorFlag = false;
            {{#domain}}
            var client = new lib.{{&className}}();
            {{/domain}}
            {{^domain}}
            var client;
            if (this.service && this.service.host) {
                client = new lib.{{&className}}({ domain: this.service.host });
            } else {
                node.error('Host in configuration node is not specified.', msg);
                errorFlag = true;
            }
            {{/domain}}
            {{#isSecure}}
            {{#isSecureToken}}
            if (!errorFlag && this.service && this.service.credentials && this.service.credentials.secureTokenValue) {
                if (this.service.secureTokenIsQuery) {
                    client.setToken(this.service.credentials.secureTokenValue,
                                    this.service.secureTokenHeaderOrQueryName, true);
                } else {
                    client.setToken(this.service.credentials.secureTokenValue,
                                    this.service.secureTokenHeaderOrQueryName, false);
                }
            }
            {{/isSecureToken}}
            {{#isSecureApiKey}}
            if (!errorFlag && this.service && this.service.credentials && this.service.credentials.secureApiKeyValue) {
                if (this.service.secureApiKeyIsQuery) {
                    client.setApiKey(this.service.credentials.secureApiKeyValue,
                                     this.service.secureApiKeyHeaderOrQueryName, true);
                } else {
                    client.setApiKey(this.service.credentials.secureApiKeyValue,
                                     this.service.secureApiKeyHeaderOrQueryName, false);
                }
            }
            {{/isSecureApiKey}}
            {{#isSecureBasic}}
            if (!errorFlag && this.service && this.service.credentials) {
                client.setBasicAuth(this.service.credentials.username, this.service.credentials.password);
            }
            {{/isSecureBasic}}
            {{/isSecure}}
            if (!errorFlag) {
                client.body = msg.payload;
            }

            var result;
            {{#methods}}
            if (!errorFlag && node.method === '{{&methodName}}') {
                var {{&methodName}}_parameters = [];
                var {{&methodName}}_nodeParam;
                var {{&methodName}}_nodeParamType;
                {{#parameters}}
                {{#isBodyParam}}
                if (typeof msg.payload === 'object') {
                    {{&methodName}}_parameters.{{&camelCaseName}} = msg.payload;
                } else {
                    node.error('Unsupported type: \'' + (typeof msg.payload) + '\', ' + 'msg.payload must be JSON object or buffer.', msg);
                    errorFlag = true;
                }
                {{/isBodyParam}}
                {{#isNotBodyParam}}
                {{&methodName}}_nodeParam = node.{{&methodName}}_{{&camelCaseName}};
                {{&methodName}}_nodeParamType = node.{{&methodName}}_{{&camelCaseName}}Type;
                if ({{&methodName}}_nodeParamType === 'str') {
                    {{&methodName}}_parameters.{{&camelCaseName}} = {{&methodName}}_nodeParam || '';
                } else {
                    {{&methodName}}_parameters.{{&camelCaseName}} = RED.util.getMessageProperty(msg, {{&methodName}}_nodeParam);
                }
                {{&methodName}}_parameters.{{&camelCaseName}} = !!{{&methodName}}_parameters.{{&camelCaseName}} ? {{&methodName}}_parameters.{{&camelCaseName}} : msg.payload;
                {{/isNotBodyParam}}
                {{/parameters}}
                result = client.{{&methodName}}({{&methodName}}_parameters);
            }
            {{/methods}}
            if (!errorFlag && result === undefined) {
                node.error('Method is not specified.', msg);
                errorFlag = true;
            }
            var setData = function (msg, data) {
                if (data) {
                    if (data.response) {
                        if (data.response.statusCode) {
                            msg.statusCode = data.response.statusCode;
                        }
                        if (data.response.headers) {
                            msg.headers = data.response.headers;
                        }
                        if (data.response.request && data.response.request.uri && data.response.request.uri.href) {
                            msg.responseUrl = data.response.request.uri.href;
                        }
                    }
                    if (data.body) {
                        msg.payload = data.body;
                    }
                }
                return msg;
            };
            if (!errorFlag) {
                node.status({ fill: 'blue', shape: 'dot', text: '{{&className}}.status.requesting' });
                result.then(function (data) {
                    node.send(setData(msg, data));
                    node.status({});
                }).catch(function (error) {
                    var message = null;
                    if (error && error.body && error.body.message) {
                        message = error.body.message;
                    }
                    node.error(message, setData(msg, error));
                    node.status({ fill: 'red', shape: 'ring', text: 'node-red:common.status.error' });
                });
            }
        });
    }

    RED.nodes.registerType('{{&nodeName}}', {{&className}}Node);
    {{#hasServiceParams}}
    function {{&className}}ServiceNode(n) {
        RED.nodes.createNode(this, n);
        {{^domain}}
        this.host = n.host;
        {{/domain}}

        {{#isSecure}}
        {{#isSecureToken}}
        this.secureTokenValue = n.secureTokenValue;
        this.secureTokenHeaderOrQueryName = n.secureTokenHeaderOrQueryName;
        this.secureTokenIsQuery = n.secureTokenIsQuery;
        {{/isSecureToken}}
        {{#isSecureApiKey}}
        this.secureApiKeyValue = n.secureApiKeyValue;
        this.secureApiKeyHeaderOrQueryName = n.secureApiKeyHeaderOrQueryName;
        this.secureApiKeyIsQuery = n.secureApiKeyIsQuery;
        {{/isSecureApiKey}}
        {{#isSecureBasic}}
        this.username = n.username;
        this.password = n.password;
        {{/isSecureBasic}}
        {{/isSecure}}
    }

    RED.nodes.registerType('{{&nodeName}}-service', {{&className}}ServiceNode, {
        credentials: {
            {{#isSecure}}
            {{#isSecureToken}}
            secureTokenValue: { type: 'password' },
            {{/isSecureToken}}
            {{#isSecureApiKey}}
            secureApiKeyValue: { type: 'password' },
            {{/isSecureApiKey}}
            {{#isSecureBasic}}
            username: { type: 'text' },
            password: { type: 'password' },
            {{/isSecureBasic}}
            {{/isSecure}}
            temp: { type: 'text' }
        }
    });
    {{/hasServiceParams}}
};