import { ZObject, Bundle } from "zapier-platform-core";
import IAuthenticationScheme from "../interfaces/authentication/IAuthenticationScheme";

const getSessionKey = (z: ZObject, bundle: Bundle) => {
    console.log('GET SESSION called');
    const { username: auth_login, password: auth_password } = bundle.authData;
    return z.request({
        method: 'POST',
        url: 'http://******/perl/auth/login',
        body: { auth_login, auth_password }
    }).then(response => {
        z.console.log(response);
        console.log(response);

        if (response.status === 401) {
            throw new Error('The username/password you supplied is invalid');
        } else {
            return {
                sessionKey: z.JSON.parse(response.content).session_id
            };
        }
    });
};

const includeSessionKeyHeader = (request: any, z: ZObject, bundle: Bundle) => {
    console.log('includeSessionKeyHeader called');

    if (bundle.authData.sessionKey) {
        request.headers = Object.assign({}, request.headers);
        let { Cookie: cookie = '' } = request.headers;
        cookie = `${bundle.authData.sessionKey};${cookie}`;
        request.headers['Cookie'] = cookie;
    }
    return request;
};

const sessionRefreshIf401 = (response: any, z: ZObject, bundle: Bundle) => {
    console.warn('sessionRefreshIf401 called');
    if (bundle.authData.sessionKey) {
        if (response.status === 401) {
            throw new z.errors.RefreshAuthError(); // ask for a refresh & retry
        }
    }
    return response;
};

const test = (z: ZObject, bundle: Bundle) => {
    console.log('test called');
    return z.request({
        url: 'http://******/ruby/features'
    }).then((response) => {
        z.console.log(response);
        if (response.status === 401) {
            throw new Error('The API Key you supplied is invalid');
        }
        return response
    });
};

const authentication: IAuthenticationScheme<any> = {
    type: 'session',
    test,
    fields: [
        {
            key: 'username',
            type: 'string',
            required: true,
            helpText: 'Your login username.'
        },
        {
            key: 'password',
            type: 'string',
            required: true,
            helpText: 'Your login password.'
        }
    ],
    connectionLabel: (z, bundle) => {
        return bundle.inputData.username;
    },
    sessionConfig: {
        perform: getSessionKey
    }
};

export default {
    authentication,
    beforeRequest: { includeSessionKeyHeader },
    afterRequest: { sessionRefreshIf401 }
};

import { should } from "should";
import { describe } from "mocha";
const { version } = require("../../package.json");
import { version as platformVersion } from "zapier-platform-core";
import { createAppTester } from "zapier-platform-core";
import PlackSession from "../authentication/PlackSession";

const App = {
    version,
    platformVersion,
    authentication: PlackSession.authentication,
    beforeRequest: [PlackSession.beforeRequest.includeSessionKeyHeader],
    afterResponse: [PlackSession.afterRequest.sessionRefreshIf401],
};

const appTester = createAppTester(App);

export default () => {
    describe('PlackSession authentication', () => {
        it('should authenticate', done => {
            console.log(`AUTHENTICATE!!`)
            const bundle = {
                authData: {
                    username: 'dev@******.com',
                    password: 'abc123'
                }
            };

            appTester(App.authentication.test, bundle)
                .then(response => {
                    console.log('BBBBBBBB')
                    done();
                })
                .catch(a => {
                    console.log('CCCCCC');
                    done(a)
                });

        });
    });
};

authentication
    PlackSession authentication
AUTHENTICATE!!
test called
includeSessionKeyHeader called
CCCCCC
      1) should authenticate