@syngrisi/syngrisi 2.2.1

package/src/server/lib/ensureLogin/ensureLoggedIn.js

@@ -0,0 +1,223 @@
+/**
+ * Ensure that a user is logged in before proceeding to next route middleware.
+ *
+ * This middleware ensures that a user is logged in.  If a request is received
+ * that is unauthenticated, the request will be redirected to a login page (by
+ * default to `/login`).
+ *
+ * Additionally, `returnTo` will be be set in the session to the URL of the
+ * current request.  After authentication, this value can be used to redirect
+ * the user to the page that was originally requested.
+ *
+ * Options:
+ *   - `redirectTo`   URL to redirect to for login, defaults to _/login_
+ *   - `setReturnTo`  set redirectTo in session, defaults to _true_
+ *
+ * Examples:
+ *
+ *     app.get('/profile',
+ *       ensureLoggedIn(),
+ *       function(req, res) { ... });
+ *
+ *     app.get('/profile',
+ *       ensureLoggedIn('/signin'),
+ *       function(req, res) { ... });
+ *
+ *     app.get('/profile',
+ *       ensureLoggedIn({ redirectTo: '/session/new', setReturnTo: false }),
+ *       function(req, res) { ... });
+ *
+ * @param {Object} options
+ * @return {Function}
+ * @api public
+ */
+const { User } = require('../../models');
+
+const $this = this;
+$this.logMeta = {
+    scope: 'Authentication',
+    msgType: 'LOGIN',
+};
+
+// eslint-disable-next-line consistent-return
+const handleBasicAuth = async (req) => {
+    const logOpts = {
+        scope: 'handleBasicAuth',
+        msgType: 'AUTH_API',
+    };
+
+    if (req.isAuthenticated()) {
+        return { type: 'success', status: 200 };
+    }
+    if (!(await global.AppSettings.isAuthEnabled())) {
+        const guest = await User.findOne({ username: 'Guest' });
+        // noinspection UnnecessaryLocalVariableJS
+        const result = new Promise((resolve) => {
+            req.logIn(guest, (err) => {
+                if (err) {
+                    log.error(`cannot find quest user: '${err}'`, $this, logOpts);
+                    resolve({
+                        type: 'redirect',
+                        status: 301,
+                        value: `/auth?=Error: cannot find quest user: ${err}`,
+                        user: null,
+                    });
+                } else {
+                    resolve({
+                        type: 'success',
+                        status: 200,
+                        value: '',
+                        user: guest,
+                    });
+                }
+            });
+        });
+        return result;
+    }
+
+    const result = {
+        type: 'error',
+        status: 400,
+        value: '',
+        user: null,
+    };
+
+    if ((await global.AppSettings.isAuthEnabled())
+        && ((await global.AppSettings.isFirstRun()))
+        && process.env.SYNGRISI_DISABLE_FIRST_RUN !== '1'
+    ) {
+        log.info('first run, set admin password', $this, logOpts);
+        result.type = 'redirect';
+        result.status = 301;
+        result.value = '/auth/change?first_run=true';
+        return result;
+    }
+
+    if (await global.AppSettings.isAuthEnabled()) {
+        log.info(`user is not authenticated - ${req.originalUrl}`, $this, logOpts);
+
+        result.type = 'redirect';
+        result.status = 301;
+
+        if (req?.originalUrl !== '/') {
+            result.value = `/auth?origin=${encodeURIComponent(req.originalUrl)}`;
+            return result;
+        }
+
+        result.value = '/auth';
+        return result;
+    }
+};
+
+exports.ensureLoggedIn = function ensureLoggedIn() {
+    // eslint-disable-next-line consistent-return
+    return async (req, res, next) => {
+        const result = await handleBasicAuth(req);
+        // log.silly(result, {
+        //     scope: 'ensureLoggedIn',
+        //     msgType: 'AUTH_API',
+        // }, $this);
+        req.user = result.user || req.user;
+        if (result.type === 'success') {
+            return next();
+        }
+        res.status(result.status)
+            .redirect(result.value);
+        return next('redirect');
+    };
+};
+
+const handleAPIAuth = async (hashedApiKey) => {
+    const logOpts = {
+        scope: 'handleAPIAuth',
+        msgType: 'AUTH_API',
+    };
+
+    const result = {
+        status: 400,
+        type: 'error',
+        value: '',
+        user: null,
+    };
+
+    if (!(await global.AppSettings.isAuthEnabled())) {
+        const guest = await User.findOne({ username: 'Guest' });
+
+        if (!guest) {
+            log.error('cannot find Guest user');
+            result.type = 'error';
+            result.value = 'cannot find Guest user';
+            return result;
+        }
+        log.debug('authentication disabled', logOpts, { user: 'Guest' });
+        result.type = 'success';
+        result.user = guest;
+        result.status = 200;
+        return result;
+    }
+
+    if (!hashedApiKey) {
+        log.debug('API key missing', logOpts);
+        result.type = 'error';
+        result.status = 401;
+        result.value = 'API key missing';
+        return result;
+    }
+
+    const user = await User.findOne({ apiKey: hashedApiKey });
+    if (!user) {
+        log.error(`wrong API key: ${hashedApiKey}`, logOpts);
+        result.type = 'error';
+        result.status = 401;
+        result.value = 'wrong API key';
+        return result;
+    }
+    log.debug('authenticated', $this, { ...logOpts, ...{ user: user?.username } });
+    result.type = 'success';
+    result.status = 200;
+    result.user = user;
+    return result;
+};
+
+exports.ensureApiKey = function ensureApiKey() {
+    const logOpts = {
+        scope: 'ensureApiKey',
+        msgType: 'AUTH_API',
+    };
+    // eslint-disable-next-line consistent-return
+    return async (req, res, next) => {
+        log.silly(`headers: ${JSON.stringify(req.headers, null, '..')}`, logOpts);
+        log.silly(`SYNGRISI_AUTH: '${process.env.SYNGRISI_AUTH}'`);
+        const hashedApiKey = req.headers.apikey || req.query.apikey;
+        const result = await handleAPIAuth(hashedApiKey);
+        req.user = req.user || result.user;
+        req.headers.apikey = result?.user?.apiKey || req?.headers?.apikey;
+        if (result.type !== 'success') {
+            log.info(`${result.value} - ${req.originalUrl}`, $this, logOpts);
+            res.status(result.status)
+                .json({ error: result.value });
+            return next(new Error(result.value));
+        }
+        return next();
+    };
+};
+
+exports.ensureLoggedInOrApiKey = () => async (req, res, next) => {
+    const basicAuthResult = await handleBasicAuth(req);
+
+    const hashedApiKey = req.headers.apikey || req.query.apikey;
+    const apiKeyResult = await handleAPIAuth(hashedApiKey);
+    req.user = req.user || apiKeyResult.user;
+
+    if (
+        (basicAuthResult.type !== 'success')
+        && (apiKeyResult.type !== 'success')
+    ) {
+        log.info(`Unauthorized - ${req.originalUrl}`);
+        // res.status(401).json({ error: `${`${apiKeyResult.value} ${basicAuthResult.value}`} - ${req.originalUrl}` });
+        res.status(401)
+            .json({ error: `Unauthorized - ${req.originalUrl}` });
+        return next(new Error(`Unauthorized - ${req.originalUrl}`));
+    }
+    return next();
+};

package/src/server/lib/ensureLogin/ensureLoggedOut.js

@@ -0,0 +1,44 @@
+/**
+ * Ensure that no user is logged in before proceeding to next route middleware.
+ *
+ * This middleware ensures that no user is logged in.  If a request is received
+ * that is authenticated, the request will be redirected to another page (by
+ * default to `/`).
+ *
+ * Options:
+ *   - `redirectTo`   URL to redirect to in logged in, defaults to _/_
+ *
+ * Examples:
+ *
+ *     app.get('/login',
+ *       ensureLoggedOut(),
+ *       function(req, res) { ... });
+ *
+ *     app.get('/login',
+ *       ensureLoggedOut('/home'),
+ *       function(req, res) { ... });
+ *
+ *     app.get('/login',
+ *       ensureLoggedOut({ redirectTo: '/home' }),
+ *       function(req, res) { ... });
+ *
+ * @param {Object} options
+ * @return {Function}
+ * @api public
+ */
+module.exports = function ensureLoggedOut(options) {
+    let opts;
+    if (typeof options === 'string') {
+        opts = { redirectTo: options };
+    }
+    opts = options || {};
+
+    const url = opts.redirectTo || '/';
+
+    return function (req, res, next) {
+        if (req.isAuthenticated && req.isAuthenticated()) {
+            return res.redirect(url);
+        }
+        return next();
+    };
+};

package/src/server/lib/getElementsByPixPositionsFromDump.js

@@ -0,0 +1,72 @@
+const getElementsByPositionFromDump = function getElementsByPositionFromDump(x, y, dump, offset = 1) {
+    return new Promise(function (resolve, reject) {
+        try {
+            // check if position is gets into dumped elements rects boundaries
+            let data = dump
+                .filter(function (item) {
+                    return (x >= item.left) &&
+                        (x <= item.right) &&
+                        (y >= item.top) &&
+                        (y <= item.bottom);
+                })
+                .sort((a, b) => (a.domPath.length) < (b.domPath.length) ? 1 : -1);
+            if (data.length < 1) {
+                return resolve(null);
+            }
+            const pos = data[0];
+            return resolve({
+                tag: pos.tag,
+                id: pos.id,
+                x: pos.x,
+                y: pos.y,
+                width: pos.width,
+                height: pos.height,
+                domPath: pos.domPath,
+                request: `${x}, ${y}`
+            });
+        } catch (e) {
+            return reject(e);
+        }
+    });
+};
+const getAllElementsByPositionFromDump = function getAllElementsByPositionFromDump(dump, positions) {
+    return new Promise(function (resolve, reject) {
+        try {
+            let executionTimer = process.hrtime();
+            console.log(`Start parse elements from dump based on diff`);
+            let promResults = [];
+            for (const position of positions) {
+                const el = getElementsByPositionFromDump(position.x, position.y, dump);
+                promResults.push(el);
+
+            }
+            console.log(`Promises formed, time: ${process.hrtime(executionTimer)
+                .toString()}`);
+
+            let dumpResults = {};
+            Promise.all(promResults)
+                .then((values) => {
+                    console.log(`Promises resolved, time: ${process.hrtime(executionTimer)
+                        .toString()}`);
+                    for (el of values) {
+                        // to make dump unique
+                        if (el !== null) {
+                            const key = `${el.tag}_${el.id}_${el.x}_${el.y}_${el.width}_${el.height}_${el.domPath.toString()}`;
+                            dumpResults[key] = el;
+                        }
+                    }
+                    console.log(`End parse elements from dump based on diff, time: '${process.hrtime(executionTimer)
+                        .toString()}'`);
+                    return resolve(Object.values(dumpResults)
+                        .map(x => x));
+                });
+        } catch (e) {
+            reject(e);
+        }
+    });
+};
+
+module.exports = {
+    getElementsByPositionFromDump: getElementsByPositionFromDump,
+    getAllElementsByPositionFromDump: getAllElementsByPositionFromDump,
+};

package/src/server/lib/guest.json

@@ -0,0 +1,9 @@
+{
+  "username": "Guest",
+  "role": "user",
+  "firstName": "Syngrisi",
+  "lastName": "Guest",
+  "salt": "861d0193d9a4cd27597d672dd73100b1218cc7629c59bf18f9faef4480d1f58a",
+  "password": "cdd8541c318008fe0eee35d311b428c666d7ddf78722735e40b21b0b9e734eabe1b60f6db6deb8f3f101ed559a7365a497bfa73156ba3fadcbb14c5cae441edfe301568a47320abcda308920fecc482b1082468fd2197893561f5d174ecafdfb930bdc8e070fbed07353231d255616d3072e899a4ae1e6ff71f171edc34ba871d091b657a3207b571d2db0f3fce1fb2bc48942657d35aac7fa1fc2ebcbacdc00e46b184e1e5e4988171bcd843f7bb4adb2920df06c4f6b830154234350f9d65cc6e10d445a242c2149a3ce24458bd741035629bb73bdf29e0db4dcd3e37d85332d58d58674ca56b632294135a3354705b3281ea7564b962d544cfcee7069f3065c394098e11999385b077755f9c7e3d42f55b23ecb3366187d3a8ce2475615fbd06d707020274d7f50fe6c824e589955a667210fa031828f832e3cc050d1c0c5360647bfd88d411d3f76e8c6d9c610e2bc5a22da498888d2c94ad25b6448ca2eb9606210b2018136116fda6fdd87b24bcdfe86daefcdaa97d1f9e3a102188a4314a5a4018599cc70dab82157f5d88f7ada008a1f8e0d6e8abf51ed87ebdab982c01645f4f907414d1bb13b1fac410648cc2e94554ecbe0f472aee26623888878139bd44e109d5ce673ecfbe71269d22bea55a03ad4409fc8578de6001f5601fab4cf800be1d420f76586ed9c31214f30c632de99260256c9d2ce45476c135d32",
+  "apiKey": "4ba2659e94f48ce771a78ee479dc3ab12c2cc6d2484c967b4c564f0a1718a8a254f6aaec3169eb7b29e7d2542d73d378339e311cf912e46fe67eac4eef44636c"
+}

package/src/server/lib/initialAppSettings.json

@@ -0,0 +1,18 @@
+[
+    {
+        "name": "first_run",
+        "label": "First Run",
+        "description": "Indicates if the application is running the first time",
+        "type": "Boolean",
+        "value": "true",
+        "enabled": true
+    },
+    {
+        "name": "authentication",
+        "label": "Authentication",
+        "description": "Enable application authentication",
+        "type": "Boolean",
+        "value": "false",
+        "enabled": true
+    }
+]

package/src/server/lib/logger.js

@@ -0,0 +1,95 @@
+const winston = require('winston');
+require('winston-mongodb');
+const {
+    blue,
+    gray,
+    magenta,
+} = require('chalk');
+const { formatISOToDateTime } = require('../utils');
+
+const logLevel = process.env.SYNGRISI_LOG_LEVEL ? process.env.SYNGRISI_LOG_LEVEL : '';
+
+module.exports.Logger = class Logger {
+    constructor(opts) {
+        this.connectionString = opts.connectionString;
+        this.winstonLogger = winston.createLogger({
+            transports: [
+                new winston.transports.Console({
+                    level: logLevel || 'silly',
+                    format: winston.format.combine(
+                        winston.format.colorize(),
+                        winston.format.timestamp(),
+                        winston.format.ms(),
+                        winston.format.metadata(),
+                        winston.format.printf((info) => {
+                            const user = info.metadata.user ? blue(` <${info.metadata.user}>`) : '';
+                            const ref = info.metadata.ref ? gray(` ${info.metadata.ref}`) : '';
+                            const msgType = info.metadata.msgType ? ` ${info.metadata.msgType}` : '';
+                            const itemType = info.metadata.itemType ? magenta(` ${info.metadata.itemType}`) : '';
+                            const scope = info.metadata.scope ? magenta(` [${info.metadata.scope}] `) : '';
+                            const msg = typeof info.message === 'object'
+                                ? `\n${JSON.stringify(info.message, null, 2)}`
+                                : info.message;
+
+                            // return `${info.level} ${scope}${formatISO9075(parseISO(info.metadata.timestamp))} `
+                            return `${info.level} ${scope}${formatISOToDateTime(info.metadata.timestamp)} `
+                                + `${info.metadata.ms}${user}${ref}${msgType}${itemType} '${msg}'`;
+                        }),
+                        winston.format.padLevels(),
+                    ),
+                }),
+                new winston.transports.MongoDB({
+                    level: logLevel || 'debug',
+                    format: winston.format.combine(
+                        winston.format.timestamp(),
+                        winston.format.json(),
+                        winston.format.metadata(),
+                    ),
+                    options: {
+                        useUnifiedTopology: true,
+                    },
+                    db: opts.dbConnectionString,
+                    collection: 'vrslogs',
+                    storeHost: true,
+                    meta: true,
+                }),
+            ],
+        });
+    }
+
+    static merge(meta, context) {
+        if ((meta?.ref) && (typeof meta?.ref) !== 'string') {
+            // eslint-disable-next-line no-param-reassign
+            meta.ref = meta.ref.toString();
+        }
+        if (context?.logMeta) {
+            // return Object.assign(context.logMeta, meta);
+            return { ...context.logMeta, ...meta };
+        }
+        return meta;
+    }
+
+    error(msg, context, meta) {
+        this.winstonLogger.error(`${msg}\n stacktrace: ${new Error().stack}`, Logger.merge(meta, context));
+    }
+
+    warn(msg, context, meta) {
+        this.winstonLogger.warn(`${msg}\n stacktrace: ${new Error().stack}`, Logger.merge(meta, context));
+    }
+
+    info(msg, context, meta) {
+        this.winstonLogger.info(msg, Logger.merge(meta, context));
+    }
+
+    verbose(msg, context, meta) {
+        this.winstonLogger.verbose(msg, Logger.merge(meta, context));
+    }
+
+    debug(msg, context, meta) {
+        this.winstonLogger.debug(msg, Logger.merge(meta, context));
+    }
+
+    silly(msg, meta, context) {
+        this.winstonLogger.silly(msg, Logger.merge(meta, context));
+    }
+};

package/src/server/lib/onStart.js

@@ -0,0 +1,53 @@
+/* eslint-disable no-underscore-dangle */
+// this code should run only once at server start
+const fs = require('fs');
+// eslint-disable-next-line no-unused-vars
+const testUsers = require('./testUsers.json');
+const { User } = require('../models');
+
+const $this = this;
+$this.logMeta = {
+    scope: 'on_start',
+    msgType: 'SETUP',
+};
+
+exports.createTempDir = function createTempDir() {
+    const dir = '.tmp';
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir);
+    }
+};
+
+exports.createInitialSettings = async function createInitialSettings() {
+    if ((await global.AppSettings.count()) < 1) {
+        await global.AppSettings.loadInitialFromFile();
+    }
+};
+
+exports.createBasicUsers = async function createBasicUsers() {
+    const defAdmin = await User.findOne({ username: 'Administrator' }).exec();
+    const defGuest = await User.findOne({ username: 'Guest' }).exec();
+    if (!defAdmin) {
+        log.info('create the default Administrator', $this);
+        const adminData = JSON.parse(fs.readFileSync(`${__dirname}/admin.json`));
+
+        const admin = await User.create(adminData);
+        log.info(`administrator with id: '${admin._id}' was created`, $this);
+    }
+    if (!defGuest) {
+        log.info('create the default Guest', $this);
+        const guestData = JSON.parse(fs.readFileSync(`${__dirname}/guest.json`));
+        const guest = await User.create(guestData);
+        log.info(`guest with id: '${guest._id}' was created`, $this);
+    }
+};
+
+exports.createTestsUsers = async function createTestsUsers() {
+    const users = require('./testUsers.json');
+    log.debug('creating tests users', $this);
+    try {
+        await User.insertMany(users);
+    } catch (e) {
+        console.warn(e);
+    }
+};

package/src/server/lib/parseDiff.js.bak

@@ -0,0 +1,72 @@
+const Canvas = require('canvas');
+
+const loop = function loop(w, h, callback) {
+    let x;
+    let y;
+
+    for (x = 0; x < w; x++) {
+        for (y = 0; y < h; y++) {
+            callback(x, y);
+        }
+    }
+};
+
+const parseDiff = function (dataDiff) {
+    console.log('Start parse diff - prepare data');
+    Img = Canvas.Image;
+    let image = new Img();
+    image.src = dataDiff;
+    const width = image.width;
+    const height = image.height;
+
+    const canvas = Canvas.createCanvas(width, height);
+    const ctx = canvas.getContext('2d');
+    ctx.drawImage(image, 0, 0);
+
+    const sourceImageData = ctx.getImageData(0, 0, width, height).data;
+
+    let diffPixCount = 0;
+    let allPixCount = 0;
+    let positions = [];
+    let s = {};
+    console.log('Start collect diff pixel positions');
+    loop(width, height, async function (horizontalPos, verticalPos) {
+        let offset = (verticalPos * width + horizontalPos) * 4;
+        let red = sourceImageData[offset];
+        let green = sourceImageData[offset + 1];
+        let blue = sourceImageData[offset + 2];
+        let alpha = sourceImageData[offset + 3];
+        if (!s[`${red}, ${green}, ${blue}, ${alpha}`]) {
+            s[`${red}, ${green}, ${blue}, ${alpha}`] = 1;
+        }
+
+        s[`${red}, ${green}, ${blue}, ${alpha}`] = s[`${red}, ${green}, ${blue}, ${alpha}`] + 1;
+
+        if
+        (
+            ((red === 252) && (green === 0) && (blue === 236)) ||
+            ((red === 196) && (green === 0) && (blue === 132)) ||
+            ((red === 255) && (green === 0) && (blue === 255))
+        ) {
+
+            diffPixCount++;
+            positions.push({
+                x: horizontalPos,
+                y: verticalPos
+            });
+        }
+
+        allPixCount++;
+    });
+    console.log(s);
+    console.log(`'${diffPixCount}' diff pixels positions  of '${allPixCount}' was collected`);
+    console.log('Start sorting pixel positions by "y"');
+    const out = positions.sort((a, b) => (a.y > b.y) ? 1 : -1);
+    console.log('End of sorting');
+    return out;
+};
+
+module.exports = {
+    parseDiff,
+    loop,
+};

package/src/server/lib/testAdmin.json

@@ -0,0 +1,9 @@
+{
+  "username": "Test",
+  "firstName": "Test",
+  "lastName": "Admin",
+  "role": "admin",
+  "password": "7c68c97c24f19fd760234b20fea21a9db0ef982f50d24ae356379193ecb649e1b819810f7d3640c20002b7cabe357be7723cc30be8197a5cad6ecb2712badd07938a3010637dc5c64e91b58adc4b2a20a58ab4c3d67c8a028e19829bdc88b4d6d98a393b75272f5b6d4ab5a4e5a9770957f963f6b53d52b428d8e2de06b6bc51eea4b6a415780f68184dabaf288492200587e78ab7f3769f7073ef1ba047c8038207bce2a5cc9dd69a59805becd3c9dda7a95d7defa3a745fffc3d7a3efa25d2ddb90e85722c91237b5333fe98c3bf106d85516947a3655d05fa0f83da07c6eb0c9b69d27f48f2bf25475c02ab94a777e4850c7c40883f1a7a471c6a928a3bfbf8eba560bf9750e6f270f3001480cc54090ec8685c6dbf6d73cc6ad157646698feb494c275fca2c71dc1f30f3d2c38837491dc327cb0fcceb98d8cb1cba9c509bf49e9c7ad65f5ac0aa515ca96e722ee6ba1da8a610f7c013b330b8ba9fee21942b7827d623eafbf22e5de2505dd72c7e69cc1c3bed8015ae1fe3ea1e7fc65104f0875b78d3bb57d50a267f29933c1fa00424a7e1f9d5f1b913aab317adf488a32d7098fd54825c5c90e813094fbc7bca89c86d72301a22dbfeada0cd98a30cba8f98f56bcb5d8089bd3e93e558179bd7e1f535012e732144a68803d38f1f52a86ade86b1434c4b94b1bb7daffc3fb4b9937b9b3d63cb660cd4332ca91a37a86",
+  "apiKey": "12345",
+  "salt": "7410d0bd960fba56427745742d1a5cb64cd1ce769f611ed9efec7bca13b56f6b"
+}

package/src/server/lib/testUsers.json

@@ -0,0 +1,41 @@
+[
+    {
+        "PASSWORD_": "Test-123",
+        "API_KEY_": "GV640BD-9CG4RDB-NY8WH76-NJB5599",
+        "username": "testreviewer@test.com",
+        "firstName": "Test",
+        "lastName": "Reviewer",
+        "role": "reviewer",
+        "password": "152046e9cd34cdcd6cea5e66a9ec3fd262f61056b51e4a82d4fe8d6dacaa71fa8419e4b16bc11dfad9d2d90a8b8f4eb79b8e0dc93bededa7d8524521b122392dde0b4e9ca3bccb23b9bade5eb991d78d98246c009e983af42274f9d701c313ef8c47f23fea7701063a19be77f7d31c7cd537ee8f3bc31e861a81cc88bb2f47424e2903d06c99cf053e3be21d191075c92eaee48e1f964ace6357d7f5fea5412e56b26331f9e67354e3f0e0937f826011ddb0058a6c59021c9b7880b5c0ecdbaef1f8491e78288a00ff5ab5fa3e58528794f1bd84f097e8dccc8a8c3a15f760389d9b57f5313c63f68688ad44b53727d1c6e2078824e3c042ccfc6351772737807f46b7e24e30d8c48c1a1a55a3eb0d465d657004e17060afe4b354a4f3946b3dce8c105a2d521cd2c63161af0c039d41c212165c6133fe3b24d8ccdc82045450ce8e189d03ec7bb948bd0ad22140089d6f63352833b56232d7cad498efb65fb609077b6de73beb8e946fe54d7b417cefef0a07e26cbf33a7c58323f414aeaa4b83118e19bffdb3eb6d4f5150f1901b340c16e71c2683d7c6faede630396c4c92ba12485c6c8e00ecb3be785604ce41fdf42315cf02ad7f96eff2b018b415b1550f50756ace62965cadd4080a3e4bd8e3d70042bb3a5f0ba8ab357bfad9290af6a93236f294b3e7547295227b8d5b33cca35393d4b76e750805249b81b2a186aa",
+        "apiKey": "9aa20a336f91ea6c9657c3391934227059d4c28d2c7924813176ac4f6633d9c65baee77ca6f34c0d13e574ec285b54fd23c10b26abefec7df981e2884f91a84c",
+        "createdDate": "2022-09-19T15:23:09.360+04:00",
+        "updatedDate": null,
+        "salt": "09067fc22c1b821db81bc83c33f217cd8a54cb8f370d1da4a12d8be867a66b93"
+    },
+    {
+        "PASSWORD_": "Test-123",
+        "API_KEY_": "NTSAEXR-CZ1MFWD-KY0Q3MG-HY6SKD1",
+        "username": "testuser@test.com",
+        "firstName": "Test",
+        "lastName": "User",
+        "role": "user",
+        "password": "60271a5363308e14af295c0ce34818ce32781296d10908f941d8c9589dced5b193f6e1a1962c4e5e718c00974497baa5a3fd6a797bf2cc91e7f76018711c1a7a35809c04fa92b256987f0835601b789609311c862f4c91220741fc30bd79aff25c0b0565834ca16cd313e45fc1b5846f25cabab695680edd739a85b479fbf51c2f860fd427003b10e5bec0b7bf776bfed7b6dbe33a3ca666e69995f4160ddc54e00075b1844807529f0fd8bf650eab71bf6732fd91018cfaedf950d94fd75cfe2b758c3610fb5ab1b863e119073637b33aeaf781e33ed1c73a050f8b8e540761f205d5b19347039599d647a25f1ba7d1422bf3029f9a35b8eb8633db09afd807d18a6ff22d55862e7aa401538eb705fca451fee132324bc05aff3eab10d6031a5e21ff4c6e3a6cb03c32730e1e8b550ebab0ca39942277782b32f9399a14c2876a2a01acecd70f819cce77407b1fee231d5674dd6dc8d9c56a38e9f50e4271e2d9725d830b6f187009726179cb6d1d67c614461bb294003b23f7979f16dbcc71ad9ab9285d7aa4a5550d15915d34ac50dee6fa7f2b90113a3cbf83a92811df0dee1f97c92328273cb8556136219569286666a1bc49c86c9e0e8175cf564168ada14e9f14c174f45789cc68667cecfda6f5d343f79d12ac4c0934f189dab0c8b6c29d01488a8dd0f37dcbba34ec45a9be8c52230189804beecf52603ce22ec95d",
+        "apiKey": "c45d0a87c4eea0f6ace90f1f780761f3e4daa9f11b5bc3732cb9014ad269a4bafa73c7ae6af891dd0fcc3e7ecaee40ca6236948ede1a3eb9c84757cd18c06bc3",
+        "createdDate": "2022-09-19T15:22:23.631+04:00",
+        "updatedDate": null,
+        "salt": "c23b0eafe172a9d1fad3651f02ae256a2f6932faac09fd1f4385c1f406c8c83f"
+    },
+    {
+        "PASSWORD_": "Test-123",
+        "API_KEY_": "3APH5SM-X9G4T6G-H3ZZNQ2-55G4REB",
+        "username": "testadmin@test.com",
+        "firstName": "Test",
+        "lastName": "Admin",
+        "role": "admin",
+        "password": "5046e8420581be0c726c1cade6b6e15fe7cb0c34dad070d3a3030ed12d79d7a56b1217916522cd8813f578d8b24571dab848f22e774abb1db70f4fb725249694afa25c3733decd78fa4d5ab875ec0de43cbbe511ea6b059482f721f96d437622374f715ea316e2f03dc40d7217b1951f6022bdff89b17357b24706306ad38115db2aab3f8a609d172f734cabd7ca5eddcaa772d4cca8b6338c86edd639b91e9fdac3b17be22b3c010eac7c9cac128b675b87ec39fa5b8fea0593137df01eca1678d197d4ed536eb209b83c477a7cd62e9e8e06b8459ebefcd267fc38d7705313303d3b038e31996b66e54415494db34544c617f03740feecc3427f7a92ebcc50e10f45f38a01c6ccbc182bf5b5c48b7eb33432f86d14d6972afcdafa5aab2d82a1b49a559c63a5a719e4fbdaa8eaad0c80cb3bec83f16854b4280b13f1976b24b7ca52d18118eec3546038b8e682aa3005f091927f64905122e41f95e9b729afbd833771e1b802dd962bbda3d5ccd0c8966da7cd902db6a3283d1a631195cdc2efa032ddfb69d924ccb3a4808b21b424dee46abc7f07edfbe2c9e9092d1d6f0da828ca98734909ed8d40802f5403d5e9070c356c594b4758759400b263601237192c6de2fd321fa9e480f2261cac7b3cd3ac2b41289a79f90efa17b890d7ff3f391654e62a7bbc557b9dc03824acdbcdb760e8209c74d29d827fc3c75de5468c",
+        "apiKey": "db6e323f7f559a62aa8cd3838b1cdd3c95acc0b064bfd21f6810b2aa6c147ae8e45ebbc49f7e720d31f0bd18d71ab05eaeedd343d1f345c35d18fbf685db91cb",
+        "createdDate": "2022-09-19T15:19:19.825+04:00",
+        "updatedDate": null,
+        "salt": "a7e22101f6886dbdf07fc01d92e633d8b323f5d868a6d1214c7f9a12f266a2b2"
+    }
+]