@openxiot/xiot-core-spec-ts 0.0.2

package/dist/xiot/core/spec/codec/product/ProductVersionCodec.d.ts

@@ -0,0 +1,7 @@
+import { ProductVersion } from '../../typedef/product/ProductVersion';
+export declare class ProductVersionCodec {
+    static encode(x: ProductVersion): any;
+    static decode(o: any): ProductVersion;
+    static encodeArray(arr: ProductVersion[]): any[];
+    static decodeArray(arr: any[]): ProductVersion[];
+}

package/dist/xiot/core/spec/codec/product/ProductVersionCodec.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProductVersionCodec = void 0;
+const ProductVersion_1 = require("../../typedef/product/ProductVersion");
+const DeviceType_1 = require("../../typedef/definition/urn/DeviceType");
+const DeviceInstanceCodec_1 = require("../instance/DeviceInstanceCodec");
+const Lifecycle_1 = require("../../typedef/lifecycle/Lifecycle");
+class ProductVersionCodec {
+    static encode(x) {
+        let o = {
+            lifecycle: x.lifecycle.toString(),
+            version: x.version,
+            productId: x.productId,
+            type: x.type.toString(),
+            ltpk: x.ltpk,
+            ltsk: x.ltsk,
+            seed: x.seed,
+        };
+        if (x.instance) {
+            o['instance'] = DeviceInstanceCodec_1.DeviceInstanceCodec.encode(x.instance);
+        }
+        if (x.createAt !== undefined) {
+            o.createAt = x.createAt.getTime();
+        }
+        if (x.updateAt !== undefined) {
+            o.updateAt = x.updateAt.getTime();
+        }
+        return o;
+    }
+    static decode(o) {
+        const version = new ProductVersion_1.ProductVersion();
+        version.lifecycle = (0, Lifecycle_1.LifeCycleFromString)(o.lifecycle || '');
+        version.version = o.version;
+        version.productId = o.productId;
+        version.type = DeviceType_1.DeviceType.parse(o.type);
+        version.ltpk = o.ltpk;
+        version.ltsk = o.ltsk;
+        version.seed = o.seed;
+        if (o.instance) {
+            version.instance = DeviceInstanceCodec_1.DeviceInstanceCodec.decode(o.instance);
+        }
+        if (o.createAt !== undefined) {
+            version.createAt = new Date(o.createAt);
+        }
+        if (o.updateAt !== undefined) {
+            version.updateAt = new Date(o.updateAt);
+        }
+        return version;
+    }
+    static encodeArray(arr) {
+        const list = [];
+        if (arr === null || arr === void 0 ? void 0 : arr.length) {
+            for (const o of arr) {
+                list.push(this.encode(o));
+            }
+        }
+        return list;
+    }
+    static decodeArray(arr) {
+        const instances = [];
+        if (arr === null || arr === void 0 ? void 0 : arr.length) {
+            for (const o of arr) {
+                instances.push(this.decode(o));
+            }
+        }
+        return instances;
+    }
+}
+exports.ProductVersionCodec = ProductVersionCodec;

package/dist/xiot/core/spec/codec/product/resource/ProductResourceCodec.d.ts

@@ -0,0 +1,7 @@
+import { ProductResource } from "../../../typedef/product/resource/ProductResource";
+export declare class ProductResourceCodec {
+    static encode(x: ProductResource): any;
+    static decode(o: any): ProductResource;
+    static encodeArray(arr: ProductResource[]): any[];
+    static decodeArray(arr: any[]): ProductResource[];
+}

package/dist/xiot/core/spec/codec/product/resource/ProductResourceCodec.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProductResourceCodec = void 0;
+const ProductResource_1 = require("../../../typedef/product/resource/ProductResource");
+const ResourceVersionCodec_1 = require("./ResourceVersionCodec");
+const DescriptionCodec_1 = require("../../definition/DescriptionCodec");
+class ProductResourceCodec {
+    static encode(x) {
+        return {
+            productId: x.productId,
+            name: x.name,
+            description: DescriptionCodec_1.DescriptionCodec.encode(x.description),
+            extra: x.extra,
+            versions: ResourceVersionCodec_1.ResourceVersionCodec.encodeArray(x.versions)
+        };
+    }
+    static decode(o) {
+        const x = new ProductResource_1.ProductResource();
+        x.productId = o.productId;
+        x.name = o.name;
+        x.description = DescriptionCodec_1.DescriptionCodec.decode(o.description);
+        x.extra = o.extra;
+        x.versions = ResourceVersionCodec_1.ResourceVersionCodec.decodeArray(o.versions);
+        return x;
+    }
+    static encodeArray(arr) {
+        const list = [];
+        if (arr === null || arr === void 0 ? void 0 : arr.length) {
+            for (const o of arr) {
+                list.push(this.encode(o));
+            }
+        }
+        return list;
+    }
+    static decodeArray(arr) {
+        const instances = [];
+        if (arr === null || arr === void 0 ? void 0 : arr.length) {
+            for (const o of arr) {
+                instances.push(this.decode(o));
+            }
+        }
+        return instances;
+    }
+}
+exports.ProductResourceCodec = ProductResourceCodec;

package/dist/xiot/core/spec/codec/product/resource/ProductResourceVersionCodec.d.ts

@@ -0,0 +1,7 @@
+import { ProductResourceVersion } from "../../../typedef/product/resource/ProductResourceVersion";
+export declare class ProductResourceVersionCodec {
+    static encode(x: ProductResourceVersion): any;
+    static decode(o: any): ProductResourceVersion;
+    static encodeArray(arr: ProductResourceVersion[]): any[];
+    static decodeArray(arr: any[]): ProductResourceVersion[];
+}

package/dist/xiot/core/spec/codec/product/resource/ProductResourceVersionCodec.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProductResourceVersionCodec = void 0;
+const ProductResourceVersion_1 = require("../../../typedef/product/resource/ProductResourceVersion");
+const Version_1 = require("../../../typedef/version/Version");
+const Lifecycle_1 = require("../../../typedef/lifecycle/Lifecycle");
+const DescriptionCodec_1 = require("../../definition/DescriptionCodec");
+class ProductResourceVersionCodec {
+    static encode(x) {
+        let o = {
+            productId: x.productId,
+            name: x.name,
+            version: x.version.toString(),
+            md5: x.md5,
+            description: DescriptionCodec_1.DescriptionCodec.encode(x.description),
+            size: x.size,
+            url: x.url,
+            lifecycle: x.lifecycle.toString(),
+            createBy: x.createBy,
+            updateBy: x.updateBy,
+        };
+        if (x.createAt !== undefined) {
+            o.createAt = x.createAt.getTime();
+        }
+        if (x.updateAt !== undefined) {
+            o.updateAt = x.updateAt.getTime();
+        }
+        return o;
+    }
+    static decode(o) {
+        const version = new ProductResourceVersion_1.ProductResourceVersion();
+        version.productId = o.productId;
+        version.name = o.name;
+        version.version = Version_1.Version.fromString(o.version);
+        version.md5 = o.md5;
+        version.description = DescriptionCodec_1.DescriptionCodec.decode(o.description);
+        version.size = o.size;
+        version.url = o.url;
+        version.lifecycle = (0, Lifecycle_1.LifeCycleFromString)(o.lifecycle || '');
+        version.createBy = o.createBy;
+        version.updateBy = o.updateBy;
+        if (o.createAt !== undefined) {
+            version.createAt = new Date(o.createAt);
+        }
+        if (o.updateAt !== undefined) {
+            version.updateAt = new Date(o.updateAt);
+        }
+        return version;
+    }
+    static encodeArray(arr) {
+        const list = [];
+        if (arr === null || arr === void 0 ? void 0 : arr.length) {
+            for (const o of arr) {
+                list.push(this.encode(o));
+            }
+        }
+        return list;
+    }
+    static decodeArray(arr) {
+        const instances = [];
+        if (arr === null || arr === void 0 ? void 0 : arr.length) {
+            for (const o of arr) {
+                instances.push(this.decode(o));
+            }
+        }
+        return instances;
+    }
+}
+exports.ProductResourceVersionCodec = ProductResourceVersionCodec;

package/dist/xiot/core/spec/codec/product/resource/ResourceVersionCodec.d.ts

@@ -0,0 +1,7 @@
+import { ResourceVersion } from "../../../typedef/product/resource/ResourceVersion";
+export declare class ResourceVersionCodec {
+    static encode(x: ResourceVersion): any;
+    static decode(o: any): ResourceVersion;
+    static encodeArray(arr: ResourceVersion[]): any[];
+    static decodeArray(arr: any[]): ResourceVersion[];
+}

package/dist/xiot/core/spec/codec/product/resource/ResourceVersionCodec.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResourceVersionCodec = void 0;
+const ResourceVersion_1 = require("../../../typedef/product/resource/ResourceVersion");
+const Lifecycle_1 = require("../../../typedef/lifecycle/Lifecycle");
+const Version_1 = require("../../../typedef/version/Version");
+const DescriptionCodec_1 = require("../../definition/DescriptionCodec");
+class ResourceVersionCodec {
+    static encode(x) {
+        let o = {
+            version: x.version.toString(),
+            md5: x.md5,
+            description: DescriptionCodec_1.DescriptionCodec.encode(x.description),
+            size: x.size,
+            url: x.url,
+            lifecycle: x.lifecycle.toString(),
+            createBy: x.createBy,
+            updateBy: x.updateBy,
+        };
+        if (x.createAt !== undefined) {
+            o.createAt = x.createAt.getTime();
+        }
+        if (x.updateAt !== undefined) {
+            o.updateAt = x.updateAt.getTime();
+        }
+        return o;
+    }
+    static decode(o) {
+        const version = new ResourceVersion_1.ResourceVersion();
+        version.version = Version_1.Version.fromString(o.version);
+        version.md5 = o.md5;
+        version.description = DescriptionCodec_1.DescriptionCodec.decode(o.description);
+        version.size = o.size;
+        version.url = o.url;
+        version.lifecycle = (0, Lifecycle_1.LifeCycleFromString)(o.lifecycle || '');
+        version.createBy = o.createBy;
+        version.updateBy = o.updateBy;
+        if (o.createAt !== undefined) {
+            version.createAt = new Date(o.createAt);
+        }
+        if (o.updateAt !== undefined) {
+            version.updateAt = new Date(o.updateAt);
+        }
+        return version;
+    }
+    static encodeArray(arr) {
+        const list = [];
+        if (arr === null || arr === void 0 ? void 0 : arr.length) {
+            for (const o of arr) {
+                list.push(this.encode(o));
+            }
+        }
+        return list;
+    }
+    static decodeArray(arr) {
+        const list = [];
+        if (arr === null || arr === void 0 ? void 0 : arr.length) {
+            for (const o of arr) {
+                list.push(this.decode(o));
+            }
+        }
+        return list;
+    }
+}
+exports.ResourceVersionCodec = ResourceVersionCodec;

package/dist/xiot/core/spec/codec/rbac/PermissionCodec.d.ts

@@ -0,0 +1,7 @@
+import { Permission } from '../../typedef/rbac/Permission';
+export declare class PermissionCodec {
+    static decodeArray(array: any[]): Permission[];
+    static decode(x: any): Permission;
+    static encode(x: Permission): {};
+    static encodeArray(permissions: Permission[]): any[];
+}

package/dist/xiot/core/spec/codec/rbac/PermissionCodec.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PermissionCodec = void 0;
+const Permission_1 = require("../../typedef/rbac/Permission");
+class PermissionCodec {
+    static decodeArray(array) {
+        if (array != null) {
+            if (array.length > 0) {
+                return array.map(x => PermissionCodec.decode(x));
+            }
+        }
+        return [];
+    }
+    static decode(x) {
+        return new Permission_1.Permission(x.id, x.parent_id, x.text, x.code, x.remark);
+    }
+    static encode(x) {
+        return {
+            id: x.id,
+            parent_id: x.parent_id,
+            text: x.text,
+            code: x.code,
+            remark: x.remark
+        };
+    }
+    static encodeArray(permissions) {
+        if (permissions != null) {
+            if (permissions.length > 0) {
+                return permissions.map(x => PermissionCodec.encode(x));
+            }
+        }
+        return [];
+    }
+}
+exports.PermissionCodec = PermissionCodec;

package/dist/xiot/core/spec/codec/rbac/RoleCodec.d.ts

@@ -0,0 +1,7 @@
+import { Role } from '../../typedef/rbac/Role';
+export declare class RoleCodec {
+    static decodeArray(array: any[]): Role[];
+    static decode(x: any): Role;
+    static encode(x: Role): {};
+    static encodeArray(roles: Role[]): any[];
+}

package/dist/xiot/core/spec/codec/rbac/RoleCodec.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RoleCodec = void 0;
+const Role_1 = require("../../typedef/rbac/Role");
+class RoleCodec {
+    static decodeArray(array) {
+        if (array != null) {
+            if (array.length > 0) {
+                return array.map(x => RoleCodec.decode(x));
+            }
+        }
+        return [];
+    }
+    static decode(x) {
+        return new Role_1.Role(x.id, x.parent_id, x.text, x.permission);
+    }
+    static encode(x) {
+        return {
+            id: x.id,
+            parent_id: x.parent_id,
+            text: x.text,
+            permission: x.permission
+        };
+    }
+    static encodeArray(roles) {
+        if (roles != null) {
+            if (roles.length > 0) {
+                return roles.map(x => RoleCodec.encode(x));
+            }
+        }
+        return [];
+    }
+}
+exports.RoleCodec = RoleCodec;

package/dist/xiot/core/spec/codec/rbac/account/AccountCodec.d.ts

@@ -0,0 +1,7 @@
+import { Account } from '../../../typedef/rbac/account/Account';
+export declare class AccountCodec {
+    static decodeArray(array: any[]): Account[];
+    static decode(x: any): Account;
+    static encode(x: Account): {};
+    static encodeArray(accounts: Account[]): any[];
+}

package/dist/xiot/core/spec/codec/rbac/account/AccountCodec.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AccountCodec = void 0;
+const Account_1 = require("../../../typedef/rbac/account/Account");
+class AccountCodec {
+    static decodeArray(array) {
+        if (array != null) {
+            if (array.length > 0) {
+                return array.map(x => AccountCodec.decode(x));
+            }
+        }
+        return [];
+    }
+    static decode(x) {
+        return new Account_1.Account(x.id, x.nickname, x.avatar, x.email, x.username, x.password, x.platformId, x.platformAccountId);
+    }
+    static encode(x) {
+        return {
+            id: x.id,
+            nickname: x.nickname,
+            avatar: x.avatar,
+            email: x.email,
+            username: x.username,
+            password: x.password,
+            platformId: x.platformId,
+            platformAccountId: x.platformAccountId,
+        };
+    }
+    static encodeArray(accounts) {
+        if (accounts != null) {
+            if (accounts.length > 0) {
+                return accounts.map(x => AccountCodec.encode(x));
+            }
+        }
+        return [];
+    }
+}
+exports.AccountCodec = AccountCodec;

package/dist/xiot/core/spec/codec/rbac/organization/MemberCodec.d.ts

@@ -0,0 +1,7 @@
+import { Member } from '../../../typedef/rbac/organization/Member';
+export declare class MemberCodec {
+    static decodeArray(array: any[]): Member[];
+    static decode(x: any): Member;
+    static encode(x: Member): {};
+    static encodeArray(Members: Member[]): any[];
+}

package/dist/xiot/core/spec/codec/rbac/organization/MemberCodec.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemberCodec = void 0;
+const Member_1 = require("../../../typedef/rbac/organization/Member");
+class MemberCodec {
+    static decodeArray(array) {
+        if (array != null) {
+            if (array.length > 0) {
+                return array.map(x => MemberCodec.decode(x));
+            }
+        }
+        return [];
+    }
+    static decode(x) {
+        return new Member_1.Member(x.organizationId, x.accountId, x.status, x.role);
+    }
+    static encode(x) {
+        return {
+            organizationId: x.organizationId,
+            accountId: x.accountId,
+            status: x.status,
+            role: x.role
+        };
+    }
+    static encodeArray(Members) {
+        if (Members != null) {
+            if (Members.length > 0) {
+                return Members.map(x => MemberCodec.encode(x));
+            }
+        }
+        return [];
+    }
+}
+exports.MemberCodec = MemberCodec;

package/dist/xiot/core/spec/codec/rbac/organization/OrganizationCodec.d.ts

@@ -0,0 +1,7 @@
+import { Organization } from '../../../typedef/rbac/organization/Organization';
+export declare class OrganizationCodec {
+    static decodeArray(array: any[]): Organization[];
+    static decode(x: any): Organization;
+    static encode(x: Organization): {};
+    static encodeArray(Organizations: Organization[]): any[];
+}

package/dist/xiot/core/spec/codec/rbac/organization/OrganizationCodec.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OrganizationCodec = void 0;
+const Organization_1 = require("../../../typedef/rbac/organization/Organization");
+class OrganizationCodec {
+    static decodeArray(array) {
+        if (array != null) {
+            if (array.length > 0) {
+                return array.map(x => OrganizationCodec.decode(x));
+            }
+        }
+        return [];
+    }
+    static decode(x) {
+        return new Organization_1.Organization(x.id, x.description, x.roles);
+    }
+    static encode(x) {
+        return {
+            id: x.id,
+            description: x.description,
+            roles: x.roles
+        };
+    }
+    static encodeArray(Organizations) {
+        if (Organizations != null) {
+            if (Organizations.length > 0) {
+                return Organizations.map(x => OrganizationCodec.encode(x));
+            }
+        }
+        return [];
+    }
+}
+exports.OrganizationCodec = OrganizationCodec;

package/dist/xiot/core/spec/codec/rule/RuleCodec.d.ts

@@ -0,0 +1,7 @@
+import { Rule } from '../../typedef/rule/Rule';
+export declare class RuleCodec {
+    static decode(o: any): Rule;
+    static encode(x: Rule): any;
+    static decodeArray(arr: any[]): Rule[];
+    static encodeArray(x: Rule[]): any[];
+}

package/dist/xiot/core/spec/codec/rule/RuleCodec.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RuleCodec = void 0;
+const Rule_1 = require("../../typedef/rule/Rule");
+const RuleContentParser_1 = require("../../typedef/rule/parser/RuleContentParser");
+const RuleType_1 = require("../../typedef/rule/RuleType");
+class RuleCodec {
+    static decode(o) {
+        const rule = new Rule_1.Rule();
+        rule.id = o.id;
+        rule.name = o.name;
+        rule.description = o.description;
+        rule.content = RuleContentParser_1.RuleContentParser.parse(o.content);
+        rule.actuator = o.actuator;
+        rule.enabled = o.enabled;
+        rule.appId = o.appId;
+        rule.ownerId = o.ownerId;
+        if (o.createAt !== undefined) {
+            rule.createAt = new Date(o.createAt);
+        }
+        if (o.updateAt !== undefined) {
+            rule.updateAt = new Date(o.updateAt);
+        }
+        return rule;
+    }
+    static encode(x) {
+        const o = {
+            id: x.id,
+            name: x.name,
+            description: x.description,
+            content: x.content.toString()
+        };
+        if (x.type !== RuleType_1.RuleType.MANUAL) {
+            o.enabled = x.enabled;
+        }
+        if (x.actuator != null) {
+            o.actuator = x.actuator;
+        }
+        if (x.createAt !== undefined) {
+            console.log('x.createAt: ', (typeof x.createAt));
+            o.createAt = x.createAt.getTime();
+        }
+        if (x.updateAt !== undefined) {
+            console.log('x.updateAt: ', (typeof x.updateAt));
+            o.updateAt = x.updateAt.getTime();
+        }
+        if (x.appId != null) {
+            o.appId = x.appId;
+        }
+        if (x.ownerId != null) {
+            o.ownerId = x.ownerId;
+        }
+        return o;
+    }
+    static decodeArray(arr) {
+        const list = [];
+        if (arr != null) {
+            for (const o of arr) {
+                list.push(this.decode(o));
+            }
+        }
+        return list;
+    }
+    static encodeArray(x) {
+        const arr = [];
+        if (x === null || x === void 0 ? void 0 : x.length) {
+            for (const p of x) {
+                arr.push(this.encode(p));
+            }
+        }
+        return arr;
+    }
+}
+exports.RuleCodec = RuleCodec;

package/dist/xiot/core/spec/codec/shadow/DeviceShadowCodec.d.ts

@@ -0,0 +1,7 @@
+import { DeviceShadow } from '../../typedef/shadow/DeviceShadow';
+export declare class DeviceShadowCodec {
+    static encode(x: DeviceShadow): any;
+    static decode(o: any): DeviceShadow;
+    static encodeArray(arr: DeviceShadow[]): any[];
+    static decodeArray(arr: any[]): DeviceShadow[];
+}

package/dist/xiot/core/spec/codec/shadow/DeviceShadowCodec.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeviceShadowCodec = void 0;
+const DeviceShadow_1 = require("../../typedef/shadow/DeviceShadow");
+const ShadowCodec_1 = require("./ShadowCodec");
+class DeviceShadowCodec {
+    static encode(x) {
+        return {
+            did: x.did,
+            shadows: ShadowCodec_1.ShadowCodec.encodeArray(x.shadows)
+        };
+    }
+    static decode(o) {
+        const device = new DeviceShadow_1.DeviceShadow();
+        device.did = o.did;
+        device.shadows = ShadowCodec_1.ShadowCodec.decodeArray(o.shadows);
+        return device;
+    }
+    static encodeArray(arr) {
+        const list = [];
+        if (arr === null || arr === void 0 ? void 0 : arr.length) {
+            for (const o of arr) {
+                list.push(this.encode(o));
+            }
+        }
+        return list;
+    }
+    static decodeArray(arr) {
+        const instances = [];
+        if (arr === null || arr === void 0 ? void 0 : arr.length) {
+            for (const o of arr) {
+                instances.push(this.decode(o));
+            }
+        }
+        return instances;
+    }
+}
+exports.DeviceShadowCodec = DeviceShadowCodec;

package/dist/xiot/core/spec/codec/shadow/ShadowCodec.d.ts

@@ -0,0 +1,7 @@
+import { Shadow } from '../../typedef/shadow/Shadow';
+export declare class ShadowCodec {
+    static decodeArray(list: any[]): Shadow[];
+    static decodeObject(o: any): Shadow;
+    static encodeObject(s: Shadow): any;
+    static encodeArray(array: Array<Shadow>): any[];
+}