vrack2-core 0.0.1

package/lib/validator/types/BasicType.js

@@ -0,0 +1,54 @@
+"use strict";
+/*
+ * Copyright © 2022 Boris Bobylev. All rights reserved.
+ * Licensed under the Apache License, Version 2.0
+*/
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const ErrorManager_1 = __importDefault(require("../../errors/ErrorManager"));
+class BasicType {
+    constructor() {
+        this.rule = {
+            type: '',
+            require: false,
+            default: undefined,
+            rules: [],
+            example: undefined,
+            description: ''
+        };
+    }
+    require() {
+        this.rule.require = true;
+        return this;
+    }
+    example(ex) {
+        this.rule.example = ex;
+        return this;
+    }
+    description(desc) {
+        this.rule.description = desc;
+        return this;
+    }
+    export() {
+        return this.rule;
+    }
+    static validate(obj, key, rule) {
+        BasicType.checkDefault(obj, key, rule);
+        BasicType.checkRequire(obj, key, rule);
+        return true;
+    }
+    static checkDefault(obj, key, rule) {
+        if (rule.default === undefined)
+            return;
+        if (obj[key] === undefined)
+            obj[key] = rule.default;
+    }
+    static checkRequire(obj, key, rule) {
+        if (obj[key] === undefined)
+            throw ErrorManager_1.default.make('VR_ERROR_REQUAERED', { key });
+    }
+}
+exports.default = BasicType;
+ErrorManager_1.default.register('Validator', 'Jwg5Mr1NqaSj', 'VR_ERROR_REQUAERED', 'A value is required', {});

package/lib/validator/types/NumberType.d.ts

@@ -0,0 +1,19 @@
+import BasicType from "./BasicType";
+import IValidationRule from "../IValidationRule";
+import IValidationSubrule from "../IValidationSubrule";
+export default class NumberType extends BasicType {
+    constructor();
+    default(def: number): this;
+    integer(): this;
+    max(max: number): this;
+    min(min: number): this;
+    static validate(obj: {
+        [key: string]: any;
+    }, key: string, rule: IValidationRule): boolean;
+    protected static checkMax(obj: {
+        [key: string]: any;
+    }, key: string, sub: IValidationSubrule): void;
+    protected static checkMin(obj: {
+        [key: string]: any;
+    }, key: string, sub: IValidationSubrule): void;
+}

package/lib/validator/types/NumberType.js

@@ -0,0 +1,66 @@
+"use strict";
+/*
+ * Copyright © 2022 Boris Bobylev. All rights reserved.
+ * Licensed under the Apache License, Version 2.0
+*/
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const BasicType_1 = __importDefault(require("./BasicType"));
+const ErrorManager_1 = __importDefault(require("../../errors/ErrorManager"));
+class NumberType extends BasicType_1.default {
+    constructor() {
+        super();
+        this.rule.type = 'number';
+    }
+    default(def) {
+        this.rule.default = def;
+        return this;
+    }
+    integer() {
+        this.rule.rules.push({ name: 'integer', args: {} });
+        return this;
+    }
+    max(max) {
+        this.rule.rules.push({ name: 'max', args: max });
+        return this;
+    }
+    min(min) {
+        this.rule.rules.push({ name: 'max', args: min });
+        return this;
+    }
+    static validate(obj, key, rule) {
+        BasicType_1.default.validate(obj, key, rule);
+        if (typeof obj[key] !== 'number')
+            throw ErrorManager_1.default.make('VR_IS_NOT_NUMBER', { key });
+        if (!Number.isInteger(obj[key]))
+            throw ErrorManager_1.default.make('VR_NUMBER_INTEGER', {});
+        for (const subrule of rule.rules) {
+            switch (subrule.name) {
+                case 'max':
+                    NumberType.checkMax(obj, key, subrule);
+                    break;
+                case 'min':
+                    NumberType.checkMin(obj, key, subrule);
+                    break;
+            }
+        }
+        return true;
+    }
+    static checkMax(obj, key, sub) {
+        const val = obj[key];
+        if (val.length > sub.args)
+            throw ErrorManager_1.default.make('VR_NUMBER_MAX', { limit: sub.args });
+    }
+    static checkMin(obj, key, sub) {
+        const val = obj[key];
+        if (val.length < sub.args)
+            throw ErrorManager_1.default.make('VR_NUMBER_MIN', { limit: sub.args });
+    }
+}
+exports.default = NumberType;
+ErrorManager_1.default.register('Validator', 'pn7B9po1UGRp', 'VR_IS_NOT_NUMBER', 'Value must be a number', {});
+ErrorManager_1.default.register('Validator', 'fiUqanqqFlnt', 'VR_NUMBER_INTEGER', 'Value must be a integer', {});
+ErrorManager_1.default.register('Validator', 'ZFSMAes0qdzC', 'VR_NUMBER_MAX', 'Number out of limit', {});
+ErrorManager_1.default.register('Validator', 'B3zqsPub40HH', 'VR_NUMBER_MIN', 'Number out of limit', {});

package/lib/validator/types/ObjectType.d.ts

@@ -0,0 +1,18 @@
+import BasicType from "./BasicType";
+import IValidationRule from "../IValidationRule";
+import IValidationSubrule from "../IValidationSubrule";
+export default class ObjectType extends BasicType {
+    constructor();
+    fields(obj: {
+        [key: string]: BasicType;
+    }): number;
+    static validate(obj: {
+        [key: string]: any;
+    }, key: string, rule: IValidationRule): boolean;
+    /**
+     * Validate object fields
+    */
+    protected static subValidate(obj: {
+        [key: string]: any;
+    }, key: string, sub: IValidationSubrule): void;
+}

package/lib/validator/types/ObjectType.js

@@ -0,0 +1,51 @@
+"use strict";
+/*
+ * Copyright © 2022 Boris Bobylev. All rights reserved.
+ * Licensed under the Apache License, Version 2.0
+*/
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const BasicType_1 = __importDefault(require("./BasicType"));
+const ErrorManager_1 = __importDefault(require("../../errors/ErrorManager"));
+const Validator_1 = __importDefault(require("../Validator"));
+const CoreError_1 = __importDefault(require("../../errors/CoreError"));
+class ObjectType extends BasicType_1.default {
+    constructor() {
+        super();
+        this.rule.type = 'object';
+    }
+    fields(obj) {
+        return this.rule.rules.push({ name: 'fields', args: obj });
+    }
+    static validate(obj, key, rule) {
+        BasicType_1.default.validate(obj, key, rule);
+        if (typeof obj[key] !== 'object')
+            throw ErrorManager_1.default.make('VR_IS_NOT_OBJECT', {});
+        for (const subrule of rule.rules) {
+            switch (subrule.name) {
+                case 'fields':
+                    ObjectType.subValidate(obj, key, subrule);
+                    break;
+            }
+        }
+        return true;
+    }
+    /**
+     * Validate object fields
+    */
+    static subValidate(obj, key, sub) {
+        try {
+            Validator_1.default.validate(sub.args, obj[key]);
+        }
+        catch (error) {
+            if (error instanceof CoreError_1.default) {
+                throw ErrorManager_1.default.make('VR_ERROR_OBJECT_FIELDS', { key }).add(error);
+            }
+        }
+    }
+}
+exports.default = ObjectType;
+ErrorManager_1.default.register('Validator', 'zOPzOab9oLum', 'VR_IS_NOT_OBJECT', 'Value must be a object', {});
+ErrorManager_1.default.register('Validator', 'p7qSfRGixV0M', 'VR_ERROR_OBJECT_FIELDS', 'Error of validation of fields inside the object', {});

package/lib/validator/types/StringType.d.ts

@@ -0,0 +1,19 @@
+import BasicType from "./BasicType";
+import IValidationRule from "../IValidationRule";
+import IValidationSubrule from "../IValidationSubrule";
+export default class StringType extends BasicType {
+    constructor();
+    example(ex: string): this;
+    default(def: string): this;
+    maxLength(max: number): this;
+    minLength(min: number): this;
+    static validate(obj: {
+        [key: string]: any;
+    }, key: string, rule: IValidationRule): boolean;
+    protected static checkMaxLength(obj: {
+        [key: string]: any;
+    }, key: string, sub: IValidationSubrule): void;
+    protected static checkMinLength(obj: {
+        [key: string]: any;
+    }, key: string, sub: IValidationSubrule): void;
+}

package/lib/validator/types/StringType.js

@@ -0,0 +1,63 @@
+"use strict";
+/*
+ * Copyright © 2022 Boris Bobylev. All rights reserved.
+ * Licensed under the Apache License, Version 2.0
+*/
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const BasicType_1 = __importDefault(require("./BasicType"));
+const ErrorManager_1 = __importDefault(require("../../errors/ErrorManager"));
+class StringType extends BasicType_1.default {
+    constructor() {
+        super();
+        this.rule.type = 'string';
+    }
+    example(ex) {
+        this.rule.example = ex;
+        return this;
+    }
+    default(def) {
+        this.rule.default = def;
+        return this;
+    }
+    maxLength(max) {
+        this.rule.rules.push({ name: 'maxLength', args: max });
+        return this;
+    }
+    minLength(min) {
+        this.rule.rules.push({ name: 'minLength', args: min });
+        return this;
+    }
+    static validate(obj, key, rule) {
+        BasicType_1.default.validate(obj, key, rule);
+        if (typeof obj[key] !== 'string')
+            throw ErrorManager_1.default.make('VR_IS_NOT_STRING', { key });
+        for (const subrule of rule.rules) {
+            switch (subrule.name) {
+                case 'maxLength':
+                    StringType.checkMaxLength(obj, key, subrule);
+                    break;
+                case 'minLength':
+                    StringType.checkMinLength(obj, key, subrule);
+                    break;
+            }
+        }
+        return true;
+    }
+    static checkMaxLength(obj, key, sub) {
+        const val = obj[key];
+        if (val.length >= sub.args)
+            throw ErrorManager_1.default.make('VR_STRING_MAX_LENGTH', { limit: sub.args, key });
+    }
+    static checkMinLength(obj, key, sub) {
+        const val = obj[key];
+        if (val.length <= sub.args)
+            throw ErrorManager_1.default.make('VR_STRING_MIN_LENGTH', { limit: sub.args, key });
+    }
+}
+exports.default = StringType;
+ErrorManager_1.default.register('Validator', 'klmjxHyQrWuH', 'VR_IS_NOT_STRING', 'Value must be a string', {});
+ErrorManager_1.default.register('Validator', 'BL5lxR4BinkA', 'VR_STRING_MAX_LENGTH', 'The maximum string length is limited', {});
+ErrorManager_1.default.register('Validator', 'KsijTdsbd2YN', 'VR_STRING_MIN_LENGTH', 'The minimum string length is limited', {});

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "vrack2-core",
+  "version": "0.0.1",
+  "description": "VRack2 core utils",
+  "main": "./lib/index",
+  "scripts": {
+    "test": "node ./lib/test.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://gitlab.com/vrack/core-utils.git"
+  },
+  "author": "Boris Bobylev",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://gitlab.com/vrack/core-utils/issues"
+  },
+  "homepage": "https://gitlab.com/vrack/core-utils#readme",
+  "devDependencies": {
+    "@types/node": "^18.11.17",
+    "@typescript-eslint/eslint-plugin": "^5.45.0",
+    "@typescript-eslint/parser": "^5.45.0",
+    "eslint": "^8.29.0",
+    "typescript": "^4.9.3"
+  }
+}

package/src/Container.ts

@@ -0,0 +1,237 @@
+import EventEmitter from "events";
+import DeviceManager from "./DeviceManager";
+
+import ErrorManager from "./errors/ErrorManager";
+import IServiceStructure from "./IServiceStructure";
+import IStructureDevice from "./IStructureDevice";
+import Device from "./service/Device";
+import Rule from "./validator/Rule";
+import CoreError from "./errors/CoreError";
+import Validator from "./validator/Validator";
+import BasicAction from "./actions/BasicAction";
+import ImportManager from "./ImportManager";
+import DevicePort from "./service/DevicePort";
+
+import IPort from "./ports/IPort";
+import DeviceConnect from "./service/DeviceConnect";
+
+
+ErrorManager.register('Container', 'FBDRkSAWnlcc', 'CTR_ERROR_INIT_DEVICE', 'Device initialization error', {
+    deviceConfig: Rule.object().description('Device configuration')
+})
+
+ErrorManager.register('Container', '96UX24PTyFU7', 'CTR_ERROR_INIT_CONNECTION', 'Connection initialization error', {
+    connection: Rule.string().description('Connection string')
+})
+
+
+ErrorManager.register('Container', '0HVa3cO1E2vB', 'CTR_INCORRECT_DEVICE_ID', 'Incorrect device id', {})
+ErrorManager.register('Container', 'uF62e07wloS9', 'CTR_DEVICE_DUBLICATE', 'Device id is dublicated', {})
+ErrorManager.register('Container', '2RZznI3JDNUW', 'CTR_ERROR_PREPARE_OPTIONS', 'An error occurred while preparing options', {
+    message: Rule.string().description('Exception error string')
+})
+ErrorManager.register('Container', 'NDW2oD7mFxqB', 'CTR_DEVICE_ACTION_NF', 'Action on device not found', {
+    action: Rule.string().description('Action name'),
+    method: Rule.string().description('Method name')
+})
+ErrorManager.register('Container', 'jkIpU1p4z5uz', 'CTR_INCORRECT_DYNAMIC_PN', 'Incorrect dynamic port name', {
+    port: Rule.string().description('Incorrect port name')
+})
+ErrorManager.register('Container', 'e8m8dUVVOEU7', 'CTR_INCORRECT_PN', 'Incorrect port name', {
+    port: Rule.string().description('Incorrect port name')
+})
+ErrorManager.register('Container', 'qPevPU6SRJ18', 'CTR_INPUT_HANDLER_NF', 'Port input handler not found', {
+    port: Rule.string().description('Port name for handler'),
+    handler: Rule.string().description('Handler name')
+})
+ErrorManager.register('Container', 'Kp74OuVGNU0u', 'CTR_CONNECTION_INCORRECT', 'Incorrect connection format', {
+    connection: Rule.string().description('Connection string'),
+    error: Rule.string().description('String of error problem'),
+})
+ErrorManager.register('Container', 'eMrJEISxvali', 'CTR_CONNECTION_DEVICE_NF', 'Connection device not found', {
+    connection: Rule.string().description('Connection string'),
+    device: Rule.string().description('Device name not found')
+})
+ErrorManager.register('Container', 'CwFj1G47H45E', 'CTR_CONNECTION_PORT_NF', 'Connection port not found', {
+    connection: Rule.string().description('Connection string'),
+    port: Rule.string().description('Port name not found')
+})
+
+export default class Container extends EventEmitter {
+    protected config: IServiceStructure
+    protected DeviceManager: DeviceManager
+    protected devices: { [key: string]: Device } = {}
+    protected deviceActions: { [key: string]: { [key: string]: BasicAction } }
+
+    constructor(config: IServiceStructure, dm: DeviceManager) {
+        super()
+        this.config = config
+        this.DeviceManager = dm
+        this.deviceActions = {}
+    }
+
+    async run() {
+
+        for (const device of this.config.devices) {
+            try {
+                await this.initDevice(device)
+            } catch (error) {
+                const ner = ErrorManager.make('CTR_ERROR_INIT_DEVICE', { deviceConfig: device })
+                if (error instanceof CoreError) ner.add(error)
+                throw ner
+            }
+        }
+
+        for (const conn of this.config.connections) {
+            try {
+                await this.initConnection(conn)
+            } catch (error) {
+                const ner = ErrorManager.make('CTR_ERROR_INIT_CONNECTION', { connection: conn })
+                if (error instanceof CoreError) ner.add(error)
+                throw ner
+            }
+        }
+
+        for (const key in this.devices) this.devices[key].process()
+        for (const key in this.devices) await this.devices[key].processPromise()
+        
+
+        // const cs = await this.DeviceManager.get('vrack.Master')
+        // const cse = new cs()
+        // console.log(cse)
+        // cse.run()
+    }
+
+
+    protected async initDevice(dconf: IStructureDevice) {
+        const cs = await this.DeviceManager.get(dconf.type)
+        // 
+        if (dconf.id === undefined || !dconf.id || typeof dconf.id !== 'string') {
+            throw ErrorManager.make('CTR_INCORRECT_DEVICE_ID')
+        }
+        // Device id is dublicated
+        if (dconf.id in this.devices) throw ErrorManager.make('CTR_DEVICE_DUBLICATE')
+        const dev = new cs(dconf.id, dconf.type, this) as Device
+        this.devices[dconf.id] = dev
+        // Fill options
+        for (const key in dconf.options) dev.options[key] = dconf.options[key]
+
+        // try prepare options
+        try {
+            dev.prepareOptions()
+        } catch (error) {
+            let message = ''
+            if (error instanceof Error) message = error.toString()
+            const ner = ErrorManager.make('CTR_ERROR_PREPARE_OPTIONS', { message })
+            if (error instanceof CoreError) ner.add(error)
+            throw ner
+        }
+
+        const rules = dev.checkOptions()
+        // Validating
+        Validator.validate(rules, dev.options)
+        
+        dev.preProcess()
+
+        // Check actions 
+        this.deviceActions[dev.id] = dev.actions()
+        for (const action in this.deviceActions[dev.id]) {
+            const method = ImportManager.camelize('action.' + action)
+            if (!(method in dev)) throw ErrorManager.make('CTR_DEVICE_ACTION_NF', { action, method })
+        }
+
+
+        // make ports
+        // prepare ports
+
+        // make inputPorts
+        const iPorts = dev.inputs()
+        for (const key in iPorts) {
+            const exp = iPorts[key].export()
+            const pList = this.getPortList(key, exp)
+            for (const subkey in pList) {
+                this.checkPortName(subkey)
+                const handler = ImportManager.camelize('input.' + subkey) as keyof Device
+                this.checkInputHandler(subkey, handler , dev)
+                const ndp = new DevicePort(subkey, pList[subkey])
+                dev.ports.input[subkey] = ndp
+                if (handler in dev) ndp.push = dev[handler].bind(dev)
+            }
+        }
+
+        const oPorts = dev.outputs()
+        for (const key in oPorts) {
+            const exp = oPorts[key].export()
+            const pList = this.getPortList(key, exp)
+            for (const subkey in pList) {
+                this.checkPortName(subkey)
+                const ndp = new DevicePort(subkey, pList[subkey])
+                dev.ports.output[subkey] = ndp
+            }
+        }
+    }
+
+    protected checkInputHandler(port: string, handler:string, device: Device) {
+        if (!(handler in device)) throw ErrorManager.make('CTR_INPUT_HANDLER_NF', { port, handler })
+    }
+
+    protected async initConnection(conn: string) {
+        const cc = this.toConnection(conn)
+        if (!(cc.outputDevice in this.devices)) throw ErrorManager.make('CTR_CONNECTION_DEVICE_NF', { connection: conn, device: cc.outputDevice })
+        if (!(cc.outputPort in this.devices[cc.outputDevice].ports.output)) throw ErrorManager.make('CTR_CONNECTION_PORT_NF', { connection: conn, port: cc.outputPort })
+        
+        if (!(cc.inputDevice in this.devices)) throw ErrorManager.make('CTR_CONNECTION_DEVICE_NF', { connection: conn, device: cc.inputDevice })
+        if (!(cc.inputPort in this.devices[cc.inputDevice].ports.input)) throw ErrorManager.make('CTR_CONNECTION_PORT_NF', { connection: conn, port: cc.inputPort })
+        const outPort =this.devices[cc.outputDevice].ports.output[cc.outputPort]
+        const inPort = this.devices[cc.inputDevice].ports.input[cc.inputPort]
+        new DeviceConnect(outPort, inPort)
+    }
+
+    private toConnection(con: string) {
+        const act = con.split('->')
+        if (act.length !== 2) throw ErrorManager.make('CTR_CONNECTION_INCORRECT', { connection: con, error: "Syntax connection error, syntax have -> beetwen device" })
+
+        const outputDeviceActs = act[0].split('.')
+        const inputDeviceActs = act[1].split('.')
+
+        if (outputDeviceActs.length > 3 || inputDeviceActs.length > 3) throw ErrorManager.make('CTR_CONNECTION_INCORRECT', { connection: con, error: "Syntax connection error, syntax have more 3 actets on side" })
+        if (outputDeviceActs.length < 2 || inputDeviceActs.length < 2) throw ErrorManager.make('CTR_CONNECTION_INCORRECT', { connection: con, error: "Syntax connection error, syntax have less 2 actets on side" })
+
+        let outputDevice = outputDeviceActs.shift()?.trim()
+        const outputPort = outputDeviceActs.join('.').trim()
+        let inputDevice = inputDeviceActs.shift()?.trim()
+        const inputPort = inputDeviceActs.join('.').trim()
+
+        if (outputDevice === undefined) outputDevice = ''
+        if (inputDevice === undefined) inputDevice = ''
+
+        const result: { [key: string]: string } = {
+            outputDevice, outputPort, inputDevice, inputPort
+        }
+        return result
+    }
+
+    protected checkPortName(port: string) {
+        if (!port.match(/[a-zA-Z0-9.]/)) throw ErrorManager.make('CTR_INCORRECT_PN', { port })
+    }
+
+    protected getPortList(name: string, iPort: IPort) {
+        const result: { [key: string]: IPort } = {}
+        if (!iPort.dynamic) {
+            result[name] = iPort
+            return result
+        }
+
+        if (!name.match(/%d/)) throw ErrorManager.make('CTR_INCORRECT_DYNAMIC_PN', { port: name })
+
+        for (let i = 1; i <= iPort.count; i++) {
+            const nIPort = Object.assign({}, iPort)
+            nIPort.count = 0
+            nIPort.dynamic = false
+            const nname = name.replace(/%d/, i + '')
+            result[nname] = nIPort
+        }
+
+        return result
+    }
+}

package/src/DeviceManager.ts

@@ -0,0 +1,124 @@
+import path from 'path'
+import fs from 'fs'
+import ErrorManager from './errors/ErrorManager'
+import Rule from './validator/Rule'
+
+interface IDeviceGroup {
+    name: string,
+    dir: string,
+    devices: Array<any>,
+    deviceList: Array<string>,
+    errors: Array<string>,
+    description: string
+}
+
+interface IDeviceInGroup{
+    name: string,
+    errors: Array<string>
+}
+
+ErrorManager.register('DeviceManager', 'S5dBTBKTnVbF', 'DM_DEVICE_NOT_FOUND','Device not found', {
+    device: Rule.string().require().description('Device request name')
+})
+
+export default class DeviceManager {
+
+    dir = './devices'
+    systemDir: string
+
+    devices = new Map<string, string>()
+    deviceList: Array<IDeviceGroup> = []
+    constructor(systemDir: string, dir: string) {
+        this.systemDir = systemDir
+        this.dir = dir
+    }
+
+
+    updateList() {
+        this.deviceList = this.devicesList()
+        for (const dgroup of this.deviceList) {
+            dgroup.devices = []
+            for (const device of dgroup.deviceList) {
+                const ndevice : IDeviceInGroup = { name: device, errors: [] }
+                dgroup.devices.push(ndevice)
+                const devicePath = path.join(this.systemDir, this.dir, dgroup.name, device + '.js')
+                if (!fs.existsSync(devicePath)) { ndevice.errors.push('File of device not found'); continue }
+            }
+        }
+        return this.deviceList
+    }
+
+    devicesList() {
+        const result: Array<IDeviceGroup> = []
+        const files = fs.readdirSync(path.join(this.systemDir, this.dir))
+        const dirs = this.getOnlyDirs(files)
+        dirs.sort()
+        for (const ddir of dirs) {
+            const group: IDeviceGroup = {
+                name: ddir,
+                dir: this.dir,
+                devices: [],
+                deviceList: [],
+                errors: [],
+                description: ''
+            }
+            result.push(group)
+            const listPath = path.join(this.systemDir, this.dir, ddir, 'list.json')
+
+            if (!fs.existsSync(listPath)) {
+                group.errors.push(listPath + ' ignored - list.json not found');
+                continue
+            }
+
+            // @todo Исправить на SAFE
+            const list: Array<string> = JSON.parse(fs.readFileSync(listPath).toString('utf-8'))
+            if (!list || !Array.isArray(list)) {
+                group.errors.push(listPath + ' ignored - list.json incorrect');
+                continue
+            }
+            
+            for (const listKey in list) {
+                const reqPath = path.join(this.systemDir, this.dir, ddir, list[listKey])
+                const devicePath = reqPath + '.js'
+                if (fs.existsSync(devicePath)) {
+                  if (!this.devices.has(ddir + '.' + list[listKey])) this.devices.set(ddir + '.' + list[listKey], reqPath)
+                  else console.log(devicePath + ' ignored - device not found')
+                }
+              }
+            list.sort()
+
+            group.deviceList = list
+        }
+        return result
+    }
+
+    /**
+     * Return class of device 
+     * 
+     * Requires special device string of path 
+     * example "vrack.System" where "vrack" is vendor and "System" is device class
+     * @param {string} device Device path string
+    */
+    async get(device:string){
+        const p: string | undefined = this.devices.get(device)
+        if (typeof p ==='string') { 
+            const deviceClass = await import(p)
+            if (deviceClass.default) return deviceClass.default
+        }
+        throw ErrorManager.make('DM_DEVICE_NOT_FOUND', { device })
+    }
+
+    /**
+     * 
+     * 
+     * 
+    */
+    private getOnlyDirs(files: Array<string>) {
+        const result: Array<string> = []
+        for (const i in files) {
+            if (fs.statSync(path.join(this.systemDir, this.dir, files[i])).isDirectory()) result.push(files[i])
+        }
+        result.sort()
+        return result
+    }
+}