@openxiot/xiot-core-spec-ts 0.0.2

package/dist/xiot/core/spec/typedef/status/Status.d.ts

@@ -0,0 +1,50 @@
+export declare enum Status {
+    UNDEFINED = -1,
+    COMPLETED = 0,
+    TO_BE_EXECUTE = 1,
+    INTERNAL_ERROR = -500,
+    ACCESS_KEY_INVALID = -501,
+    DEVICE_ID_NOT_EXIST = -502,
+    QUERY_NOT_SUPPORTED = -503,
+    /**
+     * FOR XCP DEVICE ENDPO    VERIFY
+     */
+    DEVICE_ID_INVALID = -100,
+    DEVICE_TYPE_INVALID = -101,
+    PUBLIC_KEY_NOT_FOUND = -102,
+    SIGNATURE_NOT_FOUND = -103,
+    VERSION_NOT_FOUND = -104,
+    AUTHENTICATION_NOT_FOUND = -105,
+    AUTHENTICATION_NOT_SUPPORTED = -106,
+    STATUS_INVALID = -107,
+    SIGNATURE_INVALID = -108,
+    CODEC_NOT_FOUND = -109,
+    CODEC_NOT_IMPLEMENTED = -110,
+    /**
+     * FOR OPERATION
+     */
+    DEVICE_OFFLINE = -400,
+    AUTHENTICATION_FAILED = -401,
+    SERVICE_NOT_FOUND = -410,
+    PID_INVALID = -420,
+    PROPERTY_NOT_FOUND = -421,
+    PROPERTY_CANNOT_READ = -422,
+    PROPERTY_CANNOT_WRITE = -423,
+    PROPERTY_CANNOT_NOTIFY = -424,
+    PROPERTY_VALUE_INVALID = -425,
+    PROPERTY_VALUE_ERROR = -426,
+    AID_INVALID = -430,
+    ACTION_NOT_FOUND = -431,
+    ACTION_IN_ERROR = -432,
+    ACTION_IN_VALUE_INVALID = -433,
+    ACTION_OUT_ERROR = -434,
+    ACTION_OUT_VALUE_INVALID = -435,
+    EID_INVALID = -440,
+    EVENT_NOT_FOUND = -441,
+    EVENT_ARGUMENTS_ERROR = -442,
+    EVENT_ARGUMENTS_VALUE_ERROR = -443,
+    /**
+     * FOR C2C
+     */
+    CLOUD_ERROR = -500
+}

package/dist/xiot/core/spec/typedef/status/Status.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Status = void 0;
+var Status;
+(function (Status) {
+    Status[Status["UNDEFINED"] = -1] = "UNDEFINED";
+    Status[Status["COMPLETED"] = 0] = "COMPLETED";
+    Status[Status["TO_BE_EXECUTE"] = 1] = "TO_BE_EXECUTE";
+    Status[Status["INTERNAL_ERROR"] = -500] = "INTERNAL_ERROR";
+    Status[Status["ACCESS_KEY_INVALID"] = -501] = "ACCESS_KEY_INVALID";
+    Status[Status["DEVICE_ID_NOT_EXIST"] = -502] = "DEVICE_ID_NOT_EXIST";
+    Status[Status["QUERY_NOT_SUPPORTED"] = -503] = "QUERY_NOT_SUPPORTED";
+    /**
+     * FOR XCP DEVICE ENDPO    VERIFY
+     */
+    Status[Status["DEVICE_ID_INVALID"] = -100] = "DEVICE_ID_INVALID";
+    Status[Status["DEVICE_TYPE_INVALID"] = -101] = "DEVICE_TYPE_INVALID";
+    Status[Status["PUBLIC_KEY_NOT_FOUND"] = -102] = "PUBLIC_KEY_NOT_FOUND";
+    Status[Status["SIGNATURE_NOT_FOUND"] = -103] = "SIGNATURE_NOT_FOUND";
+    Status[Status["VERSION_NOT_FOUND"] = -104] = "VERSION_NOT_FOUND";
+    Status[Status["AUTHENTICATION_NOT_FOUND"] = -105] = "AUTHENTICATION_NOT_FOUND";
+    Status[Status["AUTHENTICATION_NOT_SUPPORTED"] = -106] = "AUTHENTICATION_NOT_SUPPORTED";
+    Status[Status["STATUS_INVALID"] = -107] = "STATUS_INVALID";
+    Status[Status["SIGNATURE_INVALID"] = -108] = "SIGNATURE_INVALID";
+    Status[Status["CODEC_NOT_FOUND"] = -109] = "CODEC_NOT_FOUND";
+    Status[Status["CODEC_NOT_IMPLEMENTED"] = -110] = "CODEC_NOT_IMPLEMENTED";
+    /**
+     * FOR OPERATION
+     */
+    Status[Status["DEVICE_OFFLINE"] = -400] = "DEVICE_OFFLINE";
+    Status[Status["AUTHENTICATION_FAILED"] = -401] = "AUTHENTICATION_FAILED";
+    Status[Status["SERVICE_NOT_FOUND"] = -410] = "SERVICE_NOT_FOUND";
+    Status[Status["PID_INVALID"] = -420] = "PID_INVALID";
+    Status[Status["PROPERTY_NOT_FOUND"] = -421] = "PROPERTY_NOT_FOUND";
+    Status[Status["PROPERTY_CANNOT_READ"] = -422] = "PROPERTY_CANNOT_READ";
+    Status[Status["PROPERTY_CANNOT_WRITE"] = -423] = "PROPERTY_CANNOT_WRITE";
+    Status[Status["PROPERTY_CANNOT_NOTIFY"] = -424] = "PROPERTY_CANNOT_NOTIFY";
+    Status[Status["PROPERTY_VALUE_INVALID"] = -425] = "PROPERTY_VALUE_INVALID";
+    Status[Status["PROPERTY_VALUE_ERROR"] = -426] = "PROPERTY_VALUE_ERROR";
+    Status[Status["AID_INVALID"] = -430] = "AID_INVALID";
+    Status[Status["ACTION_NOT_FOUND"] = -431] = "ACTION_NOT_FOUND";
+    Status[Status["ACTION_IN_ERROR"] = -432] = "ACTION_IN_ERROR";
+    Status[Status["ACTION_IN_VALUE_INVALID"] = -433] = "ACTION_IN_VALUE_INVALID";
+    Status[Status["ACTION_OUT_ERROR"] = -434] = "ACTION_OUT_ERROR";
+    Status[Status["ACTION_OUT_VALUE_INVALID"] = -435] = "ACTION_OUT_VALUE_INVALID";
+    Status[Status["EID_INVALID"] = -440] = "EID_INVALID";
+    Status[Status["EVENT_NOT_FOUND"] = -441] = "EVENT_NOT_FOUND";
+    Status[Status["EVENT_ARGUMENTS_ERROR"] = -442] = "EVENT_ARGUMENTS_ERROR";
+    Status[Status["EVENT_ARGUMENTS_VALUE_ERROR"] = -443] = "EVENT_ARGUMENTS_VALUE_ERROR";
+    /**
+     * FOR C2C
+     */
+    Status[Status["CLOUD_ERROR"] = -500] = "CLOUD_ERROR";
+})(Status || (exports.Status = Status = {}));

package/dist/xiot/core/spec/typedef/summary/Summary.d.ts

@@ -0,0 +1,24 @@
+import { Urn } from '../definition/urn/Urn';
+export declare class Summary {
+    type: Urn;
+    online: boolean;
+    cloudId: string;
+    protocol: string;
+    parentId: string;
+    rootId: string;
+    members: string[];
+    lastOnline: Date;
+    lastOffline: Date;
+    from(other: Summary): Summary;
+    lastOnlineString(): string;
+    lastOfflineString(): string;
+    protected changeType(type: Urn): boolean;
+    protected changeOnline(online: boolean): boolean;
+    protected changeRootId(rootId: string): boolean;
+    protected changeParentId(parentId: string): boolean;
+    protected changeCloudId(cloudId: string): boolean;
+    protected changeProtocol(protocol: string): boolean;
+    protected changeMembers(members: string[]): boolean;
+    protected changeLastOnline(lastOnline: Date | undefined): boolean;
+    protected changeLastOffline(lastOffline: Date | undefined): boolean;
+}

package/dist/xiot/core/spec/typedef/summary/Summary.js

@@ -0,0 +1,120 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Summary = void 0;
+class Summary {
+    constructor() {
+        this.online = false;
+        this.members = [];
+    }
+    from(other) {
+        this.type = other.type;
+        this.online = other.online;
+        this.cloudId = other.cloudId;
+        this.parentId = other.parentId;
+        this.rootId = other.rootId;
+        this.protocol = other.protocol;
+        this.members = other.members;
+        this.lastOnline = other.lastOnline;
+        this.lastOffline = other.lastOffline;
+        return this;
+    }
+    lastOnlineString() {
+        if (this.lastOnline === undefined) {
+            return '';
+        }
+        return `${this.lastOnline.getFullYear()}-${this.lastOnline.getMonth() + 1}-${this.lastOnline.getDate()} ${this.lastOnline.getHours()}:${this.lastOnline.getMinutes()}`;
+    }
+    lastOfflineString() {
+        if (this.lastOffline === undefined) {
+            return '';
+        }
+        return `${this.lastOffline.getFullYear()}-${this.lastOffline.getMonth() + 1}-${this.lastOffline.getDate()} ${this.lastOffline.getHours()}:${this.lastOffline.getMinutes()}`;
+    }
+    changeType(type) {
+        if (this.type === type) {
+            return false;
+        }
+        this.type = type;
+        return true;
+    }
+    changeOnline(online) {
+        if (this.online === online) {
+            return false;
+        }
+        this.online = online;
+        return true;
+    }
+    changeRootId(rootId) {
+        if (this.rootId === rootId) {
+            return false;
+        }
+        this.rootId = rootId;
+        return true;
+    }
+    changeParentId(parentId) {
+        if (this.parentId === parentId) {
+            return false;
+        }
+        this.parentId = parentId;
+        return true;
+    }
+    changeCloudId(cloudId) {
+        if (this.cloudId === cloudId) {
+            return false;
+        }
+        this.cloudId = cloudId;
+        return true;
+    }
+    changeProtocol(protocol) {
+        if (this.protocol === protocol) {
+            return false;
+        }
+        this.protocol = protocol;
+        return true;
+    }
+    changeMembers(members) {
+        let changed = false;
+        if (members.length !== this.members.length) {
+            this.members = members;
+            changed = true;
+        }
+        else {
+            for (let i = 0; i < this.members.length; i++) {
+                if (this.members[i] !== members[i]) {
+                    this.members[i] = members[i];
+                    changed = true;
+                }
+            }
+        }
+        return changed;
+    }
+    changeLastOnline(lastOnline) {
+        if (lastOnline === undefined) {
+            return false;
+        }
+        if (this.lastOnline === undefined) {
+            this.lastOnline = lastOnline;
+            return true;
+        }
+        if (this.lastOnline.getTime() === lastOnline.getTime()) {
+            return false;
+        }
+        this.lastOnline = lastOnline;
+        return true;
+    }
+    changeLastOffline(lastOffline) {
+        if (lastOffline === undefined) {
+            return false;
+        }
+        if (this.lastOffline === undefined) {
+            this.lastOffline = lastOffline;
+            return true;
+        }
+        if (this.lastOffline.getTime() === lastOffline.getTime()) {
+            return false;
+        }
+        this.lastOffline = lastOffline;
+        return true;
+    }
+}
+exports.Summary = Summary;

package/dist/xiot/core/spec/typedef/template/ActionTemplate.d.ts

@@ -0,0 +1,17 @@
+import { ActionType } from '../definition/urn/ActionType';
+import { Argument } from '../instance/Argument';
+/**
+ * ouyang
+ */
+export declare class ActionTemplate {
+    iid: number;
+    required: boolean;
+    type: ActionType;
+    description: Map<string, string>;
+    in: Map<number, Argument>;
+    out: Map<number, Argument>;
+    source: string;
+    constructor(iid: number, required: boolean, type: ActionType, description: Map<string, string>, argumentsIn: Argument[], argumentsOut: Argument[], source: string);
+    getArgumentsIn(): Argument[];
+    getArgumentsOut(): Argument[];
+}

package/dist/xiot/core/spec/typedef/template/ActionTemplate.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ActionTemplate = void 0;
+/**
+ * ouyang
+ */
+class ActionTemplate {
+    constructor(iid, required, type, description, argumentsIn, argumentsOut, source) {
+        this.description = new Map();
+        this.in = new Map();
+        this.out = new Map();
+        this.iid = iid;
+        this.required = required;
+        this.source = source;
+        this.type = type;
+        if (description != null) {
+            this.description = description;
+        }
+        argumentsIn.forEach(x => {
+            return this.in.set(x.piid, x);
+        });
+        argumentsOut.forEach(x => {
+            return this.out.set(x.piid, x);
+        });
+    }
+    getArgumentsIn() {
+        return Array.from(this.in.values());
+    }
+    getArgumentsOut() {
+        return Array.from(this.out.values());
+    }
+}
+exports.ActionTemplate = ActionTemplate;

package/dist/xiot/core/spec/typedef/template/DeviceTemplate.d.ts

@@ -0,0 +1,12 @@
+import { DeviceType } from '../definition/urn/DeviceType';
+import { ServiceTemplate } from './ServiceTemplate';
+/**
+ * ouyang
+ */
+export declare class DeviceTemplate {
+    type: DeviceType;
+    description: Map<string, string>;
+    services: Map<number, ServiceTemplate>;
+    constructor(type: DeviceType, description: Map<string, string>, services: ServiceTemplate[]);
+    getServices(): ServiceTemplate[];
+}

package/dist/xiot/core/spec/typedef/template/DeviceTemplate.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeviceTemplate = void 0;
+/**
+ * ouyang
+ */
+class DeviceTemplate {
+    constructor(type, description, services) {
+        this.description = new Map();
+        this.services = new Map();
+        this.type = type;
+        if (description != null) {
+            this.description = description;
+        }
+        services.forEach(x => {
+            return this.services.set(x.iid, x);
+        });
+    }
+    getServices() {
+        return Array.from(this.services.values());
+    }
+}
+exports.DeviceTemplate = DeviceTemplate;

package/dist/xiot/core/spec/typedef/template/EventTemplate.d.ts

@@ -0,0 +1,15 @@
+import { EventType } from '../definition/urn/EventType';
+import { Argument } from '../instance/Argument';
+/**
+ * ouyang
+ */
+export declare class EventTemplate {
+    iid: number;
+    required: boolean;
+    type: EventType;
+    description: Map<string, string>;
+    arguments: Map<number, Argument>;
+    source: string;
+    constructor(iid: number, required: boolean, type: EventType, description: Map<string, string>, list: Argument[], source: string);
+    getArguments(): Argument[];
+}

package/dist/xiot/core/spec/typedef/template/EventTemplate.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventTemplate = void 0;
+/**
+ * ouyang
+ */
+class EventTemplate {
+    constructor(iid, required, type, description, list, source) {
+        this.description = new Map();
+        this.arguments = new Map();
+        this.iid = iid;
+        this.required = required;
+        this.source = source;
+        this.type = type;
+        if (description != null) {
+            this.description = description;
+        }
+        list.forEach(x => {
+            return this.arguments.set(x.piid, x);
+        });
+    }
+    getArguments() {
+        return Array.from(this.arguments.values());
+    }
+}
+exports.EventTemplate = EventTemplate;

package/dist/xiot/core/spec/typedef/template/PropertyTemplate.d.ts

@@ -0,0 +1,10 @@
+import { Property } from '../instance/Property';
+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 PropertyTemplate extends Property {
+    required: boolean;
+    source: string;
+    constructor(iid: number | undefined, type: PropertyType, description: Map<string, string>, format: DataFormat, access: Access, constraintValue: (ConstraintValue | null) | undefined, unit: string | null | undefined, members: Array<number> | undefined, required: boolean, source: string);
+}

package/dist/xiot/core/spec/typedef/template/PropertyTemplate.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PropertyTemplate = void 0;
+const Property_1 = require("../instance/Property");
+class PropertyTemplate extends Property_1.Property {
+    // iid: number;
+    // required: boolean;
+    // source: string;
+    // members: number[] = [];
+    constructor(iid = 0, type, description, format, access, constraintValue = null, unit = null, members = [], required, source) {
+        super(iid, type, description, format, access, constraintValue, unit, members);
+        this.required = required;
+        this.source = source;
+    }
+}
+exports.PropertyTemplate = PropertyTemplate;

package/dist/xiot/core/spec/typedef/template/ServiceTemplate.d.ts

@@ -0,0 +1,24 @@
+import { ServiceType } from '../definition/urn/ServiceType';
+import { PropertyTemplate } from './PropertyTemplate';
+import { ActionTemplate } from './ActionTemplate';
+import { EventTemplate } from './EventTemplate';
+/**
+ * ouyang
+ */
+export declare class ServiceTemplate {
+    iid: number;
+    required: boolean;
+    type: ServiceType;
+    source: string;
+    description: Map<string, string>;
+    properties: Map<number, PropertyTemplate>;
+    actions: Map<number, ActionTemplate>;
+    events: Map<number, EventTemplate>;
+    propertyAddable: boolean;
+    actionAddable: boolean;
+    eventAddable: boolean;
+    constructor(iid: number, required: boolean, type: ServiceType, description: Map<string, string>, properties: PropertyTemplate[], actions: ActionTemplate[], events: EventTemplate[], propertyAddable: boolean, actionAddable: boolean, eventAddable: boolean, source: string);
+    getProperties(): PropertyTemplate[];
+    getActions(): ActionTemplate[];
+    getEvents(): EventTemplate[];
+}

package/dist/xiot/core/spec/typedef/template/ServiceTemplate.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ServiceTemplate = void 0;
+/**
+ * ouyang
+ */
+class ServiceTemplate {
+    constructor(iid, required, type, description, properties, actions, events, propertyAddable, actionAddable, eventAddable, source) {
+        this.description = new Map();
+        this.properties = new Map();
+        this.actions = new Map();
+        this.events = new Map();
+        this.propertyAddable = false;
+        this.actionAddable = false;
+        this.eventAddable = false;
+        this.iid = iid;
+        this.required = required;
+        this.type = type;
+        this.propertyAddable = propertyAddable;
+        this.actionAddable = actionAddable;
+        this.eventAddable = eventAddable;
+        this.source = source;
+        if (description != null) {
+            this.description = description;
+        }
+        properties.forEach(x => {
+            return this.properties.set(x.iid, x);
+        });
+        actions.forEach(x => {
+            return this.actions.set(x.iid, x);
+        });
+        events.forEach(x => {
+            return this.events.set(x.iid, x);
+        });
+    }
+    getProperties() {
+        return Array.from(this.properties.values());
+    }
+    getActions() {
+        return Array.from(this.actions.values());
+    }
+    getEvents() {
+        return Array.from(this.events.values());
+    }
+}
+exports.ServiceTemplate = ServiceTemplate;

package/dist/xiot/core/spec/typedef/utils/Stack.d.ts

@@ -0,0 +1,10 @@
+export declare class Stack<E> {
+    private _storage;
+    push(item: E): E;
+    pop(): E | undefined;
+    peek(): E;
+    empty(): boolean;
+    size(): number;
+    reverse(): void;
+    toString(): string;
+}

package/dist/xiot/core/spec/typedef/utils/Stack.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Stack = void 0;
+class Stack {
+    constructor() {
+        this._storage = [];
+    }
+    push(item) {
+        this._storage.push(item);
+        return item;
+    }
+    pop() {
+        return this._storage.pop();
+    }
+    peek() {
+        const len = this._storage.length;
+        if (len > 0) {
+            return this._storage[len - 1];
+        }
+        throw new Error('EmptyStackException');
+    }
+    empty() {
+        return this._storage.length === 0;
+    }
+    size() {
+        return this._storage.length;
+    }
+    reverse() {
+        this._storage = this._storage.reverse();
+    }
+    toString() {
+        return `[${this._storage.join(', ')}]`;
+    }
+}
+exports.Stack = Stack;

package/dist/xiot/core/spec/typedef/utils/StringUtils.d.ts

@@ -0,0 +1,3 @@
+export declare function isString(obj: any): boolean;
+export declare function isNumber(obj: any): boolean;
+export declare function isBoolean(obj: any): boolean;

package/dist/xiot/core/spec/typedef/utils/StringUtils.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isString = isString;
+exports.isNumber = isNumber;
+exports.isBoolean = isBoolean;
+function isString(obj) {
+    return (typeof obj === 'string');
+}
+function isNumber(obj) {
+    return (typeof obj === 'number');
+}
+function isBoolean(obj) {
+    return (typeof obj === 'boolean');
+}

package/dist/xiot/core/spec/typedef/utils/TemplateHelper.d.ts

@@ -0,0 +1,30 @@
+import { ServiceTemplate } from '../template/ServiceTemplate';
+import { PropertyTemplate } from '../template/PropertyTemplate';
+import { ActionTemplate } from '../template/ActionTemplate';
+import { EventTemplate } from '../template/EventTemplate';
+import { DeviceTemplate } from '../template/DeviceTemplate';
+export declare class TemplateHelper {
+    static updateService(service: ServiceTemplate, organizationId: string, model: string, version: number): void;
+    static updateProperty(p: PropertyTemplate, groupId: string, model: string, version: number): void;
+    static updateAction(a: ActionTemplate, groupId: string, model: string, version: number): void;
+    static updateEvent(a: EventTemplate, groupId: string, model: string, version: number): void;
+    static alreadyAddedItems(device: DeviceTemplate): boolean;
+    static alreadyChanged(device: DeviceTemplate): boolean;
+    static addServices(device: DeviceTemplate, services: ServiceTemplate[]): void;
+    static addService(device: DeviceTemplate, service: ServiceTemplate): void;
+    static addProperties(device: DeviceTemplate, siid: number, properties: PropertyTemplate[]): void;
+    static addProperty(device: DeviceTemplate, siid: number, property: PropertyTemplate): void;
+    static addActions(device: DeviceTemplate, siid: number, actions: ActionTemplate[]): void;
+    static addAction(device: DeviceTemplate, siid: number, action: ActionTemplate): void;
+    static addEvents(device: DeviceTemplate, siid: number, events: EventTemplate[]): void;
+    static addEvent(device: DeviceTemplate, siid: number, event: EventTemplate): void;
+    private static reconstructProperty;
+    private static reconstructAction;
+    private static reconstructEvent;
+    private static reconstructService;
+    private static newHomeKitIID;
+    private static newServiceIID;
+    private static newPropertyIID;
+    private static newActionIID;
+    private static newEventIID;
+}