@hahnpro/hpc-api 6.0.0 → 2024.4.0-1

package/src/lib/mock/flow-deployment.mock.service.js

@@ -0,0 +1,118 @@
+import { __decorate } from "tslib";
+import { randomUUID } from 'crypto';
+import { mix } from 'ts-mixer';
+import { APIBaseMock } from './api-base.mock';
+import { DataMockService } from './data.mock.service';
+import { TrashMockService } from './trash.mock.service';
+let BaseService = class BaseService extends APIBaseMock {
+};
+BaseService = __decorate([
+    mix(DataMockService, TrashMockService)
+], BaseService);
+export class FlowDeploymentMockService extends BaseService {
+    constructor(deployments, api) {
+        super(deployments);
+        this.api = api;
+    }
+    subscribeToStatus(id, listener, errorListener) {
+        listener(new MessageEvent('message', { data: 'running' }));
+        return Promise.resolve(randomUUID());
+    }
+    subscribeToLogs(id, listener, errorListener) {
+        listener(new MessageEvent('message', { data: 'foo' }));
+        return Promise.resolve(randomUUID());
+    }
+    async waitForRunningStatus(id) {
+        const flowDeployment = this.data.find((v) => v.id === id);
+        flowDeployment.actualStatus = 'running';
+    }
+    async updateStatus(id, desiredStatus) {
+        const deployment = await this.getOne(id);
+        deployment.desiredStatus = desiredStatus;
+        deployment.actualStatus = desiredStatus;
+        return Promise.resolve(deployment);
+    }
+    async resolveReferences(id, recursive, types) {
+        const depl = await this.getOne(id);
+        return depl.refs ?? [];
+    }
+    getDeploymentStatistics(id) {
+        return Promise.resolve({
+            totalErrorCount: 0,
+            errorCountWeek: 0,
+            eventCountWeek: 0,
+            errorCounts: [],
+            metrics: {
+                cpu: 0,
+                memory: 97931264,
+                ctime: 16770,
+                elapsed: 172850950,
+                timestamp: 1648199692625,
+                deploymentId: id,
+            },
+        });
+    }
+    getDeploymentMetrics(id, range, interval) {
+        return Promise.resolve({
+            metrics: [{ timestamp: Date.now(), cpu: 0, memory: Math.random() * 1000000 }],
+            stats: {
+                cpu: { count: 123, avg: 0, max: 0, min: 0, sum: 0 },
+                memory: { count: 123, avg: 0, max: 0, min: 0, sum: 0 },
+            },
+        });
+    }
+    async getDeploymentLogs(id) {
+        const depl = await this.getOne(id);
+        return Promise.resolve([
+            {
+                type: 'flow.log.info',
+                deploymentId: id,
+                subject: 'FlowApplication',
+                data: 'Flow Deployment is running',
+                '@timestamp': '2022-03-23T09:14:03.129Z',
+                eventId: 'c68b7674-b8da-46c5-85f0-8e4279d74a78',
+                datacontenttype: 'text/plain',
+                elementId: 'none',
+                time: '2022-03-23T09:14:03.129Z',
+                flowId: depl.flow,
+            },
+        ]);
+    }
+    async addOne(dto) {
+        const flow = await this.api.flows.getFlowWithDiagram(dto.diagramId);
+        const refs = await this.getReferences(dto.properties);
+        const id = randomUUID();
+        const newDepl = {
+            actualStatus: 'generating queued',
+            artifact: undefined,
+            desiredStatus: 'running',
+            diagram: dto.diagramId,
+            flow: flow.id,
+            flowModel: { elements: [], connections: [], properties: dto.properties },
+            id,
+            name: dto.name,
+            readPermissions: [],
+            readWritePermissions: [],
+            target: 'executor',
+            refs,
+        };
+        await this.api.flows.updateOne(flow.id, { ...flow, deployments: [...flow.deployments, id] });
+        return super.addOne(newDepl);
+    }
+    async deleteOne(id) {
+        const depl = await this.getOne(id);
+        const flow = await this.api.flows.getOne(depl.flow);
+        const index = flow.deployments.findIndex((v) => v === id);
+        flow.deployments.splice(index, 1);
+        await this.api.flows.updateOne(flow.id, flow);
+        return super.deleteOne(id);
+    }
+    async getReferences(properties) {
+        // super simplified version of real resolver
+        return Promise.all(Object.keys(properties).map(async (prop) => {
+            if (prop !== 'assetId')
+                throw new Error('not implemented');
+            return { id: (await this.api.assets.getOne(properties[prop])).id, resourceType: 'asset' };
+        }));
+    }
+}

package/{dist → src/lib}/mock/flow-functions.mock.service.js

@@ -1,18 +1,14 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FlowFunctionsMockService = void 0;
-const tslib_1 = require("tslib");
-const crypto_1 = require("crypto");
-const data_mock_service_1 = require("./data.mock.service");
-class FlowFunctionsMockService extends data_mock_service_1.DataMockService {
+import { randomUUID } from 'crypto';
+import { DataMockService } from './data.mock.service';
+export class FlowFunctionsMockService extends DataMockService {
     constructor(functions, revisions) {
         super();
         this.revisions = revisions;
         this.data = functions;
     }
     addOne(dto) {
-        const id = (0, crypto_1.randomUUID)();
-        this.revisions.push(Object.assign(Object.assign({}, dto), { id, originalId: dto.fqn }));
+        const id = randomUUID();
+        this.revisions.push({ ...dto, id, originalId: dto.fqn });
         return super.addOne(dto);
     }
     deleteOne(fqn) {
@@ -26,22 +22,18 @@ class FlowFunctionsMockService extends data_mock_service_1.DataMockService {
         });
         return Promise.resolve(undefined);
     }
-    updateOne(fqn, dto) {
-        return tslib_1.__awaiter(this, void 0, void 0, function* () {
-            const index = this.data.findIndex((v) => v.fqn === fqn);
-            this.data.splice(index, 1);
-            const flowFunction = yield this.addOne(dto);
-            return Promise.resolve(flowFunction);
-        });
+    async updateOne(fqn, dto) {
+        const index = this.data.findIndex((v) => v.fqn === fqn);
+        this.data.splice(index, 1);
+        const flowFunction = await this.addOne(dto);
+        return Promise.resolve(flowFunction);
     }
     getOne(fqn, options) {
         const t = this.data.find((v) => v.fqn === fqn);
         return Promise.resolve(t);
     }
-    getOneById(id) {
-        return tslib_1.__awaiter(this, void 0, void 0, function* () {
-            return this.data.find((v) => v.id === id);
-        });
+    async getOneById(id) {
+        return this.data.find((v) => v.id === id);
     }
     getRevisions(fqn) {
         const revisions = this.revisions.filter((revision) => revision.originalId === fqn);
@@ -62,4 +54,3 @@ class FlowFunctionsMockService extends data_mock_service_1.DataMockService {
         return Promise.resolve(revisionId);
     }
 }
-exports.FlowFunctionsMockService = FlowFunctionsMockService;

package/src/lib/mock/flow-modules.mock.service.js

@@ -0,0 +1,20 @@
+import { DataMockService } from './data.mock.service';
+export class FlowModulesMockService extends DataMockService {
+    constructor(modules) {
+        super();
+        this.data = modules;
+    }
+    async deleteArtifact(name, version) {
+        const module = await this.getOne(name);
+        const index = module.artifacts.findIndex((art) => art.version === version);
+        module.artifacts.splice(index, 1);
+        return Promise.resolve(module);
+    }
+    publish(form) {
+        return Promise.resolve(undefined);
+    }
+    getOne(name, options = {}) {
+        const t = this.data.find((v) => v.name === name);
+        return Promise.resolve(t);
+    }
+}

package/src/lib/mock/flow.mock.service.js

@@ -0,0 +1,81 @@
+import { __decorate } from "tslib";
+import { randomUUID } from 'crypto';
+import { mix } from 'ts-mixer';
+import { APIBaseMock } from './api-base.mock';
+import { DataMockService } from './data.mock.service';
+import { TrashMockService } from './trash.mock.service';
+let BaseService = class BaseService extends APIBaseMock {
+};
+BaseService = __decorate([
+    mix(DataMockService, TrashMockService)
+], BaseService);
+export class FlowMockService extends BaseService {
+    constructor(flows, diagrams, revisions) {
+        super(flows);
+        this.diagrams = diagrams;
+        this.revisions = revisions;
+    }
+    deleteOne(id, force = false) {
+        const flow = this.data.find((v) => v.id === id);
+        if (!flow?.deletedAt && !force) {
+            // put flow in paper bin by setting deletedAt prop
+            flow.deletedAt = new Date().toISOString();
+            return Promise.resolve(flow);
+        }
+        this.revisions
+            .filter((revision) => revision.originalId === id)
+            .forEach((revision) => {
+            const index = this.revisions.indexOf(revision);
+            this.revisions.splice(index, 1);
+        });
+        return super.deleteOne(id);
+    }
+    addOne(dto) {
+        const id = randomUUID();
+        this.revisions.push({ ...dto, id, originalId: dto.id });
+        return super.addOne(dto);
+    }
+    async updateOne(id, dto) {
+        await super.deleteOne(id);
+        const flow = await this.addOne(dto);
+        return Promise.resolve(flow);
+    }
+    async isDeploymentOnLatestDiagramVersion(depl) {
+        const flowId = typeof depl.flow === 'string' ? depl.flow : depl.flow.id;
+        const diagramId = typeof depl.diagram === 'string' ? depl.diagram : depl.diagram.id;
+        const revisions = await this.getDiagramRevisions(flowId);
+        return revisions[revisions.length - 1].id === diagramId;
+    }
+    getDiagramRevisions(id) {
+        return Promise.resolve(this.diagrams.filter((v) => v.flow === id));
+    }
+    getFlowWithDiagram(diagramId) {
+        return Promise.resolve(this.data.find((v1) => v1.id === this.diagrams.find((v) => v.id === diagramId).flow));
+    }
+    async getMany(params) {
+        const flows = this.getItems(params, false);
+        return {
+            docs: flows.docs.map((v) => ({ ...v, diagram: this.diagrams.find((v1) => v1.id === v.diagram) })),
+            total: 0,
+            limit: 0,
+        };
+    }
+    getRevisions(id) {
+        const revisions = this.revisions.filter((revision) => revision.originalId === id);
+        const page = {
+            docs: revisions,
+            limit: Number.MAX_SAFE_INTEGER,
+            total: revisions.length,
+        };
+        return Promise.resolve(page);
+    }
+    rollback(id, revisionId) {
+        const flow = this.revisions.find((revision) => revision.id === revisionId);
+        return Promise.resolve(flow);
+    }
+    deleteRevision(id, revisionId) {
+        const index = this.revisions.findIndex((revision) => revision.id === revisionId);
+        this.revisions.splice(index, 1);
+        return Promise.resolve(revisionId);
+    }
+}

package/src/lib/mock/index.js

@@ -0,0 +1,11 @@
+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';
+export * from './vault.mock.service';
+export * from './notification.mock.service';

package/src/lib/mock/label.mock.service.js

@@ -0,0 +1,13 @@
+import { DataMockService } from './data.mock.service';
+export class LabelMockService extends DataMockService {
+    constructor(labels) {
+        super();
+        this.data = labels;
+    }
+    count() {
+        return Promise.resolve(this.data.length);
+    }
+    getOneByName(name) {
+        return Promise.resolve(this.data.find((label) => label.name === name));
+    }
+}

package/src/lib/mock/notification.mock.service.js

@@ -0,0 +1,7 @@
+import { DataMockService } from './data.mock.service';
+export class NotificationMockService extends DataMockService {
+    constructor(notifications) {
+        super();
+        this.data = notifications;
+    }
+}

package/src/lib/mock/secret.mock.service.js

@@ -0,0 +1,28 @@
+import { __decorate } from "tslib";
+import { mix } from 'ts-mixer';
+import { APIBaseMock } from './api-base.mock';
+import { DataMockService } from './data.mock.service';
+import { TrashMockService } from './trash.mock.service';
+let BaseService = class BaseService extends APIBaseMock {
+};
+BaseService = __decorate([
+    mix(DataMockService, TrashMockService)
+], BaseService);
+export class SecretMockService extends BaseService {
+    constructor(secrets) {
+        super(secrets);
+    }
+    deleteOne(contentId, force = false) {
+        const content = this.data.find((v) => v.id === contentId);
+        if (!content?.deletedAt && !force) {
+            // put content in paper bin by setting deletedAt prop
+            content.deletedAt = new Date().toISOString();
+            return Promise.resolve(content);
+        }
+        return super.deleteOne(contentId);
+    }
+    getMany(params) {
+        const page = this.getItems(params, false);
+        return Promise.resolve(page);
+    }
+}

package/src/lib/mock/task.mock.service.js

@@ -0,0 +1,32 @@
+import { __decorate } from "tslib";
+import { mix } from 'ts-mixer';
+import { APIBaseMock } from './api-base.mock';
+import { DataMockService } from './data.mock.service';
+import { TrashMockService } from './trash.mock.service';
+let BaseService = class BaseService extends APIBaseMock {
+};
+BaseService = __decorate([
+    mix(DataMockService, TrashMockService)
+], BaseService);
+export class TaskMockService extends BaseService {
+    constructor(tasks) {
+        super(tasks);
+    }
+    async createTaskAttachedToAsset(dto) {
+        this.data.push(dto);
+        return Promise.resolve(dto);
+    }
+    deleteOne(taskId, force = false) {
+        const task = this.data.find((v) => v.id === taskId);
+        if (!task?.deletedAt && !force) {
+            // put content in paper bin by setting deletedAt prop
+            task.deletedAt = new Date().toISOString();
+            return Promise.resolve(task);
+        }
+        return super.deleteOne(taskId);
+    }
+    getMany(params) {
+        const page = this.getItems(params, false);
+        return Promise.resolve(page);
+    }
+}

package/{dist → src/lib}/mock/timeseries.mock.service.js

@@ -1,24 +1,22 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TimeseriesMockService = void 0;
-const tslib_1 = require("tslib");
-const ts_mixer_1 = require("ts-mixer");
-const api_base_mock_1 = require("./api-base.mock");
-const data_mock_service_1 = require("./data.mock.service");
-const trash_mock_service_1 = require("./trash.mock.service");
-let BaseService = class BaseService extends api_base_mock_1.APIBaseMock {
+import { __decorate } from "tslib";
+import { mix } from 'ts-mixer';
+import { APIBaseMock } from './api-base.mock';
+import { DataMockService } from './data.mock.service';
+import { TrashMockService } from './trash.mock.service';
+let BaseService = class BaseService extends APIBaseMock {
 };
-BaseService = tslib_1.__decorate([
-    (0, ts_mixer_1.mix)(data_mock_service_1.DataMockService, trash_mock_service_1.TrashMockService)
+BaseService = __decorate([
+    mix(DataMockService, TrashMockService)
 ], BaseService);
-class TimeseriesMockService extends BaseService {
+export class TimeseriesMockService extends BaseService {
     constructor(timeseries, timeseriesValues) {
-        const data = timeseries.map((value, index) => (Object.assign(Object.assign({}, value), { data: timeseriesValues[index] })));
+        const data = timeseries.map((value, index) => ({ ...value, data: timeseriesValues[index] }));
         super(data);
     }
     deleteOne(tsmId, force = false) {
         const tsm = this.data.find((v) => v.id === tsmId);
-        if (!(tsm === null || tsm === void 0 ? void 0 : tsm.deletedAt) && !force) {
+        if (!tsm?.deletedAt && !force) {
+            // put tsm in paper bin by setting deletedAt prop
             tsm.deletedAt = new Date().toISOString();
             return Promise.resolve(tsm);
         }
@@ -32,7 +30,7 @@ class TimeseriesMockService extends BaseService {
         const ts = this.data.find((v) => v.assetRef === assetId);
         const data = Object.entries(values).map(([timestamp, value]) => {
             if (value !== null && typeof value === 'object') {
-                return Object.assign({ timestamp }, value);
+                return { timestamp, ...value };
             }
             else {
                 return { timestamp, value };
@@ -63,7 +61,7 @@ class TimeseriesMockService extends BaseService {
         for (const [tsName, values] of Object.entries(timeSeries)) {
             const data = Object.entries(values).map(([timestamp, value]) => {
                 if (value !== null && typeof value === 'object') {
-                    return Object.assign({ timestamp }, value);
+                    return { timestamp, ...value };
                 }
                 else {
                     return { timestamp, value };
@@ -92,20 +90,19 @@ class TimeseriesMockService extends BaseService {
         }
         return Promise.resolve(psr);
     }
-    addValue(id, value) {
-        return tslib_1.__awaiter(this, void 0, void 0, function* () {
-            const ts = yield this.getOne(id, {});
-            for (const [timestamp, v] of Object.entries(value)) {
-                if (v !== null && typeof v === 'object') {
-                    ts.data.push(Object.assign({ timestamp }, v));
-                }
-                else {
-                    ts.data.push({ timestamp: parseInt(timestamp, 10), value: v });
-                }
+    async addValue(id, value) {
+        const ts = await this.getOne(id, {});
+        for (const [timestamp, v] of Object.entries(value)) {
+            if (v !== null && typeof v === 'object') {
+                ts.data.push({ timestamp, ...v });
             }
-        });
+            else {
+                ts.data.push({ timestamp: parseInt(timestamp, 10), value: v });
+            }
+        }
     }
     getManyByAsset(assetId, names) {
+        // get timeseries where assetRef is assetId
         const page = { docs: [], limit: 10, total: 0 };
         for (const datum of this.data) {
             if (datum.assetRef === assetId) {
@@ -118,30 +115,24 @@ class TimeseriesMockService extends BaseService {
         page.total = page.docs.length;
         return Promise.resolve(page);
     }
-    getMostRecentValue(id, before) {
-        return tslib_1.__awaiter(this, void 0, void 0, function* () {
-            const ts = yield this.getOne(id, {});
-            for (const datum of ts.data) {
-                if (datum.timestamp < before.valueOf()) {
-                    return datum;
-                }
+    async getMostRecentValue(id, before) {
+        const ts = await this.getOne(id, {});
+        for (const datum of ts.data) {
+            if (datum.timestamp < before.valueOf()) {
+                return datum;
             }
-        });
+        }
+        return null;
     }
-    getValues(id, from, limit, group) {
-        return tslib_1.__awaiter(this, void 0, void 0, function* () {
-            let timeSeriesValues = yield this.getValuesOfPeriod(id, from, new Date().valueOf(), group);
-            if (limit) {
-                timeSeriesValues = timeSeriesValues.slice(0, limit);
-            }
-            return timeSeriesValues;
-        });
+    async getValues(id, from, limit, group) {
+        let timeSeriesValues = await this.getValuesOfPeriod(id, from, new Date().valueOf(), group);
+        if (limit) {
+            timeSeriesValues = timeSeriesValues.slice(0, limit);
+        }
+        return timeSeriesValues;
     }
-    getValuesOfPeriod(id, from, to, group) {
-        return tslib_1.__awaiter(this, void 0, void 0, function* () {
-            const ts = yield this.getOne(id, {});
-            return ts.data.filter((v) => v.timestamp < to && v.timestamp > from);
-        });
+    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 → src/lib}/mock/trash.mock.service.js

@@ -1,9 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TrashMockService = void 0;
-const tslib_1 = require("tslib");
-const trash_service_1 = require("../trash.service");
-class TrashMockService extends trash_service_1.TrashService {
+import { TrashService } from '../trash.service';
+export class TrashMockService extends TrashService {
     constructor() {
         super(null, null);
         this.data = [];
@@ -20,14 +16,12 @@ class TrashMockService extends trash_service_1.TrashService {
         delete deleted['deletedAt'];
         return Promise.resolve(deleted);
     }
-    emptyTrash(offset) {
-        return tslib_1.__awaiter(this, void 0, void 0, function* () {
-            const dateOffsSeconds = Math.round(new Date().getTime() / 1000) - offset;
-            const date = new Date(dateOffsSeconds * 1000);
-            const trashIds = this.data.filter((v) => new Date(v['deletedAt']) < date).map((v) => v.id);
-            this.data = this.data.filter((item) => !trashIds.includes(item.id));
-            return Promise.resolve({ acknowledged: true, deletedCount: trashIds.length });
-        });
+    async emptyTrash(offset) {
+        const dateOffsSeconds = Math.round(new Date().getTime() / 1000) - offset;
+        const date = new Date(dateOffsSeconds * 1000);
+        const trashIds = this.data.filter((v) => new Date(v['deletedAt']) < date).map((v) => v.id);
+        this.data = this.data.filter((item) => !trashIds.includes(item.id));
+        return Promise.resolve({ acknowledged: true, deletedCount: trashIds.length });
     }
     getTrash(params) {
         const page = this.getItems(params, true);
@@ -43,4 +37,3 @@ class TrashMockService extends trash_service_1.TrashService {
         return page;
     }
 }
-exports.TrashMockService = TrashMockService;

package/src/lib/mock/user.mock.service.js

@@ -0,0 +1,10 @@
+import { UserService } from '../user.service';
+export class UserMockService extends UserService {
+    constructor(users) {
+        super(null);
+        this.users = users;
+    }
+    getCurrentUserRoles() {
+        return Promise.resolve(this.users.roles);
+    }
+}

package/{dist → src/lib}/mock/vault.mock.service.js

@@ -1,8 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.VaultMockService = void 0;
-const data_mock_service_1 = require("./data.mock.service");
-class VaultMockService extends data_mock_service_1.DataMockService {
+import { DataMockService } from './data.mock.service';
+export class VaultMockService extends DataMockService {
     constructor(secrets) {
         super();
         this.data = secrets;
@@ -15,4 +12,3 @@ class VaultMockService extends data_mock_service_1.DataMockService {
         return Promise.resolve(vaultSecret.secret);
     }
 }
-exports.VaultMockService = VaultMockService;

package/src/lib/notification.interface.js

@@ -0,0 +1 @@
+export {};

package/src/lib/notification.service.js

@@ -0,0 +1,6 @@
+import { DataService } from './data.service';
+export class NotificationService extends DataService {
+    constructor(httpClient) {
+        super(httpClient, '/notifications');
+    }
+}

package/{dist → src/lib}/proxy.service.js

@@ -1,7 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ProxyService = void 0;
-class ProxyService {
+export class ProxyService {
     constructor(httpClient) {
         this.httpClient = httpClient;
         this.delete = (proxyId, path, config) => this.httpClient.delete(this.url(proxyId, path), config);
@@ -14,4 +11,3 @@ class ProxyService {
         return `/proxy/${proxyId}${path}`;
     }
 }
-exports.ProxyService = ProxyService;

package/src/lib/resource.interface.js

@@ -0,0 +1 @@
+export {};

package/src/lib/schema.interface.js

@@ -0,0 +1 @@
+export {};

package/src/lib/secret.interface.js

@@ -0,0 +1 @@
+export {};

package/src/lib/secret.service.js

@@ -0,0 +1,15 @@
+import { __decorate } from "tslib";
+import { mix } from 'ts-mixer';
+import { APIBase } from './api-base';
+import { DataService } from './data.service';
+import { TrashService } from './trash.service';
+let BaseService = class BaseService extends APIBase {
+};
+BaseService = __decorate([
+    mix(DataService, TrashService)
+], BaseService);
+export class SecretService extends BaseService {
+    constructor(httpClient) {
+        super(httpClient, '/secrets');
+    }
+}

package/src/lib/storage.interface.js

@@ -0,0 +1 @@
+export {};

package/src/lib/task.interface.js

@@ -0,0 +1 @@
+export {};

package/src/lib/task.service.js

@@ -0,0 +1,19 @@
+import { __decorate } from "tslib";
+import { mix } from 'ts-mixer';
+import { APIBase } from './api-base';
+import { DataService } from './data.service';
+import { TrashService } from './trash.service';
+let BaseService = class BaseService extends APIBase {
+};
+BaseService = __decorate([
+    mix(DataService, TrashService)
+], BaseService);
+export class TaskService extends BaseService {
+    constructor(httpClient) {
+        super(httpClient, '/tasks');
+    }
+    // we may not need this method (already have the addOne method from DataService)
+    createTaskAttachedToAsset(dto, options = {}) {
+        return this.httpClient.post(this.basePath, dto, options);
+    }
+}