@hahnpro/flow-sdk 4.14.4

package/dist/api/sidriveiq.service.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SiDriveIqService = void 0;
+class SiDriveIqService {
+    constructor(httpClient) {
+        this.httpClient = httpClient;
+        this.basePath = 'api/sidrive/api/v0';
+    }
+    getAssets(params = {}) {
+        return this.httpClient.get(`${this.basePath}/assets`, { params });
+    }
+    getAssetCount(params = {}) {
+        return this.httpClient.get(`${this.basePath}/assets/count`, { params });
+    }
+    getAsset(assetId) {
+        return this.httpClient.get(`${this.basePath}/assets/${assetId}`);
+    }
+    getProperties(assetId, params = {}) {
+        return this.httpClient.get(`${this.basePath}/assets/${assetId}/properties`, { params });
+    }
+    getProperty(assetId, path) {
+        return this.httpClient.get(`${this.basePath}/assets/${assetId}/properties/${path}`);
+    }
+    getSubsets(assetId) {
+        return this.httpClient.get(`${this.basePath}/assets/${assetId}/subsets`);
+    }
+    getSubset(assetId, subsetId) {
+        return this.httpClient.get(`${this.basePath}/assets/${assetId}/subsets/${subsetId}`);
+    }
+    getSubsetProperties(assetId, subsetId, pathFilter) {
+        const params = Object.assign({}, (pathFilter && { path_filter: pathFilter }));
+        return this.httpClient.get(`${this.basePath}/assets/${assetId}/subsets/${subsetId}/properties`, { params });
+    }
+    getTimeSeries(assetId, path, params = {}) {
+        params = this.convertDates(params);
+        return this.httpClient.get(`${this.basePath}/assets/${assetId}/properties/${path}/timeseries`, { params });
+    }
+    getTimeSeriesCount(assetId, path, params = {}) {
+        params = this.convertDates(params);
+        return this.httpClient.get(`${this.basePath}/assets/${assetId}/properties/${path}/timeseries/count`, { params });
+    }
+    getRecentTimeSeries(assetId, path, timestamp) {
+        const params = Object.assign({}, (timestamp && { timestamp: timestamp.toISOString() }));
+        return this.httpClient.get(`${this.basePath}/assets/${assetId}/properties/${path}/timeseries/recent`, { params });
+    }
+    addTimeSeries(assetId, path, values) {
+        return this.httpClient.post(`${this.basePath}/assets/${assetId}/properties/${path}/timeseries`, values);
+    }
+    getFiles(assetId, params = {}) {
+        params = this.convertDates(params);
+        return this.httpClient.get(`${this.basePath}/assets/${assetId}/files/import`, { params });
+    }
+    getFileCount(assetId, params = {}) {
+        params = this.convertDates(params);
+        return this.httpClient.get(`${this.basePath}/assets/${assetId}/files/import/count`, { params });
+    }
+    getFile(assetId, fileId) {
+        return this.httpClient.get(`${this.basePath}/assets/${assetId}/files/import/${fileId}`);
+    }
+    downloadFile(assetId, fileId) {
+        return this.httpClient.get(`${this.basePath}/assets/${assetId}/files/import/${fileId}/download`, {
+            headers: { 'response-type': 'arraybuffer' },
+            responseType: 'arraybuffer',
+        });
+    }
+    uploadFile(assetId, form) {
+        const headers = Object.assign({}, form.getHeaders());
+        return this.httpClient.post(`${this.basePath}/assets/${assetId}/files/import`, form, { headers });
+    }
+    deleteFile(assetId, fileId) {
+        return this.httpClient.delete(`${this.basePath}/assets/${assetId}/files/import/${fileId}`);
+    }
+    getLogs(assetId, params) {
+        params = this.convertDates(params);
+        return this.httpClient.get(`${this.basePath}/assets/${assetId}/logs`, { params });
+    }
+    getLogCount(assetId, params) {
+        params = this.convertDates(params);
+        return this.httpClient.get(`${this.basePath}/assets/${assetId}/logs/count`, { params });
+    }
+    addLog(assetId, item) {
+        return this.httpClient.post(`${this.basePath}/assets/${assetId}/logs`, item);
+    }
+    sendMail(mail) {
+        return this.httpClient.post(`${this.basePath}/mails`, mail);
+    }
+    convertDates(params) {
+        if (params.from) {
+            params.from = new Date(params.from).toISOString();
+        }
+        if (params.to) {
+            params.to = new Date(params.to).toISOString();
+        }
+        return params;
+    }
+}
+exports.SiDriveIqService = SiDriveIqService;

package/dist/api/task.interface.d.ts

@@ -0,0 +1,22 @@
+export interface Task {
+    id: string;
+    name: string;
+    desc?: string;
+    tags?: string[];
+    author?: string;
+    readPermissions: string[];
+    readWritePermissions: string[];
+    assetRef?: string;
+    eventRef?: string;
+    expiryDate?: Date;
+    parent?: string;
+    subTasks?: string[];
+    assignedTo: string[];
+    status?: string;
+    acceptedBy?: string;
+    rejectReason?: string;
+    statusHistoryLog?: string[];
+    weight?: number;
+    createdAt?: string;
+    updatedAt?: string;
+}

package/dist/api/task.interface.js

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

package/dist/api/task.service.d.ts

@@ -0,0 +1,7 @@
+import { DataService } from './data.service';
+import { HttpClient } from './http.service';
+import { Task } from './task.interface';
+export declare class TaskService extends DataService<Task> {
+    constructor(httpClient: HttpClient);
+    createTaskAttachedToAsset(dto: any): Promise<Task>;
+}

package/dist/api/task.service.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TaskService = void 0;
+const data_service_1 = require("./data.service");
+class TaskService extends data_service_1.DataService {
+    constructor(httpClient) {
+        super(httpClient, process.env.DEBUG_TSK_URL || 'api/tasks');
+    }
+    createTaskAttachedToAsset(dto) {
+        return this.httpClient.post(this.basePath, dto);
+    }
+}
+exports.TaskService = TaskService;

package/dist/api/timeseries.interface.d.ts

@@ -0,0 +1,39 @@
+export interface TimeSeries {
+    id?: string;
+    name: string;
+    description: string;
+    readPermissions: string[];
+    readWritePermissions: string[];
+    assetRef?: string;
+    assetRef$name?: string;
+    assetTsId?: string;
+    minDate: Date;
+    metrics?: string[];
+    maxBucketTimeRange: number;
+    tsRef?: [string];
+    autoDelData: Date;
+    autoDelBucket: Date;
+}
+export interface TimeSeriesCondition {
+    operator: string;
+    values: number[];
+}
+export interface TimeSeriesValue {
+    timestamp: number;
+    value: number | string | any;
+    [key: string]: any;
+}
+export interface TimeSeriesBucket {
+    id?: string;
+    ts: TimeSeries;
+    prev: TimeSeriesBucket;
+    next: TimeSeriesBucket;
+    prevHash: string;
+    from: Date;
+    to: Date;
+    bucketSize: number;
+    data: TimeSeriesValue[];
+    meta: any;
+    final: boolean;
+}
+export declare type TS_GROUPS = 'none' | '10s' | '1m' | '5m' | '15m' | '30m' | '1h' | '3h' | '6h' | '12h' | '1d' | '7d';

package/dist/api/timeseries.interface.js

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

package/dist/api/timeseries.service.d.ts

@@ -0,0 +1,17 @@
+import { Paginated } from './data.interface';
+import { DataService } from './data.service';
+import { HttpClient } from './http.service';
+import { TS_GROUPS, TimeSeries, TimeSeriesValue } from './timeseries.interface';
+export declare class TimeSeriesService extends DataService<TimeSeries> {
+    constructor(httpClient: HttpClient);
+    addValue(id: string, value: {
+        [values: string]: any;
+    }): Promise<void>;
+    addAssetTimeSeriesValues(assetId: string, name: string, readPermissions: string[], readWritePermissions: string[], values: {
+        [timestamp: string]: any;
+    }): Promise<TimeSeries>;
+    getMostRecentValue(id: string, before: Date): Promise<TimeSeriesValue>;
+    getValues(id: string, from: number, limit?: number, group?: TS_GROUPS): Promise<TimeSeriesValue[]>;
+    getValuesOfPeriod(id: string, from: number, to: number, group?: TS_GROUPS): Promise<TimeSeriesValue[]>;
+    getManyByAsset(assetId: string, names?: string[]): Promise<Paginated<TimeSeries[]>>;
+}

package/dist/api/timeseries.service.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TimeSeriesService = void 0;
+const data_service_1 = require("./data.service");
+class TimeSeriesService extends data_service_1.DataService {
+    constructor(httpClient) {
+        super(httpClient, process.env.DEBUG_TSM_URL || 'api/tsm');
+    }
+    addValue(id, value) {
+        return this.httpClient.post(`${this.basePath}/${id}`, value);
+    }
+    addAssetTimeSeriesValues(assetId, name, readPermissions, readWritePermissions, values) {
+        const dto = {
+            name,
+            readPermissions,
+            readWritePermissions,
+            values,
+        };
+        return this.httpClient.post(`${this.basePath}/assets/${assetId}`, dto);
+    }
+    getMostRecentValue(id, before) {
+        const params = before ? { before: before.toISOString() } : {};
+        return this.httpClient.get(`${this.basePath}/${id}/recent`, { params });
+    }
+    getValues(id, from, limit, group) {
+        const params = { limit, group };
+        return this.httpClient.get(`${this.basePath}/${id}/${from}`, { params });
+    }
+    getValuesOfPeriod(id, from, to, group) {
+        const params = { group };
+        return this.httpClient.get(`${this.basePath}/${id}/${from}/${to}`, { params });
+    }
+    getManyByAsset(assetId, names) {
+        const params = Array.isArray(names) ? { names: names.join() } : {};
+        return this.httpClient.get(`${this.basePath}/asset/${assetId}`, { params });
+    }
+}
+exports.TimeSeriesService = TimeSeriesService;

package/dist/api/user.service.d.ts

@@ -0,0 +1,6 @@
+import { HttpClient } from './http.service';
+export declare class UserService {
+    private httpClient;
+    constructor(httpClient: HttpClient);
+    getCurrentUserRoles(): Promise<string[]>;
+}

package/dist/api/user.service.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserService = void 0;
+const tslib_1 = require("tslib");
+const jwt_decode_1 = (0, tslib_1.__importDefault)(require("jwt-decode"));
+class UserService {
+    constructor(httpClient) {
+        this.httpClient = httpClient;
+    }
+    async getCurrentUserRoles() {
+        try {
+            const token = await this.httpClient.getAccessToken();
+            const decode = (0, jwt_decode_1.default)(token);
+            return decode.realm_access.roles;
+        }
+        catch (err) {
+            return null;
+        }
+    }
+}
+exports.UserService = UserService;

package/dist/extra-validators.d.ts

@@ -0,0 +1 @@
+export declare function IncompatableWith(incompatibleSiblings: string[]): (target: any, key: string) => void;

package/dist/extra-validators.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IncompatableWith = void 0;
+const tslib_1 = require("tslib");
+const class_validator_1 = require("class-validator");
+let IsNotSiblingOfConstraint = class IsNotSiblingOfConstraint {
+    validate(value, args) {
+        if ((0, class_validator_1.isDefined)(value)) {
+            return this.getFailedConstraints(args).length === 0;
+        }
+        else {
+            return !args.constraints.every((prop) => !(0, class_validator_1.isDefined)(args.object[prop]));
+        }
+    }
+    defaultMessage(args) {
+        if (args.value) {
+            return `${args.property} cannot exist alongside the following defined properties: ${this.getFailedConstraints(args).join(', ')}`;
+        }
+        else {
+            return `at least one of the properties must be defined`;
+        }
+    }
+    getFailedConstraints(args) {
+        return args.constraints.filter((prop) => (0, class_validator_1.isDefined)(args.object[prop]));
+    }
+};
+IsNotSiblingOfConstraint = (0, tslib_1.__decorate)([
+    (0, class_validator_1.ValidatorConstraint)({ async: false })
+], IsNotSiblingOfConstraint);
+function IsNotSiblingOf(props, validationOptions) {
+    return (object, propertyName) => {
+        (0, class_validator_1.registerDecorator)({
+            target: object.constructor,
+            propertyName,
+            options: validationOptions,
+            constraints: props,
+            validator: IsNotSiblingOfConstraint,
+        });
+    };
+}
+function incompatibleSiblingsNotPresent(incompatibleSiblings) {
+    return (o, v) => Boolean((0, class_validator_1.isDefined)(v) || incompatibleSiblings.every((prop) => !(0, class_validator_1.isDefined)(o[prop])));
+}
+function IncompatableWith(incompatibleSiblings) {
+    const notSibling = IsNotSiblingOf(incompatibleSiblings);
+    const validateIf = (0, class_validator_1.ValidateIf)(incompatibleSiblingsNotPresent(incompatibleSiblings));
+    return (target, key) => {
+        notSibling(target, key);
+        validateIf(target, key);
+    };
+}
+exports.IncompatableWith = IncompatableWith;

package/dist/flow.interface.d.ts

@@ -0,0 +1,41 @@
+export interface FlowContext {
+    deploymentId?: string;
+    diagramId?: string;
+    flowId?: string;
+}
+export interface FlowElementContext extends FlowContext {
+    id: string;
+    name?: string;
+    functionFqn?: string;
+    inputStreamId?: string;
+}
+export interface DeploymentMessage extends Record<string, any> {
+    elementId?: string;
+}
+interface FlowElement {
+    id: string;
+    name?: string;
+    properties?: Record<string, any>;
+    module: string;
+    functionFqn: string;
+}
+interface FlowConnection {
+    id: string;
+    name?: string;
+    source: string;
+    target: string;
+    sourceStream?: string;
+    targetStream?: string;
+}
+export interface Flow {
+    elements: FlowElement[];
+    connections: FlowConnection[];
+    modules?: string[];
+    properties?: Record<string, any>;
+    context?: FlowContext;
+}
+export interface StreamOptions {
+    concurrent?: number;
+}
+export declare type ClassType<T> = new (...args: any[]) => T;
+export {};

package/dist/flow.interface.js

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

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+export * from './api';
+export * from './flow.interface';
+export * from './utils';
+export * from './FlowApplication';
+export * from './FlowElement';
+export * from './FlowEvent';
+export * from './FlowLogger';
+export * from './FlowModule';
+export * from './TestModule';
+export * from './unit-decorators';
+export { IncompatableWith } from './extra-validators';

package/dist/index.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IncompatableWith = void 0;
+const tslib_1 = require("tslib");
+(0, tslib_1.__exportStar)(require("./api"), exports);
+(0, tslib_1.__exportStar)(require("./flow.interface"), exports);
+(0, tslib_1.__exportStar)(require("./utils"), exports);
+(0, tslib_1.__exportStar)(require("./FlowApplication"), exports);
+(0, tslib_1.__exportStar)(require("./FlowElement"), exports);
+(0, tslib_1.__exportStar)(require("./FlowEvent"), exports);
+(0, tslib_1.__exportStar)(require("./FlowLogger"), exports);
+(0, tslib_1.__exportStar)(require("./FlowModule"), exports);
+(0, tslib_1.__exportStar)(require("./TestModule"), exports);
+(0, tslib_1.__exportStar)(require("./unit-decorators"), exports);
+var extra_validators_1 = require("./extra-validators");
+Object.defineProperty(exports, "IncompatableWith", { enumerable: true, get: function () { return extra_validators_1.IncompatableWith; } });

package/dist/rpc_server.py

@@ -0,0 +1,115 @@
+import asyncio
+import json
+from asyncio import Future
+from functools import partial, wraps
+from aio_pika import IncomingMessage, Exchange, Message, connect_robust, ExchangeType
+import os
+
+user = ""
+try:
+    user = os.environ["RABBIT_USER"]
+except:
+    user = "guest"
+
+password = ""
+try:
+    password = os.environ["RABBIT_PASSWORD"]
+except:
+    password = "guest"
+
+host = ""
+try:
+    host = os.environ["RABBIT_HOST"]
+except:
+    host = "localhost"
+
+port = ""
+try:
+    port = os.environ["RABBIT_PORT"]
+except:
+    port = "5672"
+
+routingKey = ""
+try:
+    routingKey = os.environ["RPC_ROUTING_KEY"]
+except:
+    routingKey = "rpc"
+
+remoteProcedures = {}
+
+
+def RemoteProcedure(func):
+    global remoteProcedures
+
+    @wraps(func)
+    def function_wrapper(*args, **kwargs):
+        return func(*args, **kwargs)
+
+    remoteProcedures[func.__name__] = func
+
+    return function_wrapper
+
+
+loop = asyncio.get_event_loop()
+
+
+async def on_message(exchange: Exchange, message: IncomingMessage):
+    def callback(future: Future):
+        try:
+            res = future.result()
+            reply1 = {"type": "reply", "value": res}
+        except Exception as err:
+            # print(traceback.format_list(traceback.extract_stack(err)))
+            reply1 = {"type": "error", "message": str(err), "stack": "failed"}
+
+        asyncio.ensure_future(sendReply(exchange, reply1, message), loop=loop)
+
+    with message.process():
+        request = json.loads(message.body.decode())
+
+        # call function
+        if remoteProcedures.keys().__contains__(request["functionName"]):
+            func = remoteProcedures.get(request["functionName"])
+            future = loop.run_in_executor(None, func, *request["arguments"])
+            future.add_done_callback(callback)
+
+        else:
+            reply = {
+                "type": "error",
+                "message": request["functionName"] + " is not a function",
+            }
+            await sendReply(exchange, reply, originalMessage=message)
+
+
+async def sendReply(exchange: Exchange, reply, originalMessage: Message):
+    await exchange.publish(
+        Message(
+            body=json.dumps(reply).encode("utf-8"),
+            correlation_id=originalMessage.correlation_id
+        ),
+        routing_key=originalMessage.reply_to,
+    )
+
+
+async def main(loop, routing_key):
+    url = "amqp://%s:%s@%s:%s/" % (user, password, host, port)
+    connection = await connect_robust(
+        url, loop=loop
+    )
+
+    channel = await connection.channel()
+
+    dest_exchange = await channel.declare_exchange(name="rpc_direct_exchange", type=ExchangeType.DIRECT)
+
+    queue = await channel.declare_queue("", exclusive=True)
+
+    await queue.bind(dest_exchange, routing_key)
+
+    await queue.consume(partial(
+        on_message, channel.default_exchange)
+    )
+
+
+def start_consumer(routing_key=routingKey):
+    loop.create_task(main(loop, routing_key))
+    loop.run_forever()

package/dist/unit-decorators.d.ts

@@ -0,0 +1,39 @@
+import { ValidationOptions } from 'class-validator';
+export declare function IsTime(unit?: string, validationOptions?: ValidationOptions): (object: any, propertyName: string) => void;
+export declare function IsLength(unit?: string, validationOptions?: ValidationOptions): (object: any, propertyName: string) => void;
+export declare function IsMass(unit?: string, validationOptions?: ValidationOptions): (object: any, propertyName: string) => void;
+export declare function IsElectricCurrent(unit?: string, validationOptions?: ValidationOptions): (object: any, propertyName: string) => void;
+export declare function IsThermodynamicTemperature(unit?: string, validationOptions?: ValidationOptions): (object: any, propertyName: string) => void;
+export declare function IsAmountOfSubstance(unit?: string, validationOptions?: ValidationOptions): (object: any, propertyName: string) => void;
+export declare function IsLuminousIntensity(unit?: string, validationOptions?: ValidationOptions): (object: any, propertyName: string) => void;
+export declare function IsVoltage(unit?: string, validationOptions?: ValidationOptions): (object: any, propertyName: string) => void;
+export declare function IsForce(unit?: string, validationOptions?: ValidationOptions): (object: any, propertyName: string) => void;
+export declare function IsEnergy(unit?: string, validationOptions?: ValidationOptions): (object: any, propertyName: string) => void;
+export declare function IsPower(unit?: string, validationOptions?: ValidationOptions): (object: any, propertyName: string) => void;
+export declare function IsPressure(unit?: string, validationOptions?: ValidationOptions): (object: any, propertyName: string) => void;
+export declare function IsFrequency(unit?: string, validationOptions?: ValidationOptions): (object: any, propertyName: string) => void;
+export declare function IsArea(unit?: string, validationOptions?: ValidationOptions): (object: any, propertyName: string) => void;
+export declare function IsVolume(unit?: string, validationOptions?: ValidationOptions): (object: any, propertyName: string) => void;
+export declare function IsAngle(unit?: string, validationOptions?: ValidationOptions): (object: any, propertyName: string) => void;
+export declare function IsTranslationalAcceleration(unit?: string, validationOptions?: ValidationOptions): (object: any, propertyName: string) => void;
+export declare function IsTranslationalVelocity(unit?: string, validationOptions?: ValidationOptions): (object: any, propertyName: string) => void;
+export declare function IsTranslationalDisplacement(unit?: string, validationOptions?: ValidationOptions): (object: any, propertyName: string) => void;
+export declare function IsSpringConstant(unit?: string, validationOptions?: ValidationOptions): (object: any, propertyName: string) => void;
+export declare function IsRotationalAcceleration(unit?: string, validationOptions?: ValidationOptions): (object: any, propertyName: string) => void;
+export declare function IsRotationalVelocity(unit?: string, validationOptions?: ValidationOptions): (object: any, propertyName: string) => void;
+export declare function IsRotationalDisplacement(unit?: string, validationOptions?: ValidationOptions): (object: any, propertyName: string) => void;
+export declare function IsTorque(unit?: string, validationOptions?: ValidationOptions): (object: any, propertyName: string) => void;
+export declare function IsMomentOfInertia(unit?: string, validationOptions?: ValidationOptions): (object: any, propertyName: string) => void;
+export declare function IsRotatingUnbalance(unit?: string, validationOptions?: ValidationOptions): (object: any, propertyName: string) => void;
+export declare function IsMechanicalPower(unit?: string, validationOptions?: ValidationOptions): (object: any, propertyName: string) => void;
+export declare function IsMechanicalEnergy(unit?: string, validationOptions?: ValidationOptions): (object: any, propertyName: string) => void;
+export declare function IsDynamicViscosity(unit?: string, validationOptions?: ValidationOptions): (object: any, propertyName: string) => void;
+export declare function IsVolumeFlow(unit?: string, validationOptions?: ValidationOptions): (object: any, propertyName: string) => void;
+export declare function IsMassFlow(unit?: string, validationOptions?: ValidationOptions): (object: any, propertyName: string) => void;
+export declare function IsHeatFlux(unit?: string, validationOptions?: ValidationOptions): (object: any, propertyName: string) => void;
+export declare function IsThermalEnergy(unit?: string, validationOptions?: ValidationOptions): (object: any, propertyName: string) => void;
+export declare function IsSpecificHeatCapacity(unit?: string, validationOptions?: ValidationOptions): (object: any, propertyName: string) => void;
+export declare function IsThermalTransmittance(unit?: string, validationOptions?: ValidationOptions): (object: any, propertyName: string) => void;
+export declare function IsElectricalPower(unit?: string, validationOptions?: ValidationOptions): (object: any, propertyName: string) => void;
+export declare function IsElectricalEnergy(unit?: string, validationOptions?: ValidationOptions): (object: any, propertyName: string) => void;
+export declare function IsElectricalFrequency(unit?: string, validationOptions?: ValidationOptions): (object: any, propertyName: string) => void;