@manyos/smileconnect-api 1.28.0

package/util/arquery.js

@@ -0,0 +1,416 @@
+require('dotenv').config();
+const request = require('request-promise-native');
+const path = require('path');
+const log = require('@manyos/logger').setupLog('SMILEconnect_' + path.basename(__filename));
+
+async function deleteEntries(form, baseQuery, query) {
+    let fullQuery = query;
+    if (baseQuery)
+        fullQuery = baseQuery + " AND " + query;
+    fullQuery = encodeURIComponent(fullQuery);
+    let port = 0;
+
+    if (process.env.AR_PORT && process.env.AR_PORT != undefined)
+        port = process.env.AR_PORT;
+
+    let uri = process.env.BASEURL
+        + "/" + process.env.AR_SERVER
+        + "/" + form
+        + "/" + fullQuery
+        + "?port=" + port;
+
+    log.debug('start delete on:', uri);
+
+    let options = {
+        method: 'DELETE',
+        uri: uri,
+        json: true // Automatically stringifies the body to JSON
+    };
+
+    const value = await request(options).auth(process.env.AR_USER, process.env.AR_PASSWORD, true);
+    log.debug('request done', uri, value);
+
+    if (value && value.status && value.status === 'error') {
+        throw new Error(value);
+    }
+    return value;
+}
+
+async function executeARQuery(form, baseQuery, query, fields, options) {
+    let fullQuery = query;
+    if (baseQuery)
+        fullQuery = "(" + baseQuery + ") AND " + query;
+    fullQuery = encodeURIComponent(fullQuery);
+    let port = 0;
+
+    log.debug('Use options for query', options);
+
+    const limits = {};
+
+    limits.globalDefault = Number.parseInt(process.env.LIMIT_DEFAULT);
+    limits.globalMax = Number.parseInt(process.env.LIMIT_MAX);
+    if (options) {
+        limits.clientMax = Number.parseInt(options.clientLimit);
+        limits.clientRequested = Number.parseInt(options.limit);
+    }
+    const limit = getLimits(limits);
+
+    if (process.env.AR_PORT && process.env.AR_PORT != undefined)
+        port = process.env.AR_PORT;
+
+    let uri = process.env.BASEURL
+        + "/" + process.env.AR_SERVER
+        + "/" + form
+        + "/" + fullQuery
+        + "?port=" + port
+        + "&fields=" + fields;
+
+    if (options != null && options != undefined) {
+        if (options.dateFormat != null && options.dateFormat != undefined) {
+            uri = uri + "&dateFormat=" + options.dateFormat;
+        }
+        if (options.offset != null && options.offset != undefined) {
+            uri = uri + "&firstEntry=" + options.offset;
+        }
+
+        if (options.sort != null && options.sort != undefined) {
+            const sortString = prepareSortString(options.sort);
+            if (sortString != null && sortString != undefined) {
+                uri = uri + "&sort=" + sortString;
+            }
+        }
+
+        if (options.impersonateUser) {
+            uri = uri + "&impersonateUser=" + options.impersonateUser;
+        }
+
+        if (options.translateSelectionFields !== undefined && options.translateSelectionFields === false) {
+            uri = uri + "&translateSelectionFields=false";
+        }
+    }
+    //Use limit
+    if (limit) {
+        uri = uri + "&maxEntries=" + limit;
+    }
+    log.debug('start request on:', uri);
+
+    const value = await request(uri).auth(process.env.AR_USER, process.env.AR_PASSWORD, true);
+    log.debug('request done', uri, value);
+
+    if (value && value.status && value.status === 'error') {
+        throw new Error(value);
+    }
+    const result = JSON.parse(value);
+    if (result.status && result.status === 'success') {
+        result.data = result.data.map(x => x.values);
+    }
+    return result;
+}
+
+async function getMetaData(form) {
+    let port = 0;
+
+    if (process.env.AR_PORT && process.env.AR_PORT != undefined)
+        port = process.env.AR_PORT;
+
+    let uri = process.env.BASEURL
+        + "/" + process.env.AR_SERVER;
+
+    if (form != null && form != undefined) {
+        uri = uri + '/' + form;
+    }
+
+    log.debug('start metadata request on:', uri);
+
+    const value = await request(uri).auth(process.env.AR_USER, process.env.AR_PASSWORD, true);
+    log.debug('request done', uri, value);
+
+    if (value && value.status && value.status === 'error') {
+        throw new Error(value);
+    }
+    const result = JSON.parse(value);
+    if (result.status && result.status === 'success') {
+        if (result.forms) {
+            return result.forms;
+        } else if (result.fields) {
+            return result.fields;
+        }
+    }
+    return result;
+}
+
+function getLimits(limits) {
+    log.debug('Defined limits', limits);
+    const max = limits.clientMax || limits.globalMax;
+    const requested = limits.clientRequested || limits.globalDefault;
+    log.debug('max', max);
+    log.debug('requested', requested);
+    let limit = undefined;
+    if (max && requested) {
+        if (requested > max) {
+            limit = max;
+        } else {
+            limit = requested;
+        }
+    } else if (requested) {
+        limit = requested;
+    } else if (max) {
+        limit = max;
+    } else {
+        limit = undefined;
+    }
+    log.debug('Use limit', limit);
+    return limit;
+}
+
+function prepareSortString(sortOptions) {
+    log.debug('prepare sortString', sortOptions);
+    const sortArray = [];
+    Object.keys(sortOptions).forEach(sortKey => {
+        if (sortOptions[sortKey] === -1) {
+            sortArray.push('-'+sortKey);
+        } else {
+            sortArray.push(sortKey);
+        }
+    });
+    log.debug('sortString', sortArray.toString());
+    return sortArray.toString();
+}
+
+//todo add impersonate
+function createEntry(form, entryData, clientOptions) {
+    let port = 0;
+    if (process.env.AR_PORT && process.env.AR_PORT != undefined)
+        port = process.env.AR_PORT;
+    //Apply mapping
+    log.debug('Data to create new entry', entryData);
+    let entries = [];
+    if (!Array.isArray(entryData)) {
+        entries.push(entryData);
+    } else {
+        entries = entryData;
+    }
+
+    const finalEntries = {};
+    let i = 0;
+    for (i=0;i<entries.length;i++) {
+        finalEntries[i] = entries[i];
+    }
+    log.debug('New Entry', finalEntries);
+    //log.debug('object', Object.keys(entryData));
+    return new Promise((resolve, reject) => {
+        let uri = process.env.BASEURL
+            + "/" + process.env.AR_SERVER
+            + "/" + form
+            + "?port=" + port;
+
+        if (clientOptions && clientOptions.impersonateUser) {
+            uri = uri + "&impersonateUser=" + clientOptions.impersonateUser;
+        }
+
+        let options = {
+            method: 'POST',
+            uri: uri,
+            body: finalEntries,
+            timeout: 6000000, // 10 min.
+            json: true // Automatically stringifies the body to JSON
+        };
+
+        log.debug('start request with:', options.body);
+        log.debug('start request on:', uri);
+        const singleRecord = Object.keys(finalEntries).length == 1;
+        request(options).auth(process.env.AR_USER, process.env.AR_PASSWORD, true)
+            .then(function (response) {
+                log.debug('RAPI return', response[0]);
+                //check for error on single record
+                if (singleRecord) {
+                    if (response[0].startsWith('null - ')) {
+                        reject(response[0]);
+                    }
+                }
+                resolve(response);
+
+            }).catch(function (error) {
+                log.error(error);
+                reject(error);
+            });
+    });
+}
+
+function setAttachment(form, entryId, attachmentfield, fileData) {
+    //log.debug ('file', fileData);
+    let port = 0;
+    if (process.env.AR_PORT && process.env.AR_PORT != undefined)
+        port = process.env.AR_PORT;
+
+    return new Promise((resolve, reject) => {
+        const uri = process.env.BASEURL
+            + "/" + process.env.AR_SERVER
+            + "/" + form
+            + "/setAttachment"
+            + "/" + entryId
+            + "/" + attachmentfield
+            + "?port=" + port;
+
+        const myFormData = {};
+        myFormData[fileData.name] = {
+            value: fileData.data,
+            options: {
+                filename: fileData.name,
+                contentType: fileData.mimetype
+            }
+        };
+
+
+        var options = {
+            method: 'POST',
+            uri: uri,
+            timeout: 600000, // 10 min.
+            formData: myFormData
+        };
+
+        log.debug('start attachment request on:', uri);
+        request(options).auth(process.env.AR_USER, process.env.AR_PASSWORD, true)
+            .then(function (response) {
+                log.debug('RAPI return', response);
+                //TODO check for status and reject if Error -> Achtug array
+                resolve(response);
+            })
+            .catch(function (error) {
+                log.error(error);
+                reject(error);
+            });
+    });
+}
+
+function getAttachment(form, entryId, attachmentfield) {
+    //log.debug ('file', fileData);
+    let port = 0;
+    if (process.env.AR_PORT && process.env.AR_PORT != undefined)
+        port = process.env.AR_PORT;
+
+    return new Promise((resolve, reject) => {
+        const uri = process.env.BASEURL
+            + "/" + process.env.AR_SERVER
+            + "/" + form
+            + "/getAttachment"
+            + "/" + entryId
+            + "/" + attachmentfield
+            + "?port=" + port;
+
+        var options = {
+            method: 'Get',
+            uri: uri,
+            encoding: null,
+            resolveWithFullResponse: true,
+            timeout: 600000 // 10 min.
+        };
+
+        log.debug('start attachment request on:', uri);
+        request(options).auth(process.env.AR_USER, process.env.AR_PASSWORD, true)
+            .then(function (response) {
+                log.debug('RAPI return', response.headers);
+                const fileName = response.headers['content-disposition'].split(';')[1].split('=')[1];
+                log.debug('filename', fileName);
+                const file = {
+                    data : response.body,
+                    fileName : fileName
+                }
+                resolve(file);
+            })
+            .catch(function (error) {
+                log.error(error);
+                reject(error);
+            });
+    });
+}
+
+function applyMapping(entryData, mapping, constants) {
+    Object.keys(entryData).forEach(function (objectKey) {
+        const found = mapping.find(function(element) {
+            return element.newName === objectKey;
+        });
+
+        if (found == null || found=== undefined) {
+            log.debug('delete', objectKey)
+            delete entryData[objectKey];
+        }
+    });
+    mapping.forEach(function (mappingEntry) {
+        try {
+            Object.defineProperty(entryData, mappingEntry.oldName, Object.getOwnPropertyDescriptor(entryData, mappingEntry.newName));
+            //delete mapping only if no self mapping
+            if (!(mappingEntry.newName == mappingEntry.oldName)) {
+                delete entryData[mappingEntry.newName];
+            }
+        } catch (e) {
+            //ignore missing mapping
+        }
+    });
+    //add constant values (defaults)
+    if (constants && Array.isArray(constants) && constants.length) {
+
+        constants.forEach(function (element) {
+            log.debug('add constant', element);
+            try {
+                entryData[element.name] = element.value;
+            } catch (e) {
+                log.error(e);
+            }
+        });
+    }
+    return entryData;
+}
+
+function updateEntry(form, id, entryData) {
+    let port = 0;
+    if (process.env.AR_PORT && process.env.AR_PORT != undefined)
+        port = process.env.AR_PORT;
+    //Apply mapping
+    log.debug('Data to update entry with id: ' + id, entryData);
+    //entryData = applyMapping(entryData, mapping, constants);
+    const myEntry = {};
+    myEntry.id = id;
+    myEntry.values = entryData;
+    //Create record data. Use field id to identify each record
+    log.debug('New Entry', myEntry);
+    //log.debug('object', Object.keys(entryData));
+    return new Promise((resolve, reject) => {
+        const uri = process.env.BASEURL
+            + "/" + process.env.AR_SERVER
+            + "/" + form
+            + "?port=" + port;
+
+
+        var options = {
+            method: 'PUT',
+            uri: uri,
+            body: myEntry,
+            timeout: 6000000, // 10 min.
+            json: true // Automatically stringifies the body to JSON
+        };
+
+        log.debug('start request with:', options.body);
+        log.debug('start request on:', uri);
+        request(options).auth(process.env.AR_USER, process.env.AR_PASSWORD, true)
+            .then(function (response) {
+                log.debug('RAPI update return', response);
+                const singleRecord = Object.keys(response).length == 1;
+                if (singleRecord) {
+                    if (response[0].startsWith('null - ')) {
+                        reject(response[0]);
+                    }
+                }
+                //TODO check for status and reject if Error
+                resolve(response);
+            })
+            .catch(function (error) {
+                log.error(error);
+                reject(error);
+            });
+    });
+}
+
+module.exports = {
+    executeARQuery, createEntry, updateEntry, setAttachment, getAttachment, deleteEntries, getMetaData
+};

package/util/auth.js

@@ -0,0 +1,37 @@
+require('dotenv').config();
+const path = require('path');
+const log = require('@manyos/logger').setupLog('SMILEconnect_' + path.basename(__filename));
+
+function isAuthorizedAdmin(req, res, next) {
+    log.debug(req.user);
+    const admins = process.env.ADMIN_USERS;
+    if (admins !== null
+        && admins !== undefined
+        && req.user !== null
+        && req.user !== undefined
+        && isUserInList(admins, req.user.username)) {
+        log.debug('user authorized');
+        next();
+    } else {
+        const err = new Error('Not authorized as admin!');
+        err.status = 401;
+        return next(err);
+    }
+}
+
+function isUserInList(userList, userName) {
+    log.debug('Check if user is in List', userName, userList)
+    if (userList !== null && userList !== undefined && userName !== null && userName !== undefined) {
+        let userArray = userList.split(',');
+        userArray = userArray.map(item => {
+            return item.trim();
+        });
+        log.debug(userArray.includes(userName.trim()));
+        return (userArray.includes(userName.trim()));
+    }
+    return false;
+}
+
+module.exports = {
+    isAuthorizedAdmin
+}

package/util/cache.service.js

@@ -0,0 +1,52 @@
+const NodeCache = require ('node-cache/index');
+const path = require('path');
+const log = require('@manyos/logger').setupLog('SMILEconnect_' + path.basename(__filename));
+
+class Cache {
+
+    constructor(ttlSeconds) {
+        log.debug('cache created. ttl seconds:', ttlSeconds);
+        this.cache = new NodeCache({ stdTTL: ttlSeconds, checkperiod: ttlSeconds * 0.2, useClones: false });
+    }
+
+    get(key, storeFunction) {
+        const value = this.cache.get(key);
+        if (value) {
+            return Promise.resolve(value);
+        }
+
+        return storeFunction().then((result) => {
+            this.cache.set(key, result);
+            return result;
+        });
+    }
+
+    del(keys) {
+        log.debug('Delete cache keys', keys);
+        this.cache.del(keys);
+    }
+
+    delStartWith(startStr = '') {
+        if (!startStr) {
+            return;
+        }
+
+        const keys = this.cache.keys();
+        for (const key of keys) {
+            if (key.indexOf(startStr) === 0) {
+                this.del(key);
+            }
+        }
+    }
+
+    flush() {
+        this.cache.flushAll();
+    }
+
+    getTtl(key) {
+        return this.cache.getTtl(key);
+    }
+}
+
+
+module.exports = Cache;