@openxiot/xiot-core-spec-ts 0.0.2

package/dist/xiot/core/spec/typedef/image/ActionImage.d.ts

@@ -0,0 +1,13 @@
+import { Action } from '../instance/Action';
+import { ArgumentImage } from './ArgumentImage';
+import { Property } from '../instance/Property';
+import { ActionType } from '../definition/urn/ActionType';
+import { ActionOperation } from '../operation/ActionOperation';
+export declare class ActionImage extends Action {
+    static of(action: Action): ActionImage;
+    static addValues(argument: ArgumentImage, property: Property, values: any[]): void;
+    constructor(iid: number, type: ActionType, description: Map<string, string>, argumentsIn: ArgumentImage[], argumentsOut: ArgumentImage[]);
+    getArgumentsIn(): ArgumentImage[];
+    getArgumentsOut(): ArgumentImage[];
+    tryInvoke(o: ActionOperation, properties: Map<number, Property>): void;
+}

package/dist/xiot/core/spec/typedef/image/ActionImage.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ActionImage = void 0;
+const Action_1 = require("../instance/Action");
+const ArgumentImage_1 = require("./ArgumentImage");
+const Property_1 = require("../instance/Property");
+const Status_1 = require("../status/Status");
+const Argument_1 = require("../instance/Argument");
+class ActionImage extends Action_1.Action {
+    static of(action) {
+        return new ActionImage(action.iid, action.type, action.description, action.getArgumentsIn().map(x => ArgumentImage_1.ArgumentImage.fromArgument(x)), action.getArgumentsOut().map(x => ArgumentImage_1.ArgumentImage.fromArgument(x)));
+    }
+    static addValues(argument, property, values) {
+        for (let i = 0; i < values.length; ++i) {
+            const newProperty = Property_1.Property.copy(property);
+            newProperty.iid = argument.piid;
+            newProperty.type._index = i;
+            newProperty.type._optional = false;
+            newProperty.setValue(values[i]);
+            argument.properties.push(newProperty);
+        }
+    }
+    constructor(iid, type, description, argumentsIn, argumentsOut) {
+        super(iid, type, description, argumentsIn, argumentsOut);
+    }
+    getArgumentsIn() {
+        return super
+            .getArgumentsIn()
+            .filter(x => x instanceof ArgumentImage_1.ArgumentImage)
+            .map(x => x);
+    }
+    getArgumentsOut() {
+        return super
+            .getArgumentsOut()
+            .filter(x => x instanceof ArgumentImage_1.ArgumentImage)
+            .map(x => x);
+    }
+    tryInvoke(o, properties) {
+        console.log('tryInvoke');
+        o.status = Status_1.Status.COMPLETED;
+        for (const argument of this.getArgumentsIn()) {
+            const iid = argument.piid;
+            const v = o.in.get(iid);
+            if (v == null) {
+                if (argument.minRepeat > 0) {
+                    o.status = Status_1.Status.ACTION_IN_ERROR;
+                    o.description = `action argument in error, piid(${iid}) min repeat > 0`;
+                    break;
+                }
+                continue;
+            }
+            const property = properties.get(iid);
+            if (property == null) {
+                o.status = Status_1.Status.ACTION_IN_VALUE_INVALID;
+                o.description = `action argument in error, piid(${iid}) value invalid`;
+                break;
+            }
+            if (!property.trySetValues(v.values)) {
+                o.status = Status_1.Status.ACTION_IN_VALUE_INVALID;
+                o.description = `action argument in error, piid(${iid}) set value failed`;
+                break;
+            }
+            ActionImage.addValues(argument, property, v.values);
+        }
+        if (o.status !== Status_1.Status.COMPLETED) {
+            return;
+        }
+        const out = this.getArgumentsOut().map(x => {
+            const a = new Argument_1.Argument(x.piid);
+            a.values = x.properties.map(p => { var _a; return (_a = p.value.currentValue) === null || _a === void 0 ? void 0 : _a.rawValue(); });
+            return a;
+        });
+        o.setArgumentsOut(out);
+    }
+}
+exports.ActionImage = ActionImage;

package/dist/xiot/core/spec/typedef/image/ArgumentImage.d.ts

@@ -0,0 +1,8 @@
+import { Argument } from '../instance/Argument';
+import { Property } from '../instance/Property';
+export declare class ArgumentImage extends Argument {
+    properties: Property[];
+    static of(piid: number, minRepeat: number, maxRepeat: number): Argument;
+    static fromArgument(argument: Argument): ArgumentImage;
+    constructor(piid: number);
+}

package/dist/xiot/core/spec/typedef/image/ArgumentImage.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ArgumentImage = void 0;
+const Argument_1 = require("../instance/Argument");
+class ArgumentImage extends Argument_1.Argument {
+    // static of(argument: Argument): ArgumentImage {
+    //   const a = new ArgumentImage(argument.piid);
+    //   a.minRepeat = argument.minRepeat;
+    //   a.maxRepeat = argument.maxRepeat;
+    //   return a;
+    // }
+    // 适应 Argument 类的 of 方法签名
+    static of(piid, minRepeat, maxRepeat) {
+        const a = new ArgumentImage(piid);
+        a.minRepeat = minRepeat;
+        a.maxRepeat = maxRepeat;
+        return a;
+    }
+    static fromArgument(argument) {
+        const a = new ArgumentImage(argument.piid);
+        a.minRepeat = argument.minRepeat;
+        a.maxRepeat = argument.maxRepeat;
+        return a;
+    }
+    constructor(piid) {
+        super(piid);
+        this.properties = [];
+    }
+}
+exports.ArgumentImage = ArgumentImage;

package/dist/xiot/core/spec/typedef/image/DeviceImage.d.ts

@@ -0,0 +1,31 @@
+import { DeviceInstance } from '../instance/DeviceInstance';
+import { Summary } from '../summary/Summary';
+import { DeviceType } from '../definition/urn/DeviceType';
+import { ServiceImage } from './ServiceImage';
+import { PropertyOperation } from '../operation/PropertyOperation';
+import { ActionOperation } from '../operation/ActionOperation';
+import { EventOperation } from '../operation/EventOperation';
+export declare class DeviceImage extends DeviceInstance {
+    did: string;
+    summary: Summary | null;
+    children: Map<string, DeviceImage>;
+    parentFound: boolean;
+    static createTrees(nodes: DeviceImage[]): DeviceImage[];
+    static of(did: string, device: DeviceInstance): DeviceImage;
+    constructor(did: string, type: DeviceType, description: Map<string, string>, services: ServiceImage[]);
+    online(value: boolean): void;
+    tryRead(list: Array<PropertyOperation>): void;
+    tryWrite(list: Array<PropertyOperation>, save: boolean): void;
+    tryInvoke(list: Array<ActionOperation>): void;
+    tryEventOccurred(o: EventOperation): void;
+    private tryReadProperty;
+    private tryWriteProperty;
+    private tryInvokeAction;
+    add(nodes: DeviceImage[]): DeviceImage[];
+    private getAll;
+    addNode(node: DeviceImage): boolean;
+    removeNode(nodeId: string): DeviceImage | null;
+    getNode(did: string): DeviceImage | null;
+    private getParent;
+    getServices(): ServiceImage[];
+}

package/dist/xiot/core/spec/typedef/image/DeviceImage.js

@@ -0,0 +1,283 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeviceImage = void 0;
+const DeviceInstance_1 = require("../instance/DeviceInstance");
+const ServiceImage_1 = require("./ServiceImage");
+const Status_1 = require("../status/Status");
+class DeviceImage extends DeviceInstance_1.DeviceInstance {
+    static createTrees(nodes) {
+        const size = nodes.length;
+        for (let i = 0; i < size; ++i) {
+            for (let j = i + 1; j < size; ++j) {
+                const a = nodes[i];
+                const b = nodes[j];
+                if (a.did === b.did) {
+                    continue;
+                }
+                // A is B's parent
+                if (b.summary == null) {
+                    continue;
+                }
+                if (a.did === b.summary.parentId) {
+                    b.parentFound = true;
+                    a.children.set(b.did, b);
+                    continue;
+                }
+                // B is A's parent
+                if (a.summary == null) {
+                    continue;
+                }
+                if (b.did === a.summary.parentId) {
+                    a.parentFound = true;
+                    b.children.set(a.did, a);
+                }
+            }
+        }
+        return nodes.filter(x => !x.parentFound);
+    }
+    static of(did, device) {
+        return new DeviceImage(did, device.type, device.description, device.getServices().map(x => ServiceImage_1.ServiceImage.of(x)));
+    }
+    constructor(did, type, description, services) {
+        super(type, description, services);
+        this.did = '';
+        this.summary = null;
+        this.children = new Map();
+        this.parentFound = false;
+        this.did = did;
+    }
+    online(value) {
+        if (this.summary != null) {
+            this.summary.online = value;
+        }
+        for (const child of this.children.values()) {
+            child.online(value);
+        }
+    }
+    tryRead(list) {
+        for (const o of list) {
+            this.tryReadProperty(o);
+        }
+    }
+    tryWrite(list, save) {
+        for (const o of list) {
+            this.tryWriteProperty(o, save);
+        }
+    }
+    tryInvoke(list) {
+        for (const o of list) {
+            this.tryInvokeAction(o);
+        }
+    }
+    tryEventOccurred(o) {
+        if (o.eid == null) {
+            o.status = Status_1.Status.EID_INVALID;
+            o.description = 'EventId INVALID';
+            return;
+        }
+        const device = this.getNode(o.eid.did);
+        if (device) {
+            const service = device.services.get(o.eid.siid);
+            if (service) {
+                if (service instanceof ServiceImage_1.ServiceImage) {
+                    service.tryEventOccurred(o);
+                }
+                else {
+                    o.status = Status_1.Status.INTERNAL_ERROR;
+                    o.description = 'service is not ServiceImage';
+                }
+            }
+            else {
+                o.status = Status_1.Status.SERVICE_NOT_FOUND;
+                o.description = 'service not found';
+            }
+        }
+        else {
+            o.status = Status_1.Status.DEVICE_ID_NOT_EXIST;
+            o.description = `device not found, root: ${this.did}`;
+        }
+    }
+    tryReadProperty(o) {
+        var _a;
+        if (o.pid == null) {
+            o.status = Status_1.Status.PID_INVALID;
+            o.description = 'PropertyID INVALID';
+            return;
+        }
+        const device = this.getNode((_a = o.pid) === null || _a === void 0 ? void 0 : _a.did);
+        if (device != null) {
+            const service = device.services.get(o.pid.siid);
+            if (service != null) {
+                if (service instanceof ServiceImage_1.ServiceImage) {
+                    service.tryRead(o);
+                }
+                else {
+                    o.status = Status_1.Status.INTERNAL_ERROR;
+                    o.description = 'service is not ServiceImage';
+                }
+            }
+            else {
+                o.status = Status_1.Status.SERVICE_NOT_FOUND;
+                o.description = 'service not found';
+            }
+        }
+        else {
+            o.status = Status_1.Status.DEVICE_ID_NOT_EXIST;
+            o.description = `device not found, root: ${this.did}`;
+        }
+    }
+    tryWriteProperty(o, save) {
+        if (o.pid == null) {
+            o.status = Status_1.Status.PID_INVALID;
+            o.description = 'PropertyID INVALID';
+            return;
+        }
+        const device = this.getNode(o.pid.did);
+        if (device != null) {
+            const service = device.services.get(o.pid.siid);
+            if (service != null) {
+                if (service instanceof ServiceImage_1.ServiceImage) {
+                    service.tryWrite(o, save);
+                }
+                else {
+                    o.status = Status_1.Status.INTERNAL_ERROR;
+                    o.description = 'service is not ServiceImage';
+                }
+            }
+            else {
+                o.status = Status_1.Status.SERVICE_NOT_FOUND;
+                o.description = 'service not found';
+            }
+        }
+        else {
+            o.status = Status_1.Status.DEVICE_ID_NOT_EXIST;
+            o.description = `device not found, root: ${this.did}`;
+        }
+    }
+    tryInvokeAction(o) {
+        if (o.aid == null) {
+            o.status = Status_1.Status.PID_INVALID;
+            o.description = 'ActionID INVALID';
+            return;
+        }
+        const device = this.getNode(o.aid.did);
+        if (device != null) {
+            const service = device.services.get(o.aid.siid);
+            if (service != null) {
+                if (service instanceof ServiceImage_1.ServiceImage) {
+                    service.tryInvoke(o);
+                }
+                else {
+                    o.status = Status_1.Status.INTERNAL_ERROR;
+                    o.description = 'service is not ServiceImage';
+                }
+            }
+            else {
+                o.status = Status_1.Status.SERVICE_NOT_FOUND;
+                o.description = 'service not found';
+            }
+        }
+        else {
+            o.status = Status_1.Status.DEVICE_ID_NOT_EXIST;
+            o.description = `device not found, root: ${this.did}`;
+        }
+    }
+    add(nodes) {
+        const trees = DeviceImage.createTrees(nodes);
+        for (const tree of trees) {
+            if (tree.summary != null) {
+                if (tree.summary.parentId === this.did) {
+                    tree.parentFound = true;
+                    this.children.set(tree.did, tree);
+                }
+            }
+        }
+        const result = [];
+        for (const tree of trees) {
+            if (tree.parentFound) {
+                const all = tree.getAll();
+                for (const item of all) {
+                    result.push(item);
+                }
+            }
+        }
+        return result;
+    }
+    getAll() {
+        const list = [];
+        list.push(this);
+        for (const value of this.children.values()) {
+            list.push(...value.getAll());
+        }
+        return list;
+    }
+    addNode(node) {
+        const parent = this.getParent(node);
+        if (parent != null) {
+            parent.children.set(node.did, node);
+            return true;
+        }
+        return false;
+    }
+    removeNode(nodeId) {
+        const node = this.children.get(nodeId);
+        if (node != null) {
+            this.children.delete(nodeId);
+            return node;
+        }
+        for (const child of this.children.values()) {
+            const removed = child.removeNode(nodeId);
+            if (removed != null) {
+                return removed;
+            }
+        }
+        return null;
+    }
+    getNode(did) {
+        if (did == null) {
+            return null;
+        }
+        if (this.did === did) {
+            return this;
+        }
+        const child = this.children.get(did);
+        if (child != null) {
+            return child;
+        }
+        for (const device of this.children.values()) {
+            const node = device.getNode(did);
+            if (node != null) {
+                return node;
+            }
+        }
+        return null;
+    }
+    getParent(node) {
+        if (node.did == null) {
+            return null;
+        }
+        if (node.did.length === 0) {
+            return null;
+        }
+        if (node.summary == null) {
+            return null;
+        }
+        if (node.summary.parentId == null) {
+            return null;
+        }
+        if (node.summary.parentId.length === 0) {
+            return null;
+        }
+        if (node.did === node.summary.parentId) {
+            return null;
+        }
+        return this.getNode(node.summary.parentId);
+    }
+    getServices() {
+        return super
+            .getServices()
+            .filter(x => x instanceof ServiceImage_1.ServiceImage)
+            .map(x => x);
+    }
+}
+exports.DeviceImage = DeviceImage;

package/dist/xiot/core/spec/typedef/image/EventImage.d.ts

@@ -0,0 +1,11 @@
+import { Event } from '../instance/Event';
+import { EventType } from '../definition/urn/EventType';
+import { EventOperation } from '../operation/EventOperation';
+import { ArgumentImage } from './ArgumentImage';
+import { Property } from '../instance/Property';
+export declare class EventImage extends Event {
+    static of(event: Event): EventImage;
+    constructor(iid: number, type: EventType, description: Map<string, string>, list: ArgumentImage[]);
+    tryEventOccurred(o: EventOperation, properties: Map<number, Property>): void;
+    getArguments(): ArgumentImage[];
+}

package/dist/xiot/core/spec/typedef/image/EventImage.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventImage = void 0;
+const Event_1 = require("../instance/Event");
+const ArgumentImage_1 = require("./ArgumentImage");
+const Status_1 = require("../status/Status");
+class EventImage extends Event_1.Event {
+    static of(event) {
+        return new EventImage(event.iid, event.type, event.description, event.getArguments().map(x => ArgumentImage_1.ArgumentImage.fromArgument(x)));
+    }
+    constructor(iid, type, description, list) {
+        super(iid, type, description, list);
+    }
+    tryEventOccurred(o, properties) {
+        o.status = Status_1.Status.COMPLETED;
+        for (const spec of this.getArguments()) {
+            const v = o.arguments.get(spec.piid);
+            if (v == null) {
+                o.status = Status_1.Status.EVENT_ARGUMENTS_ERROR;
+                o.description = 'event argument error';
+                break;
+            }
+            if (spec.minRepeat > 0) {
+                o.status = Status_1.Status.EVENT_ARGUMENTS_ERROR;
+                o.description = 'event argument error, min repeat > 0';
+                break;
+            }
+            const property = properties.get(spec.piid);
+            if (property == null) {
+                o.status = Status_1.Status.EVENT_ARGUMENTS_ERROR;
+                o.description = 'event argument error, value invalid';
+                break;
+            }
+            if (!property.trySetValues(v.values)) {
+                o.status = Status_1.Status.EVENT_ARGUMENTS_ERROR;
+                o.description = 'event argument error, set value failed';
+                break;
+            }
+        }
+    }
+    getArguments() {
+        return super
+            .getArguments()
+            .filter(x => x instanceof ArgumentImage_1.ArgumentImage)
+            .map(x => x);
+    }
+}
+exports.EventImage = EventImage;

package/dist/xiot/core/spec/typedef/image/PropertyImage.d.ts

@@ -0,0 +1,22 @@
+import { Property } from '../instance/Property';
+import { PropertyOperation } from '../operation/PropertyOperation';
+import { PropertyType } from "../definition/urn/PropertyType";
+import { DataFormat } from "../definition/property/data/DataFormat";
+import { Access } from "../definition/property/Access";
+import { ConstraintValue } from "../definition/property/ConstraintValue";
+export declare class PropertyImage extends Property {
+    iid: number;
+    type: PropertyType;
+    description: Map<string, string>;
+    format: DataFormat;
+    access: Access;
+    constraintValue: ConstraintValue | null;
+    unit: string | null;
+    members: Array<number>;
+    static copy(other: Property): PropertyImage;
+    constructor(iid: number | undefined, type: PropertyType, description: Map<string, string>, format: DataFormat, access: Access, constraintValue?: ConstraintValue | null, unit?: string | null, members?: Array<number>);
+    tryRead(o: PropertyOperation): void;
+    tryWrite(o: PropertyOperation, save: boolean): void;
+    update(o: PropertyOperation): void;
+    onPropertiesChanged(o: PropertyOperation): void;
+}

package/dist/xiot/core/spec/typedef/image/PropertyImage.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PropertyImage = void 0;
+const Property_1 = require("../instance/Property");
+const Status_1 = require("../status/Status");
+class PropertyImage extends Property_1.Property {
+    static copy(other) {
+        return new PropertyImage(other.iid, other.type, other.description, other.format, other.access, other.constraintValue, other.unit, other.members);
+    }
+    constructor(iid = 0, type, description, format, access, constraintValue = null, unit = null, members = []) {
+        super(iid, type, description, format, access, constraintValue, unit, members);
+        this.iid = iid;
+        this.type = type;
+        this.description = description;
+        this.format = format;
+        this.access = access;
+        this.constraintValue = constraintValue;
+        this.unit = unit;
+        this.members = members;
+    }
+    tryRead(o) {
+        var _a;
+        if (this.value == null) {
+            o.status = Status_1.Status.INTERNAL_ERROR;
+            o.description = 'property value is null';
+            return;
+        }
+        if (this.access.isReadable) {
+            o.value = (_a = this.value.currentValue) === null || _a === void 0 ? void 0 : _a.rawValue();
+        }
+        else {
+            o.status = Status_1.Status.PROPERTY_CANNOT_READ;
+            o.description = 'property cannot read';
+        }
+    }
+    tryWrite(o, save) {
+        if (this.access.isWritable) {
+            if (save) {
+                this.update(o);
+            }
+            else if (super.trySetValue(o.value)) {
+                o.status = Status_1.Status.COMPLETED;
+            }
+            else {
+                o.status = Status_1.Status.PROPERTY_VALUE_INVALID;
+                o.description = 'property value invalid';
+            }
+        }
+        else {
+            o.status = Status_1.Status.PROPERTY_CANNOT_WRITE;
+            o.description = 'property cannot write';
+        }
+    }
+    update(o) {
+        if (this.setValue(o.value)) {
+            o.status = Status_1.Status.COMPLETED;
+        }
+        else {
+            o.status = Status_1.Status.PROPERTY_VALUE_INVALID;
+            o.description = 'property value invalid';
+        }
+    }
+    onPropertiesChanged(o) {
+        if (this.access.isNotifiable) {
+            this.update(o);
+        }
+        else {
+            o.status = Status_1.Status.PROPERTY_CANNOT_NOTIFY;
+            o.description = 'property cannot notify';
+        }
+    }
+}
+exports.PropertyImage = PropertyImage;

package/dist/xiot/core/spec/typedef/image/ServiceImage.d.ts

@@ -0,0 +1,21 @@
+import { Service } from '../instance/Service';
+import { ServiceType } from '../definition/urn/ServiceType';
+import { PropertyImage } from './PropertyImage';
+import { ActionImage } from './ActionImage';
+import { EventImage } from './EventImage';
+import { PropertyOperation } from '../operation/PropertyOperation';
+import { ActionOperation } from '../operation/ActionOperation';
+import { EventOperation } from '../operation/EventOperation';
+export declare class ServiceImage extends Service {
+    static of(s: Service): ServiceImage;
+    constructor(iid: number, type: ServiceType, description: Map<string, string>, properties: PropertyImage[], actions: ActionImage[], events: EventImage[]);
+    getProperties(): PropertyImage[];
+    getActions(): ActionImage[];
+    getEvents(): EventImage[];
+    tryRead(o: PropertyOperation): void;
+    tryWrite(o: PropertyOperation, save: boolean): void;
+    tryInvoke(o: ActionOperation): void;
+    tryEventOccurred(o: EventOperation): void;
+    update(o: PropertyOperation): void;
+    onPropertiesChanged(o: PropertyOperation): void;
+}