@openxiot/xiot-core-spec-ts 0.0.2

package/dist/xiot/core/spec/typedef/rule/condition/operator/compare/Compare.d.ts

@@ -0,0 +1,21 @@
+export interface Compare {
+    check(left: Object, right: Object): boolean;
+}
+export declare class CompareEqual implements Compare {
+    check(left: Object, right: Object): boolean;
+}
+export declare class CompareNotEqual implements Compare {
+    check(left: Object, right: Object): boolean;
+}
+export declare class CompareGreater implements Compare {
+    check(left: Object, right: Object): boolean;
+}
+export declare class CompareGreaterOrEqual implements Compare {
+    check(left: Object, right: Object): boolean;
+}
+export declare class CompareLess implements Compare {
+    check(left: Object, right: Object): boolean;
+}
+export declare class CompareLessOrEqual implements Compare {
+    check(left: Object, right: Object): boolean;
+}

package/dist/xiot/core/spec/typedef/rule/condition/operator/compare/Compare.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CompareLessOrEqual = exports.CompareLess = exports.CompareGreaterOrEqual = exports.CompareGreater = exports.CompareNotEqual = exports.CompareEqual = void 0;
+const StringUtils_1 = require("../../../../utils/StringUtils");
+class CompareEqual {
+    check(left, right) {
+        if ((0, StringUtils_1.isString)(left) && (0, StringUtils_1.isString)(right)) {
+            return left === right;
+        }
+        if ((0, StringUtils_1.isNumber)(left) && (0, StringUtils_1.isNumber)(right)) {
+            return left === right;
+        }
+        if ((0, StringUtils_1.isBoolean)(left) && (0, StringUtils_1.isBoolean)(right)) {
+            return left === right;
+        }
+        return false;
+    }
+}
+exports.CompareEqual = CompareEqual;
+class CompareNotEqual {
+    check(left, right) {
+        if ((0, StringUtils_1.isString)(left) && (0, StringUtils_1.isString)(right)) {
+            return left !== right;
+        }
+        if ((0, StringUtils_1.isNumber)(left) && (0, StringUtils_1.isNumber)(right)) {
+            return left !== right;
+        }
+        return false;
+    }
+}
+exports.CompareNotEqual = CompareNotEqual;
+class CompareGreater {
+    check(left, right) {
+        if ((0, StringUtils_1.isNumber)(left) && (0, StringUtils_1.isNumber)(right)) {
+            return left > right;
+        }
+        return false;
+    }
+}
+exports.CompareGreater = CompareGreater;
+class CompareGreaterOrEqual {
+    check(left, right) {
+        if ((0, StringUtils_1.isNumber)(left) && (0, StringUtils_1.isNumber)(right)) {
+            return left >= right;
+        }
+        return false;
+    }
+}
+exports.CompareGreaterOrEqual = CompareGreaterOrEqual;
+class CompareLess {
+    check(left, right) {
+        if ((0, StringUtils_1.isNumber)(left) && (0, StringUtils_1.isNumber)(right)) {
+            return left < right;
+        }
+        return false;
+    }
+}
+exports.CompareLess = CompareLess;
+class CompareLessOrEqual {
+    check(left, right) {
+        if ((0, StringUtils_1.isNumber)(left) && (0, StringUtils_1.isNumber)(right)) {
+            return left <= right;
+        }
+        return false;
+    }
+}
+exports.CompareLessOrEqual = CompareLessOrEqual;

package/dist/xiot/core/spec/typedef/rule/condition/operator/logical/Logic.d.ts

@@ -0,0 +1,2 @@
+import { LogicalOperator } from '../LogicalOperator';
+export declare function checkLogic(operator: LogicalOperator, values: Array<boolean>): boolean;

package/dist/xiot/core/spec/typedef/rule/condition/operator/logical/Logic.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkLogic = checkLogic;
+const Logical_1 = require("./Logical");
+const LogicalOperator_1 = require("../LogicalOperator");
+const logics = new Map([
+    [LogicalOperator_1.LogicalOperator.AND, new Logical_1.LogicalAND()],
+    [LogicalOperator_1.LogicalOperator.OR, new Logical_1.LogicalOR()]
+]);
+function checkLogic(operator, values) {
+    const logical = logics.get(operator);
+    if (logical === undefined || logical === null) {
+        return false;
+    }
+    return logical.check(values);
+}

package/dist/xiot/core/spec/typedef/rule/condition/operator/logical/Logical.d.ts

@@ -0,0 +1,9 @@
+export interface Logical {
+    check(values: Array<boolean>): boolean;
+}
+export declare class LogicalAND implements Logical {
+    check(values: Array<boolean>): boolean;
+}
+export declare class LogicalOR implements Logical {
+    check(values: Array<boolean>): boolean;
+}

package/dist/xiot/core/spec/typedef/rule/condition/operator/logical/Logical.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LogicalOR = exports.LogicalAND = void 0;
+class LogicalAND {
+    check(values) {
+        return values.filter(value => value).length === values.length;
+    }
+}
+exports.LogicalAND = LogicalAND;
+class LogicalOR {
+    check(values) {
+        return values.filter(value => value).length > 0;
+    }
+}
+exports.LogicalOR = LogicalOR;

package/dist/xiot/core/spec/typedef/rule/cron/CronExp.d.ts

@@ -0,0 +1,31 @@
+/**
+ * cron表达式解析类，终端设置定时器时可用，支持单独设置某一项
+ * toString()方法返回cron表达式
+ * 基于一般闹钟的逻辑，时分秒只支持有意义的整数型值，不支持形如*、1/5、23-56等范围
+ * 格式暂定，实际使用中需要继续优化
+ * Author zhanghaitao039
+ */
+export declare class CronExp {
+    private _second;
+    private _minute;
+    private _hour;
+    private _day;
+    private _month;
+    private _week;
+    private _year;
+    get second(): number;
+    set second(value: number);
+    get minute(): number;
+    set minute(value: number);
+    get hour(): number;
+    set hour(value: number);
+    get day(): string;
+    set day(value: string);
+    get month(): string;
+    set month(value: string);
+    get week(): string;
+    set week(value: string);
+    get year(): string;
+    set year(value: string);
+    toString(): string;
+}

package/dist/xiot/core/spec/typedef/rule/cron/CronExp.js

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CronExp = void 0;
+/**
+ * cron表达式解析类，终端设置定时器时可用，支持单独设置某一项
+ * toString()方法返回cron表达式
+ * 基于一般闹钟的逻辑，时分秒只支持有意义的整数型值，不支持形如*、1/5、23-56等范围
+ * 格式暂定，实际使用中需要继续优化
+ * Author zhanghaitao039
+ */
+class CronExp {
+    constructor() {
+        this._second = 0;
+        this._minute = 0;
+        this._hour = 0;
+        this._day = '*';
+        this._month = '*';
+        this._week = '?';
+        this._year = '';
+    }
+    get second() {
+        return this._second;
+    }
+    set second(value) {
+        if (value >= 0 && value <= 59) {
+            this._second = value;
+        }
+        else {
+            throw new Error(`minute part should between 0 and 23 or be *, but [${value}]`);
+        }
+    }
+    get minute() {
+        return this._minute;
+    }
+    set minute(value) {
+        if (value >= 0 && value <= 59) {
+            this._minute = value;
+        }
+        else {
+            throw new Error(`minute part should between 0 and 23 or be *, but [${value}]`);
+        }
+    }
+    get hour() {
+        return this._hour;
+    }
+    set hour(value) {
+        if (value >= 0 && value <= 23) {
+            this._hour = value;
+        }
+        else {
+            throw new Error(`hour part should between 0 and 23 or be *, but [${value}]`);
+        }
+    }
+    get day() {
+        return this._day;
+    }
+    set day(value) {
+        if ('*' === value) {
+            this._day = value;
+        }
+        else if (parseInt(value, 10) >= 1 && parseInt(value, 10) <= 31) {
+            this._day = value;
+        }
+        else {
+            throw new Error(`day part should between 1 and 31 or be *, but [${value}]`);
+        }
+    }
+    get month() {
+        return this._month;
+    }
+    set month(value) {
+        if ('*' === value) {
+            this._month = value;
+        }
+        else if (parseInt(value, 10) >= 1 && parseInt(value, 10) <= 12) {
+            this._month = value;
+        }
+        else {
+            throw new Error(`month part should between 1 and 12 or be *, but [${value}]`);
+        }
+    }
+    get week() {
+        return this._week;
+    }
+    set week(value) {
+        this._week = value;
+    }
+    get year() {
+        return this._year;
+    }
+    set year(value) {
+        this._year = value;
+    }
+    toString() {
+        let str = `${this.second} ${this.minute} ${this.hour} ${this.day} ${this.month} ${this.week}`;
+        if (this.year !== null && this.year !== undefined && this.year.length > 0) {
+            str += ` ${this.year}`;
+        }
+        return str;
+    }
+}
+exports.CronExp = CronExp;

package/dist/xiot/core/spec/typedef/rule/listener/RuleExecutionListener.d.ts

@@ -0,0 +1,5 @@
+import { AbstractOperation } from "../../operation/AbstractOperation";
+export interface RuleExecutionListener {
+    onTriggered(ruleId: string, trigger: AbstractOperation): void;
+    onExecuted(ruleId: string, status: number, description: string, operations: AbstractOperation[]): void;
+}

package/dist/xiot/core/spec/typedef/rule/listener/RuleExecutionListener.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/xiot/core/spec/typedef/rule/parser/RuleContentParser.d.ts

@@ -0,0 +1,13 @@
+import { RuleContent } from '../RuleContent';
+export declare class RuleContentParser {
+    private constructor();
+    static parse(text: string): RuleContent;
+    static parseManualRule(text: string): RuleContent;
+    /**
+     * 将tokens拆分为: triggers & conditions & operations
+     * @param text 自动化文本
+     * @return Automation 自动化
+     */
+    static parseAutomationRule(text: string): RuleContent;
+    private static parseTokens;
+}

package/dist/xiot/core/spec/typedef/rule/parser/RuleContentParser.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RuleContentParser = void 0;
+const RuleContent_1 = require("../RuleContent");
+const OperationParser_1 = require("./operation/OperationParser");
+const Tokenizer_1 = require("./token/Tokenizer");
+const Token_1 = require("./token/Token");
+const ConditionParser_1 = require("./condition/ConditionParser");
+class RuleContentParser {
+    constructor() { }
+    static parse(text) {
+        return text.startsWith('IF') ? this.parseAutomationRule(text) : this.parseManualRule(text);
+    }
+    static parseManualRule(text) {
+        return new RuleContent_1.RuleContent(null, null, new OperationParser_1.OperationParser().parseExpression(text));
+    }
+    /**
+     * 将tokens拆分为: triggers & conditions & operations
+     * @param text 自动化文本
+     * @return Automation 自动化
+     */
+    static parseAutomationRule(text) {
+        const tokens = new Tokenizer_1.Tokenizer().parse(text), triggerTokens = new Array(), conditionTokens = new Array(), operationTokens = new Array();
+        while (tokens.length > 0) {
+            const token = tokens.shift();
+            if (token === undefined) {
+                continue;
+            }
+            let trigger = true;
+            if (token.type === Token_1.TokenType.KEY_IF) {
+                while (tokens.length > 0) {
+                    const t = tokens.shift();
+                    if (t === undefined) {
+                        continue;
+                    }
+                    if (t.type === Token_1.TokenType.KEY_THEN) {
+                        break;
+                    }
+                    if (t.type === Token_1.TokenType.KEY_AND) {
+                        trigger = false;
+                    }
+                    if (trigger) {
+                        triggerTokens.push(t);
+                    }
+                    else {
+                        conditionTokens.push(t);
+                    }
+                }
+                while (tokens.length > 0) {
+                    const t = tokens.shift();
+                    if (t === undefined) {
+                        continue;
+                    }
+                    if (t.type === Token_1.TokenType.KEY_ENDIF) {
+                        break;
+                    }
+                    operationTokens.push(t);
+                }
+            }
+        }
+        return this.parseTokens(triggerTokens, conditionTokens, operationTokens);
+    }
+    static parseTokens(triggerTokens, conditionTokens, operationTokens) {
+        const trigger = new ConditionParser_1.ConditionParser().parseQueueTokens(triggerTokens);
+        const condition = new ConditionParser_1.ConditionParser().parseQueueTokens(conditionTokens);
+        const operations = new OperationParser_1.OperationParser().parseTokens(operationTokens);
+        return new RuleContent_1.RuleContent(trigger, condition, operations);
+    }
+}
+exports.RuleContentParser = RuleContentParser;

package/dist/xiot/core/spec/typedef/rule/parser/condition/ConditionParser.d.ts

@@ -0,0 +1,17 @@
+import { Stack } from '../../../utils/Stack';
+import { AbstractCondition } from '../../condition/AbstractCondition';
+import { Token } from '../token/Token';
+import { Token2 } from './parser2/Token2';
+export declare class ConditionParser {
+    private stack;
+    parse(expression: string): AbstractCondition;
+    parseQueueTokens(tokens: Array<Token>): AbstractCondition;
+    /**
+     * 将二阶逆波兰表达式合并成一个条件
+     *
+     * @param tokens xx
+     * @return condition 条件
+     */
+    parseStackTokens(tokens: Stack<Token2>): AbstractCondition | undefined;
+    private handleLogicalOperator;
+}

package/dist/xiot/core/spec/typedef/rule/parser/condition/ConditionParser.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConditionParser = void 0;
+const Stack_1 = require("../../../utils/Stack");
+const Parser2_1 = require("./parser2/Parser2");
+const Parser1_1 = require("./parser1/Parser1");
+const Parser0_1 = require("./parser0/Parser0");
+const Token2_1 = require("./parser2/Token2");
+const LogicalOperator_1 = require("../../condition/operator/LogicalOperator");
+const ComplexCondition_1 = require("../../condition/ComplexCondition");
+class ConditionParser {
+    constructor() {
+        this.stack = new Stack_1.Stack();
+    }
+    parse(expression) {
+        return this.parseStackTokens(new Parser2_1.Parser2().parseTokens(Parser1_1.Parser1.parse(expression)));
+    }
+    parseQueueTokens(tokens) {
+        const t = new Parser2_1.Parser2().parseTokens(Parser1_1.Parser1.parseTokens(new Parser0_1.Parser0().parseTokens(tokens)));
+        return this.parseStackTokens(t);
+    }
+    /**
+     * 将二阶逆波兰表达式合并成一个条件
+     *
+     * @param tokens xx
+     * @return condition 条件
+     */
+    parseStackTokens(tokens) {
+        this.stack = new Stack_1.Stack();
+        while (tokens.size() > 0) {
+            const token = tokens.pop();
+            if (token === undefined) {
+                continue;
+            }
+            switch (token.type) {
+                case Token2_1.Token2Type.PROPERTY_CONDITION:
+                case Token2_1.Token2Type.EVENT_CONDITION:
+                case Token2_1.Token2Type.EXTERNAL_CONDITION:
+                    this.stack.push(token.condition);
+                    break;
+                case Token2_1.Token2Type.LOGICAL_OPERATOR:
+                    this.handleLogicalOperator((0, LogicalOperator_1.getLogicalOperator)(token.operator));
+                    break;
+                default:
+                    throw new Error('invalid token2: ' + token.type);
+            }
+        }
+        if (this.stack.size() === 0) {
+            return undefined;
+        }
+        if (this.stack.size() !== 1) {
+            throw new Error('解析失败，堆栈中剩余条件: ' + this.stack.size());
+        }
+        return this.stack.pop();
+    }
+    handleLogicalOperator(operator) {
+        const condition = new ComplexCondition_1.ComplexCondition(operator);
+        if (this.stack.size() < 2) {
+            throw new Error('逻辑运算符的操作数少于2个: ' + operator.toString());
+        }
+        let c = this.stack.pop();
+        if (c !== undefined) {
+            condition.conditions.push(c);
+        }
+        c = this.stack.pop();
+        if (c !== undefined) {
+            condition.conditions.push(c);
+        }
+        this.stack.push(condition);
+    }
+}
+exports.ConditionParser = ConditionParser;

package/dist/xiot/core/spec/typedef/rule/parser/condition/parser0/Parser0.d.ts

@@ -0,0 +1,28 @@
+import { Token } from '../../token/Token';
+export declare enum ParserState0 {
+    INIT = 0,// initialize
+    VALUE = 1,// value
+    HASH = 2,// #
+    INTEGER = 3,// integer
+    ASSIGN = 4,// =
+    COMMA = 5
+}
+export declare class Parser0 {
+    private state;
+    private iid;
+    parse(expression: string): Array<Token>;
+    /**
+     * 将表达式中的事件值合并成: ArgumentValues
+     * @param tokens 未事件值合并的表达式
+     * @return tokens 事件值合并的表达式
+     */
+    parseTokens(tokens: Array<Token>): Token[];
+    private createTokenArguments;
+    private parseToken;
+    private handleStateInit;
+    private handleStateHASH;
+    private handleStateInteger;
+    private handleStateASSIGN;
+    private handleStateCOMMA;
+    private handleStateValue;
+}

package/dist/xiot/core/spec/typedef/rule/parser/condition/parser0/Parser0.js

@@ -0,0 +1,148 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Parser0 = exports.ParserState0 = void 0;
+const Token_1 = require("../../token/Token");
+const Tokenizer_1 = require("../../token/Tokenizer");
+const ArgumentOperation_1 = require("../../../../operation/ArgumentOperation");
+var ParserState0;
+(function (ParserState0) {
+    ParserState0[ParserState0["INIT"] = 0] = "INIT";
+    ParserState0[ParserState0["VALUE"] = 1] = "VALUE";
+    ParserState0[ParserState0["HASH"] = 2] = "HASH";
+    ParserState0[ParserState0["INTEGER"] = 3] = "INTEGER";
+    ParserState0[ParserState0["ASSIGN"] = 4] = "ASSIGN";
+    ParserState0[ParserState0["COMMA"] = 5] = "COMMA";
+})(ParserState0 || (exports.ParserState0 = ParserState0 = {}));
+class Parser0 {
+    constructor() {
+        this.iid = 0;
+    }
+    parse(expression) {
+        return this.parseTokens(new Tokenizer_1.Tokenizer().parse(expression));
+    }
+    /**
+     * 将表达式中的事件值合并成: ArgumentValues
+     * @param tokens 未事件值合并的表达式
+     * @return tokens 事件值合并的表达式
+     */
+    parseTokens(tokens) {
+        const queue = new Array(), argumentArray = new Array();
+        while (tokens.length > 0) {
+            const token = tokens.shift();
+            if (token === undefined) {
+                continue;
+            }
+            // {
+            if (token.type !== Token_1.TokenType.LEFT_BRACE) {
+                queue.push(token);
+                continue;
+            }
+            argumentArray.slice(0, argumentArray.length);
+            while (tokens.length > 0) {
+                const t = tokens.shift();
+                if (t === undefined) {
+                    continue;
+                }
+                if (t.type === Token_1.TokenType.RIGHT_BRACE) {
+                    break;
+                }
+                argumentArray.push(t);
+            }
+            queue.push(this.createTokenArguments(argumentArray));
+        }
+        return queue;
+    }
+    createTokenArguments(tokens) {
+        const argumentValue = new Token_1.Token(Token_1.TokenType.EVENT_VALUE, 0, 0);
+        this.state = ParserState0.INIT;
+        //        console.log("createTokenArguments: " + tokens.size());
+        while (tokens.length > 0) {
+            const token = tokens.shift();
+            if (token === undefined) {
+                continue;
+            }
+            this.parseToken(argumentValue, token);
+        }
+        return argumentValue;
+    }
+    parseToken(argumentValue, token) {
+        //        System.out.println("parse: " + token);
+        switch (this.state) {
+            case ParserState0.INIT:
+                this.handleStateInit(argumentValue, token);
+                break;
+            case ParserState0.HASH:
+                this.handleStateHASH(argumentValue, token);
+                break;
+            case ParserState0.INTEGER:
+                this.handleStateInteger(argumentValue, token);
+                break;
+            case ParserState0.ASSIGN:
+                this.handleStateASSIGN(argumentValue, token);
+                break;
+            case ParserState0.COMMA:
+                this.handleStateCOMMA(argumentValue, token);
+                break;
+            case ParserState0.VALUE:
+                this.handleStateValue(argumentValue, token);
+                break;
+            default:
+                throw new Error('state undefined: ' + this.state);
+        }
+    }
+    handleStateInit(argumentValue, token) {
+        if (token.type === Token_1.TokenType.HASH) {
+            this.state = ParserState0.HASH;
+            return;
+        }
+        throw new Error('state is INIT, token expected is #, but token is ' + token.type + ': ' + token);
+    }
+    handleStateHASH(argumentValue, token) {
+        this.iid = token.getInteger();
+        argumentValue.arguments.set(this.iid, new ArgumentOperation_1.ArgumentOperation(this.iid));
+        this.state = ParserState0.INTEGER;
+    }
+    handleStateInteger(argumentValue, token) {
+        if (token.type === Token_1.TokenType.ASSIGNMENT) {
+            this.state = ParserState0.ASSIGN;
+            return;
+        }
+        throw new Error('state is Integer, token expected is \'=\', but token is ' + token.type + ': ' + token);
+    }
+    handleStateASSIGN(argumentValue, token) {
+        if (token.isValue()) {
+            const argument = argumentValue.arguments.get(this.iid);
+            if (argument === undefined) {
+                throw new Error('argument is undefined, iid: ' + this.iid);
+            }
+            argument.values.push(token.getValue());
+            this.state = ParserState0.VALUE;
+            return;
+        }
+        throw new Error('state is NUMBER, token expected is \';\', but token is ' + token.type + ': ' + token);
+    }
+    handleStateCOMMA(argumentValue, token) {
+        if (token.type === Token_1.TokenType.HASH) {
+            this.state = ParserState0.HASH;
+            return;
+        }
+        if (token.isValue()) {
+            const argument = argumentValue.arguments.get(this.iid);
+            if (argument === undefined) {
+                throw new Error('argument is undefined, iid: ' + this.iid);
+            }
+            argument.values.push(token.getValue());
+            this.state = ParserState0.VALUE;
+            return;
+        }
+        throw new Error('state is \',\', token expected is # or value, but token is ' + token.type + ': ' + token);
+    }
+    handleStateValue(argumentValue, token) {
+        if (token.type === Token_1.TokenType.COMMA) {
+            this.state = ParserState0.COMMA;
+            return;
+        }
+        throw new Error('state is ARGUMENT_VALUE, token expected is \',\', but token is ' + token.type + ': ' + token);
+    }
+}
+exports.Parser0 = Parser0;

package/dist/xiot/core/spec/typedef/rule/parser/condition/parser1/Parser1.d.ts

@@ -0,0 +1,16 @@
+import { Stack } from '../../../../utils/Stack';
+import { Token } from '../../token/Token';
+export declare class Parser1 {
+    /**
+     * 将表达式转为逆波兰表达式
+     * @param expression 表达式
+     * @return stack 逆波兰表达式
+     */
+    static parse(expression: string): Stack<Token>;
+    /**
+     * https://www.fatalerrors.org/index.php/a/prefix-suffix-suffix-expression-inverse-polish-expression.html
+     * @param tokens 表达式
+     * @return stack 逆波兰表达式
+     */
+    static parseTokens(tokens: Array<Token>): Stack<Token>;
+}