fully-api/dist/areas/core/internal_1_0_0.js

API framework for Fully Stacked, LLC REST-ful APIs

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.Internal = void 0;
const fs = require("fs");
let path = require('path');
let rootDir = path.dirname(require.main.filename);
let Q = require('q');
let dataAccess;
let utilities;
let accessControl;
let serviceRegistration;
let settings;
let models;
let config;
let endpoints;
class Internal {
    constructor(db, utils, ac, sr, st, m, e, c) {
        config = c;
        models = m;
        settings = st;
        serviceRegistration = sr;
        accessControl = ac;
        utilities = utils;
        dataAccess = db;
        endpoints = e;
    }
    getPostmanCollcationPath(callback) {
        let deferred = Q.defer();
        let response = {
            exists: false,
            path: ''
        };
        try {
            let path = config.file_locations.postman_collection;
            if (fs.existsSync(path)) {
                path += '/public.zip';
                if (fs.existsSync(path)) {
                    response.exists = true;
                    response.path = path;
                }
            }
            else {
                path = rootDir + "../postman";
                if (fs.existsSync(path)) {
                    path += '/public.zip';
                    if (fs.existsSync(path)) {
                        response.exists = true;
                        response.path = path;
                        deferred.resolve({ exists: true });
                    }
                }
                else {
                    path = rootDir + "/postman";
                    if (fs.existsSync(path)) {
                        path += '/public.zip';
                        if (fs.existsSync(path)) {
                            response.exists = true;
                            response.path = path;
                        }
                    }
                    else {
                        path = "./postman";
                        if (fs.existsSync(path)) {
                            path += '/public.zip';
                            if (fs.existsSync(path)) {
                                response.exists = true;
                                response.path = path;
                            }
                        }
                    }
                }
            }
            deferred.resolve(response);
        }
        catch (e) {
            console.log("An error occurred.");
            deferred.reject(e);
        }
        deferred.promise.nodeify(callback);
        return deferred.promise;
    }
}
exports.Internal = Internal;
;
Internal.prototype.get = {
    health_status(req, callback) {
        let deferred = Q.defer();
        dataAccess.executePostgresQuery("SELECT usename AS role_name FROM pg_catalog.pg_user LIMIT 0", [])
            .then(function (res) {
            deferred.resolve({ sucess: true });
        })
            .fail(function (err) {
            deferred.reject(err);
        });
        deferred.promise.nodeify(callback);
        return deferred.promise;
    },
    header_token_name(req, callback) {
        let deferred = Q.defer();
        deferred.resolve({ token_name: settings.data.token_header });
        deferred.promise.nodeify(callback);
        return deferred.promise;
    },
    models(req, callback) {
        let deferred = Q.defer();
        deferred.resolve(models);
        deferred.promise.nodeify(callback);
        return deferred.promise;
    },
    endpoints(req, callback) {
        let deferred = Q.defer();
        deferred.resolve(utilities.getEndpointData());
        deferred.promise.nodeify(callback);
        return deferred.promise;
    },
    postman_collection(req, callback) {
        let deferred = Q.defer();
        try {
            Internal.prototype.getPostmanCollcationPath()
                .then(function (res) {
                let contents = fs.readFileSync(res.path, { encoding: 'base64' });
                deferred.resolve({ data: contents, filename: settings.data.api_name + '_postman.zip' });
            })
                .fail(function (err) {
                deferred.reject(err);
            });
        }
        catch (e) {
            console.log("An error occurred.");
            deferred.reject(e);
        }
        deferred.promise.nodeify(callback);
        return deferred.promise;
    },
    has_postman_collection(req, callback) {
        let deferred = Q.defer();
        try {
            Internal.prototype.getPostmanCollcationPath()
                .then(function (res) {
                delete res.path;
                deferred.resolve(res);
            })
                .fail(function (err) {
                deferred.reject(err);
            });
        }
        catch (e) {
            console.log("An error occurred.");
            deferred.reject(e);
        }
        deferred.promise.nodeify(callback);
        return deferred.promise;
    },
    readme_md(req, callback) {
        let deferred = Q.defer();
        try {
            let contents = fs.readFileSync(config.file_locations.readme, { encoding: 'base64' });
            deferred.resolve({ data: contents });
        }
        catch (e) {
            try {
                let contents = fs.readFileSync('./README.md', { encoding: 'base64' });
                deferred.resolve({ data: contents });
            }
            catch (e) {
                deferred.reject(e);
            }
        }
        deferred.promise.nodeify(callback);
        return deferred.promise;
    }
};
Internal.prototype.post = {};
Internal.prototype.patch = {};
Internal.prototype.delete = {};
//# sourceMappingURL=internal_1_0_0.js.map