@hahnpro/flow-sdk 4.14.4

package/dist/api/mock/content.mock.service.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContentMockService = void 0;
+const stream_1 = require("stream");
+const content_interface_1 = require("../content.interface");
+const data_mock_service_1 = require("./data.mock.service");
+class ContentMockService extends data_mock_service_1.DataMockService {
+    constructor(contents, contentData) {
+        super();
+        this.contentData = new Map();
+        this.data = contents;
+        for (let i = 0; i < contents.length; i++) {
+            this.contentData.set(contents[i].id, contentData[i]);
+        }
+    }
+    download(id, second) {
+        let returnType;
+        if (typeof second === 'boolean' || !second) {
+            returnType = second ? content_interface_1.ReturnType.ARRAYBUFFER : content_interface_1.ReturnType.BLOB;
+        }
+        else {
+            returnType = second;
+        }
+        const content = this.contentData.get(id);
+        switch (returnType) {
+            case content_interface_1.ReturnType.TEXT:
+                if (typeof content === 'string') {
+                    return Promise.resolve(content);
+                }
+                else {
+                    return Promise.resolve(JSON.stringify(content));
+                }
+            case content_interface_1.ReturnType.JSON:
+                if (typeof content !== 'string') {
+                    return Promise.resolve(content);
+                }
+                else {
+                    return Promise.resolve(JSON.parse(content));
+                }
+            case content_interface_1.ReturnType.NODEBUFFER:
+                return Promise.resolve(Buffer.from(this.contentData.get(id)));
+            case content_interface_1.ReturnType.BLOB:
+                if (global.Blob) {
+                    return Promise.resolve(new Blob([Buffer.from(this.contentData.get(id)).buffer]));
+                }
+                else {
+                    if (typeof content === 'string') {
+                        return Promise.resolve(content);
+                    }
+                    else {
+                        return Promise.resolve(JSON.stringify(content));
+                    }
+                }
+            case content_interface_1.ReturnType.ARRAYBUFFER:
+                return Promise.resolve(Buffer.from(this.contentData.get(id)).buffer);
+            case content_interface_1.ReturnType.NODESTREAM:
+                return Promise.resolve(stream_1.Readable.from(this.contentData.get(id)));
+        }
+    }
+    upload(form) {
+        return Promise.resolve(undefined);
+    }
+}
+exports.ContentMockService = ContentMockService;

package/dist/api/mock/data.mock.service.d.ts

@@ -0,0 +1,13 @@
+import { Filter, Paginated, RequestParameter } from '../data.interface';
+import { DataService } from '../data.service';
+export declare class DataMockService<T> extends DataService<T> {
+    protected data: T[];
+    constructor();
+    addMany(dto: any[]): Promise<T[]>;
+    addOne(dto: any): Promise<T>;
+    deleteOne(id: string): Promise<any>;
+    getMany(params?: RequestParameter): Promise<Paginated<T[]>>;
+    getManyFiltered(filter: Filter, params?: RequestParameter): Promise<Paginated<T[]>>;
+    getOne(id: string, options?: any): Promise<T>;
+    updateOne(id: string, dto: any): Promise<T>;
+}

package/dist/api/mock/data.mock.service.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataMockService = void 0;
+const data_service_1 = require("../data.service");
+class DataMockService extends data_service_1.DataService {
+    constructor() {
+        super(null, null);
+        this.data = [];
+    }
+    async addMany(dto) {
+        const map = dto.map((v) => this.addOne(v));
+        return Promise.all(map);
+    }
+    addOne(dto) {
+        this.data.push(dto);
+        return Promise.resolve(dto);
+    }
+    deleteOne(id) {
+        const index = this.data.findIndex((v) => v.id === id);
+        this.data.splice(index, 1);
+        return Promise.resolve(undefined);
+    }
+    getMany(params) {
+        const data = this.data;
+        const page = {
+            docs: data,
+            limit: params && params.limit ? params.limit : Number.MAX_SAFE_INTEGER,
+            total: data.length,
+        };
+        return Promise.resolve(page);
+    }
+    async getManyFiltered(filter, params = {}) {
+        const paginated = await this.getMany(params);
+        const newData = paginated.docs.filter((v) => { var _a; return filter.parent === v.parent || ((_a = filter.tags) === null || _a === void 0 ? void 0 : _a.some((tag) => { var _a; return (_a = v.tags) === null || _a === void 0 ? void 0 : _a.contains(tag); })) || filter.type === v.tag; });
+        const page = {
+            docs: newData,
+            limit: paginated.limit || Number.MAX_SAFE_INTEGER,
+            total: newData.length,
+        };
+        return Promise.resolve(page);
+    }
+    getOne(id, options) {
+        const t = this.data.find((v) => v.id === id);
+        return Promise.resolve(t);
+    }
+    async updateOne(id, dto) {
+        await this.deleteOne(id);
+        const t = await this.addOne(dto);
+        return Promise.resolve(t);
+    }
+}
+exports.DataMockService = DataMockService;

package/dist/api/mock/endpoint.mock.service.d.ts

@@ -0,0 +1,15 @@
+import { Endpoint } from '../endpoint.interface';
+import { EndpointService } from '../endpoint.service';
+import { DataMockService } from './data.mock.service';
+export declare class EndpointMockService extends DataMockService<Endpoint> implements EndpointService {
+    constructor(endpoints: Endpoint[]);
+    sendNotification(endpointId: string, subject: string, message: string, group: string, eventLink?: string): Promise<void>;
+    readLastLogByGroup(endpointId: string, group: string): Promise<{
+        id: string;
+        endpoint: string;
+        group: string;
+        data: string;
+        createdAt: string;
+        updatedAt: string;
+    }>;
+}

package/dist/api/mock/endpoint.mock.service.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EndpointMockService = void 0;
+const data_mock_service_1 = require("./data.mock.service");
+class EndpointMockService extends data_mock_service_1.DataMockService {
+    constructor(endpoints) {
+        super();
+        this.data = endpoints;
+    }
+    sendNotification(endpointId, subject, message, group, eventLink) {
+        return Promise.resolve();
+    }
+    readLastLogByGroup(endpointId, group) {
+        return Promise.resolve({
+            id: 'endpointlog1',
+            endpoint: '',
+            group: 'test',
+            data: 'OK',
+            createdAt: new Date().toISOString(),
+            updatedAt: new Date().toISOString(),
+        });
+    }
+}
+exports.EndpointMockService = EndpointMockService;

package/dist/api/mock/events.mock.service.d.ts

@@ -0,0 +1,7 @@
+import { Event } from '../events.interface';
+import { EventsService } from '../events.service';
+import { DataMockService } from './data.mock.service';
+export declare class EventsMockService extends DataMockService<Event> implements EventsService {
+    constructor(events: Event[]);
+    getLastEventByAssetAndGroup(assetId: string, group: string): Promise<Event>;
+}

package/dist/api/mock/events.mock.service.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventsMockService = void 0;
+const data_mock_service_1 = require("./data.mock.service");
+class EventsMockService extends data_mock_service_1.DataMockService {
+    constructor(events) {
+        super();
+        this.data = events;
+    }
+    getLastEventByAssetAndGroup(assetId, group) {
+        return Promise.resolve(this.data[this.data.length - 1]);
+    }
+}
+exports.EventsMockService = EventsMockService;

package/dist/api/mock/index.d.ts

@@ -0,0 +1,9 @@
+export * from './api.mock';
+export * from './asset.mock.service';
+export * from './assetTypes.mock.service';
+export * from './content.mock.service';
+export * from './data.mock.service';
+export * from './secret.mock.service';
+export * from './timeseries.mock.service';
+export * from './task.mock.service';
+export * from './events.mock.service';

package/dist/api/mock/index.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+(0, tslib_1.__exportStar)(require("./api.mock"), exports);
+(0, tslib_1.__exportStar)(require("./asset.mock.service"), exports);
+(0, tslib_1.__exportStar)(require("./assetTypes.mock.service"), exports);
+(0, tslib_1.__exportStar)(require("./content.mock.service"), exports);
+(0, tslib_1.__exportStar)(require("./data.mock.service"), exports);
+(0, tslib_1.__exportStar)(require("./secret.mock.service"), exports);
+(0, tslib_1.__exportStar)(require("./timeseries.mock.service"), exports);
+(0, tslib_1.__exportStar)(require("./task.mock.service"), exports);
+(0, tslib_1.__exportStar)(require("./events.mock.service"), exports);

package/dist/api/mock/secret.mock.service.d.ts

@@ -0,0 +1,6 @@
+import { Secret } from '../secret.interface';
+import { SecretService } from '../secret.service';
+import { DataMockService } from './data.mock.service';
+export declare class SecretMockService extends DataMockService<Secret> implements SecretService {
+    constructor(secrets: Secret[]);
+}

package/dist/api/mock/secret.mock.service.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SecretMockService = void 0;
+const data_mock_service_1 = require("./data.mock.service");
+class SecretMockService extends data_mock_service_1.DataMockService {
+    constructor(secrets) {
+        super();
+        this.data = secrets;
+    }
+}
+exports.SecretMockService = SecretMockService;

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

@@ -0,0 +1,7 @@
+import { Task } from '../task.interface';
+import { TaskService } from '../task.service';
+import { DataMockService } from './data.mock.service';
+export declare class TaskMockService extends DataMockService<Task> implements TaskService {
+    constructor(tasks: Task[]);
+    createTaskAttachedToAsset(dto: any): Promise<Task>;
+}

package/dist/api/mock/task.mock.service.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TaskMockService = void 0;
+const data_mock_service_1 = require("./data.mock.service");
+class TaskMockService extends data_mock_service_1.DataMockService {
+    constructor(tasks) {
+        super();
+        this.data = tasks;
+    }
+    async createTaskAttachedToAsset(dto) {
+        this.data.push(dto);
+        return Promise.resolve(dto);
+    }
+}
+exports.TaskMockService = TaskMockService;

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

@@ -0,0 +1,19 @@
+import { Paginated } from '../data.interface';
+import { TS_GROUPS, TimeSeries, TimeSeriesValue } from '../timeseries.interface';
+import { TimeSeriesService } from '../timeseries.service';
+import { DataMockService } from './data.mock.service';
+export declare class TimeseriesMockService extends DataMockService<TimeSeries & {
+    data: TimeSeriesValue[];
+}> implements TimeSeriesService {
+    constructor(timeseries: TimeSeries[], timeseriesValues: TimeSeriesValue[][]);
+    addAssetTimeSeriesValues(assetId: string, name: string, readPermissions: string[], readWritePermissions: string[], values: {
+        [p: string]: any;
+    }): Promise<TimeSeries>;
+    addValue(id: string, value: {
+        [p: string]: any;
+    }): Promise<void>;
+    getManyByAsset(assetId: string, names?: string[]): Promise<Paginated<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[]>;
+}

package/dist/api/mock/timeseries.mock.service.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TimeseriesMockService = void 0;
+const data_mock_service_1 = require("./data.mock.service");
+class TimeseriesMockService extends data_mock_service_1.DataMockService {
+    constructor(timeseries, timeseriesValues) {
+        super();
+        this.data = timeseries.map((value, index) => (Object.assign(Object.assign({}, value), { data: timeseriesValues[index] })));
+    }
+    addAssetTimeSeriesValues(assetId, name, readPermissions, readWritePermissions, values) {
+        const ts = this.data.find((v) => v.assetRef === assetId);
+        if (!ts) {
+            const data = values.map((v) => (Object.assign({ timestamp: Date.now() }, v)));
+            const dto = {
+                autoDelBucket: undefined,
+                autoDelData: undefined,
+                description: '',
+                maxBucketTimeRange: 0,
+                minDate: undefined,
+                name,
+                readPermissions,
+                readWritePermissions,
+                assetRef: assetId,
+                data,
+            };
+            return this.addOne(dto);
+        }
+        ts.data = Object.assign(Object.assign({}, ts.data), values);
+        return Promise.resolve(ts);
+    }
+    async addValue(id, value) {
+        const ts = await this.getOne(id, {});
+        ts.data.push({ timestamp: new Date().getDate(), value });
+        return;
+    }
+    getManyByAsset(assetId, names) {
+        const page = { docs: [], limit: 10, total: 0 };
+        for (const datum of this.data) {
+            if (datum.assetRef === assetId) {
+                page.docs.push(datum);
+            }
+            if (page.docs.length === page.limit) {
+                break;
+            }
+        }
+        page.total = page.docs.length;
+        return Promise.resolve(page);
+    }
+    async getMostRecentValue(id, before) {
+        const ts = await this.getOne(id, {});
+        for (const datum of ts.data) {
+            if (datum.timestamp < before.getDate()) {
+                return datum;
+            }
+        }
+    }
+    async getValues(id, from, limit, group) {
+        let timeSeriesValues = await this.getValuesOfPeriod(id, from, new Date().getDate(), group);
+        if (limit) {
+            timeSeriesValues = timeSeriesValues.slice(0, limit);
+        }
+        return timeSeriesValues;
+    }
+    async getValuesOfPeriod(id, from, to, group) {
+        const ts = await this.getOne(id, {});
+        return ts.data.filter((v) => v.timestamp < to && v.timestamp > from);
+    }
+}
+exports.TimeseriesMockService = TimeseriesMockService;

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

@@ -0,0 +1,7 @@
+import { UserService } from '../user.service';
+import { UserInit } from './api.mock';
+export declare class UserMockService extends UserService {
+    private users;
+    constructor(users: UserInit);
+    getCurrentUserRoles(): Promise<string[]>;
+}

package/dist/api/mock/user.mock.service.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserMockService = void 0;
+const user_service_1 = require("../user.service");
+class UserMockService extends user_service_1.UserService {
+    constructor(users) {
+        super(null);
+        this.users = users;
+    }
+    getCurrentUserRoles() {
+        return Promise.resolve(this.users.roles);
+    }
+}
+exports.UserMockService = UserMockService;

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

@@ -0,0 +1,11 @@
+import { AxiosRequestConfig } from 'axios';
+import { HttpClient } from './http.service';
+export declare class ProxyService {
+    private readonly httpClient;
+    constructor(httpClient: HttpClient);
+    delete: <T>(proxyId: string, path: string, config?: AxiosRequestConfig) => Promise<T>;
+    get: <T>(proxyId: string, path: string, config?: AxiosRequestConfig) => Promise<T>;
+    post: <T>(proxyId: string, path: string, data: any, config?: AxiosRequestConfig) => Promise<T>;
+    put: <T>(proxyId: string, path: string, data: any, config?: AxiosRequestConfig) => Promise<T>;
+    private url;
+}

package/dist/api/proxy.service.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProxyService = void 0;
+class ProxyService {
+    constructor(httpClient) {
+        this.httpClient = httpClient;
+        this.delete = (proxyId, path, config) => this.httpClient.delete(this.url(proxyId, path), config);
+        this.get = (proxyId, path, config) => this.httpClient.get(this.url(proxyId, path), config);
+        this.post = (proxyId, path, data, config) => this.httpClient.post(this.url(proxyId, path), data, config);
+        this.put = (proxyId, path, data, config) => this.httpClient.put(this.url(proxyId, path), data, config);
+    }
+    url(proxyId, path = '/') {
+        path = path.startsWith('/') ? path : `/${path}`;
+        return `api/${proxyId}${path}`;
+    }
+}
+exports.ProxyService = ProxyService;

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

@@ -0,0 +1,7 @@
+export interface Secret {
+    id?: string;
+    name: string;
+    key: string;
+    readPermissions: string[];
+    readWritePermissions: string[];
+}

package/dist/api/secret.interface.js

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

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

@@ -0,0 +1,6 @@
+import { DataService } from './data.service';
+import { HttpClient } from './http.service';
+import { Secret } from './secret.interface';
+export declare class SecretService extends DataService<Secret> {
+    constructor(httpClient: HttpClient);
+}

package/dist/api/secret.service.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SecretService = void 0;
+const data_service_1 = require("./data.service");
+class SecretService extends data_service_1.DataService {
+    constructor(httpClient) {
+        super(httpClient, process.env.DEBUG_SECRET_URL || '/api/secrets');
+    }
+}
+exports.SecretService = SecretService;

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

@@ -0,0 +1,104 @@
+export interface Asset {
+    id: string;
+    type_id: string;
+    name: string;
+    description: string;
+    tag: string;
+    agent_id: string;
+    is_active: boolean;
+}
+export interface File {
+    id: string;
+    name: string;
+    status: string;
+    content_type: string;
+    created_at: string;
+    length: number;
+}
+export interface List<T> {
+    cursor: string;
+    values: T[];
+}
+export interface Log {
+    ref_id: string;
+    ref_type: RefType;
+    severity: Severity;
+    created_at: string;
+    text: string;
+    actor: string;
+    category: string;
+    item_type: string;
+    gone_at: string;
+}
+export interface Mail {
+    from: string;
+    to: string;
+    cc?: string;
+    subject: string;
+    body: string;
+    is_html: boolean;
+}
+export interface Property {
+    path: string;
+    name: string;
+    unit: string;
+    data_type: string;
+    is_mandatory: boolean;
+}
+export declare type RefType = 'Unknown' | 'Asset' | 'AssetType' | 'Container' | 'ContainerType' | 'Action' | 'AssetReport' | 'ReportType';
+export declare type Severity = 'Info' | 'Warning' | 'Error' | 'All';
+export interface Subset {
+    id: string;
+    name: string;
+}
+export interface TimeSeries {
+    ts: string;
+    v: any;
+}
+export interface RangeParams {
+    from?: string | Date;
+    to?: string | Date;
+}
+export interface CursorParams {
+    limit?: number;
+    cursor?: string;
+}
+export interface PaginationParams {
+    page?: number;
+    page_size?: number;
+    sort?: string;
+}
+export interface AssetsParams extends CursorParams {
+    name_filter?: string;
+    type_filter?: string;
+    tag_filter?: string;
+    agent_filter?: string;
+}
+export interface PropertiesParams extends CursorParams {
+    path_filter?: string;
+    subset_filter?: string;
+    only_assigned?: boolean;
+    only_mandatory?: boolean;
+}
+export interface TimeSeriesParams extends CursorParams, RangeParams {
+}
+export interface FilesCountParams extends RangeParams {
+    name_filter?: string;
+    status_filter?: 'Imported' | 'Scanned' | 'ScannedButEmpty';
+    exclude?: string;
+}
+export interface FilesParams extends FilesCountParams, PaginationParams {
+}
+export interface LogsParams extends PaginationParams, RangeParams {
+    categories: string[];
+    severity?: Severity;
+    filter?: string;
+}
+export interface LogDto {
+    text: string;
+    severity: Severity;
+    created_at: string;
+    actor: string;
+    category: string;
+    gone_at: string;
+}

package/dist/api/sidriveiq.interface.js

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

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

@@ -0,0 +1,97 @@
+import FormData from 'form-data';
+import { HttpClient } from './http.service';
+import { Asset, AssetsParams, File, FilesParams, FilesCountParams, List, Log, LogsParams, LogDto, Mail, Property, PropertiesParams, RangeParams, Subset, TimeSeries, TimeSeriesParams } from './sidriveiq.interface';
+export declare class SiDriveIqService {
+    private readonly httpClient;
+    private basePath;
+    constructor(httpClient: HttpClient);
+    /**
+     * @deprecated
+     */
+    getAssets(params?: AssetsParams): Promise<List<Asset>>;
+    /**
+     * @deprecated
+     */
+    getAssetCount(params?: AssetsParams): Promise<number>;
+    /**
+     * @deprecated
+     */
+    getAsset(assetId: string | number): Promise<Asset>;
+    /**
+     * @deprecated
+     */
+    getProperties(assetId: string | number, params?: PropertiesParams): Promise<List<Property>>;
+    /**
+     * @deprecated
+     */
+    getProperty(assetId: string | number, path: string): Promise<Property>;
+    /**
+     * @deprecated
+     */
+    getSubsets(assetId: string | number): Promise<List<TimeSeries>>;
+    /**
+     * @deprecated
+     */
+    getSubset(assetId: string | number, subsetId: string): Promise<Subset>;
+    /**
+     * @deprecated
+     */
+    getSubsetProperties(assetId: string | number, subsetId: string, pathFilter?: string): Promise<List<Property>>;
+    /**
+     * @deprecated
+     */
+    getTimeSeries(assetId: string | number, path: string, params?: TimeSeriesParams): Promise<List<TimeSeries>>;
+    /**
+     * @deprecated
+     */
+    getTimeSeriesCount(assetId: string | number, path: string, params?: RangeParams): Promise<number>;
+    /**
+     * @deprecated
+     */
+    getRecentTimeSeries(assetId: string | number, path: string, timestamp?: Date): Promise<TimeSeries>;
+    /**
+     * @deprecated
+     */
+    addTimeSeries(assetId: string | number, path: string, values: TimeSeries[]): Promise<void>;
+    /**
+     * @deprecated
+     */
+    getFiles(assetId: string | number, params?: FilesParams): Promise<File[]>;
+    /**
+     * @deprecated
+     */
+    getFileCount(assetId: string | number, params?: FilesCountParams): Promise<number>;
+    /**
+     * @deprecated
+     */
+    getFile(assetId: string | number, fileId: string): Promise<File>;
+    /**
+     * @deprecated
+     */
+    downloadFile(assetId: string | number, fileId: string): Promise<ArrayBuffer>;
+    /**
+     * @deprecated
+     */
+    uploadFile(assetId: string | number, form: FormData): Promise<string>;
+    /**
+     * @deprecated
+     */
+    deleteFile(assetId: string | number, fileId: string): Promise<void>;
+    /**
+     * @deprecated
+     */
+    getLogs(assetId: string | number, params: LogsParams): Promise<List<Log>>;
+    /**
+     * @deprecated
+     */
+    getLogCount(assetId: string | number, params: LogsParams): Promise<number>;
+    /**
+     * @deprecated
+     */
+    addLog(assetId: string | number, item: LogDto): Promise<void>;
+    /**
+     * @deprecated
+     */
+    sendMail(mail: Mail): Promise<string>;
+    private convertDates;
+}