datahub-restful-core/routes/util.js

'use strict';

const debug = require('debug')('krh:route:util');

/**
 * result wrapper for ui purpose
 * @param result
 * @param options
 * @returns {{content: *, page: {size: null, totalElements: *, totalPages: number, number: *}, size: null, totalElements: *, totalPages: number, number: *}}
 */
const wrapPagingResult = exports.wrapPagingResult = function (result, options) {
    return {
        content: result,
        page: {
            size: options.limit,
            totalElements: options.count,
            totalPages: options.limit == 0 ? 0 : Math.ceil(options.count / options.limit),
            number: options.page ? options.page : 0
        },
        size: options.limit,
        totalElements: options.count,
        totalPages: options.limit == 0 ? 0 : Math.ceil(options.count / options.limit),
        number: options.page ? options.page : 0
    };
}


exports.halWrapper = function (entity) {
    return {
        "_links": {
            "self": {
                "href": "/api/v1/" + entity + "{?page,size,sort}",
                "templated": true
            },
            "search": {
                "href": "/api/v1/" + entity + "/search"
            }
        }
    };
}

exports.sortResolver = function () {

    var promise = new Promise((resolve, reject) => {

        if (this.query['_sort']) {
            var sortColumns = this.query['_sort'].split(',');
            var order = [];

            sortColumns.forEach((sortColumn) => {
                if (sortColumn.indexOf('-') === 0) {
                    var actualName = sortColumn.substring(1).replace(/[;*,'"]/g, '');
                    order.push(actualName + ' DESC');
                } else {
                    order.push(sortColumn + ' ASC');
                }
            });
            resolve(order);
        } else {
            this.state.connection(this.state.entity).select('*').from('information_schema.columns')
                .where({'table_name': this.state.entity, 'table_schema': this.state.schema}).then((columns) => {
                debug('Use first column for sorting, %o', columns);
                if(columns.length == 0){
                    debug("Sort resolved failed because cannot find column definitions of", this.state.schema, this.state.entity);
                    resolve([]);
                }else{
                    resolve([columns[0].COLUMN_NAME]);
                }

            });
        }
    });

    return promise;
}

exports.parsePk = function (ids, idField) {
    let pkParams = {};
    ids = ids.filter((e) => idField.filter((e1) => e1 == e[0]));
    debug('Ids %o', ids);

    ids.forEach((e) => {
        let value = e[1]
        let pk = e[0]
        try {
            value = decodeURIComponent(value)
        } catch (e) {
            // ignore, user source value
        }
        pkParams[pk] = value
    });
    return pkParams;
}

exports.appendClause = function (table, queryObjs) {

    let firstClause = true;

    for (let column in queryObjs) {

        let queryObj = queryObjs[column];
        let sqlParameter = convertToSqlParameter(queryObj);

        if (firstClause) {
            table[queryObj.whereType.replace('W', 'w')].apply(table, sqlParameter.clause);
        } else {
            if(!table[sqlParameter.condition]){
                sqlParameter.condition = sqlParameter.condition.replace('andW', 'w');
            }
            table[sqlParameter.condition].apply(table, sqlParameter.clause);
        }
        firstClause = false;
    }

    return table;
}

const convertToSqlParameter = function (queryObj) {

    let clause = [queryObj.columnName, queryObj.operatorAlias, queryObj.value];
    if (typeof queryObj.value === 'function') {
        clause = [queryObj.columnName];
    }
    if (queryObj.whereType.search('In') > -1) {
        clause = [queryObj.columnName, queryObj.value];
    }
    if (queryObj.whereType.search('Between') > -1) {
        clause = [queryObj.columnName, queryObj.value];
    }

    return {
        condition: queryObj.condition + queryObj.whereType,
        clause: clause
    }
}