@vived/host 3.0.0

package/lib/Components/VivedAPI/UCs/GetAssetsForOwnerFromAPIUC.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeGetAssetsForOwnerFromAPIUC = exports.GetAssetsForOwnerFromAPIUC = void 0;
+const HostAppObject_1 = require("../../../HostAppObject");
+const VivedAPIEntity_1 = require("../Entities/VivedAPIEntity");
+const JsonRequestUC_1 = require("./JsonRequestUC");
+const SignedAuthTokenUC_1 = require("./SignedAuthTokenUC");
+class GetAssetsForOwnerFromAPIUC extends HostAppObject_1.HostAppObjectUC {
+    static get(appObjects) {
+        return HostAppObject_1.getSingletonComponent(GetAssetsForOwnerFromAPIUC.type, appObjects);
+    }
+}
+exports.GetAssetsForOwnerFromAPIUC = GetAssetsForOwnerFromAPIUC;
+GetAssetsForOwnerFromAPIUC.type = 'GetAssetsForOwnerFromAPIUC';
+function makeGetAssetsForOwnerFromAPIUC(appObject) {
+    return new GetAssetsForOwnerUCImp(appObject);
+}
+exports.makeGetAssetsForOwnerFromAPIUC = makeGetAssetsForOwnerFromAPIUC;
+class GetAssetsForOwnerUCImp extends GetAssetsForOwnerFromAPIUC {
+    constructor(appObject) {
+        super(appObject, GetAssetsForOwnerFromAPIUC.type);
+        this.getAssets = (ownerID) => {
+            const getAuthToken = this.getAuthToken;
+            const vivedAPI = this.vivedAPI;
+            const jsonRequester = this.jsonRequester;
+            if (!getAuthToken || !vivedAPI || !jsonRequester) {
+                return Promise.reject();
+            }
+            return new Promise((resolve, reject) => {
+                getAuthToken()
+                    .then((token) => {
+                    const url = vivedAPI.getEndpointURL(`assets/group/${ownerID}`);
+                    const page = 1;
+                    const itemsPerPage = 100;
+                    url.searchParams.append('page', page.toString());
+                    url.searchParams.append('itemsPerPage', itemsPerPage.toString());
+                    const options = {
+                        method: 'GET',
+                    };
+                    return jsonRequester(url, options);
+                })
+                    .then((resp) => {
+                    const ownerAssets = resp.assets.map((asset) => {
+                        return this.responseToDTO(asset);
+                    });
+                    resolve(ownerAssets);
+                })
+                    .catch((e) => {
+                    reject(e);
+                    return;
+                });
+            });
+        };
+        this.appObjects.registerSingleton(this);
+    }
+    get jsonRequester() {
+        var _a;
+        return (_a = this.getCachedSingleton(JsonRequestUC_1.JsonRequestUC.type)) === null || _a === void 0 ? void 0 : _a.doRequest;
+    }
+    get getAuthToken() {
+        var _a;
+        return (_a = this.getCachedSingleton(SignedAuthTokenUC_1.SignedAuthTokenUC.type)) === null || _a === void 0 ? void 0 : _a.getUserAuthToken;
+    }
+    get vivedAPI() {
+        return this.getCachedSingleton(VivedAPIEntity_1.VivedAPIEntity.type);
+    }
+    responseToDTO(resp) {
+        const linkedAssets = resp.linkedAssets.map((linkedAssetResp) => {
+            return {
+                type: linkedAssetResp.type,
+                asset: this.responseToDTO(linkedAssetResp.asset),
+            };
+        });
+        const dto = {
+            archived: resp.archived,
+            description: resp.description,
+            fileURL: resp.fileURL,
+            filename: resp.filename,
+            id: resp.id,
+            name: resp.name,
+            linkedAssets,
+            ownerId: resp.ownerId,
+        };
+        return dto;
+    }
+}

package/lib/Components/VivedAPI/UCs/GetAssetsForOwnerUC.d.ts

@@ -0,0 +1,20 @@
+import { HostAppObject, HostAppObjectRepo, HostAppObjectUC } from "../../../HostAppObject";
+export interface OwnerAssetDTO {
+    id: string;
+    ownerId: string;
+    name: string;
+    description: string;
+    archived: boolean;
+    filename: string;
+    fileURL: string;
+    linkedAssets: {
+        type: string;
+        asset: OwnerAssetDTO;
+    }[];
+}
+export declare abstract class GetAssetsForOwnerUC extends HostAppObjectUC {
+    static type: string;
+    abstract getAssets(ownerID: string): Promise<OwnerAssetDTO[]>;
+    static get(appObjects: HostAppObjectRepo): GetAssetsForOwnerUC | undefined;
+}
+export declare function makeGetAssetsForOwnerUC(appObject: HostAppObject): GetAssetsForOwnerUC;

package/lib/Components/VivedAPI/UCs/GetAssetsForOwnerUC.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeGetAssetsForOwnerUC = exports.GetAssetsForOwnerUC = void 0;
+const HostAppObject_1 = require("../../../HostAppObject");
+const VivedAPIEntity_1 = require("../Entities/VivedAPIEntity");
+const JsonRequestUC_1 = require("./JsonRequestUC");
+const SignedAuthTokenUC_1 = require("./SignedAuthTokenUC");
+class GetAssetsForOwnerUC extends HostAppObject_1.HostAppObjectUC {
+    static get(appObjects) {
+        return HostAppObject_1.getSingletonComponent(GetAssetsForOwnerUC.type, appObjects);
+    }
+}
+exports.GetAssetsForOwnerUC = GetAssetsForOwnerUC;
+GetAssetsForOwnerUC.type = "GetAssetsForOwnerUC";
+function makeGetAssetsForOwnerUC(appObject) {
+    return new GetAssetsForOwnerUCImp(appObject);
+}
+exports.makeGetAssetsForOwnerUC = makeGetAssetsForOwnerUC;
+class GetAssetsForOwnerUCImp extends GetAssetsForOwnerUC {
+    constructor(appObject) {
+        super(appObject, GetAssetsForOwnerUC.type);
+        this.getAssets = (ownerID) => {
+            const getAuthToken = this.getAuthToken;
+            const vivedAPI = this.vivedAPI;
+            const jsonRequester = this.jsonRequester;
+            if (!getAuthToken || !vivedAPI || !jsonRequester) {
+                return Promise.reject();
+            }
+            return new Promise((resolve, reject) => {
+                getAuthToken()
+                    .then((token) => {
+                    const url = vivedAPI.getEndpointURL(`assets/group/${ownerID}`);
+                    const page = 1;
+                    const itemsPerPage = 100;
+                    url.searchParams.append("page", page.toString());
+                    url.searchParams.append("itemsPerPage", itemsPerPage.toString());
+                    const options = {
+                        method: "GET"
+                    };
+                    return jsonRequester(url, options);
+                })
+                    .then((resp) => {
+                    const ownerAssets = resp.assets.map((asset) => {
+                        return this.responseToDTO(asset);
+                    });
+                    resolve(ownerAssets);
+                })
+                    .catch((e) => {
+                    reject(e);
+                    return;
+                });
+            });
+        };
+        this.appObjects.registerSingleton(this);
+    }
+    get jsonRequester() {
+        var _a;
+        return (_a = this.getCachedSingleton(JsonRequestUC_1.JsonRequestUC.type)) === null || _a === void 0 ? void 0 : _a.doRequest;
+    }
+    get getAuthToken() {
+        var _a;
+        return (_a = this.getCachedSingleton(SignedAuthTokenUC_1.SignedAuthTokenUC.type)) === null || _a === void 0 ? void 0 : _a.getUserAuthToken;
+    }
+    get vivedAPI() {
+        return this.getCachedSingleton(VivedAPIEntity_1.VivedAPIEntity.type);
+    }
+    responseToDTO(resp) {
+        const linkedAssets = resp.linkedAssets.map((linkedAssetResp) => {
+            return {
+                type: linkedAssetResp.type,
+                asset: this.responseToDTO(linkedAssetResp.asset)
+            };
+        });
+        const dto = {
+            archived: resp.archived,
+            description: resp.description,
+            fileURL: resp.fileURL,
+            filename: resp.filename,
+            id: resp.id,
+            name: resp.name,
+            linkedAssets,
+            ownerId: resp.ownerId
+        };
+        return dto;
+    }
+}

package/lib/Components/VivedAPI/UCs/JsonRequestUC.d.ts

@@ -0,0 +1,13 @@
+import { HostAppObject, HostAppObjectRepo, HostAppObjectUC } from "../../../HostAppObject";
+export interface RequestJSONOptions {
+    headers?: any;
+    method: "GET" | "PATCH" | "POST" | "PUT" | "DELETE" | undefined;
+    params?: any;
+    body?: any;
+}
+export declare abstract class JsonRequestUC extends HostAppObjectUC {
+    static type: string;
+    abstract doRequest(url: URL, options?: RequestJSONOptions): Promise<any>;
+    static get(appObjects: HostAppObjectRepo): JsonRequestUC | undefined;
+}
+export declare function makeJsonRequestUC(appObject: HostAppObject): JsonRequestUC;

package/lib/Components/VivedAPI/UCs/JsonRequestUC.js

@@ -0,0 +1,49 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeJsonRequestUC = exports.JsonRequestUC = void 0;
+const HostAppObject_1 = require("../../../HostAppObject");
+class JsonRequestUC extends HostAppObject_1.HostAppObjectUC {
+    static get(appObjects) {
+        return HostAppObject_1.getSingletonComponent(JsonRequestUC.type, appObjects);
+    }
+}
+exports.JsonRequestUC = JsonRequestUC;
+JsonRequestUC.type = "JsonRequestUC";
+function makeJsonRequestUC(appObject) {
+    return new JsonRequestUCImp(appObject);
+}
+exports.makeJsonRequestUC = makeJsonRequestUC;
+class JsonRequestUCImp extends JsonRequestUC {
+    constructor(appObject) {
+        super(appObject, JsonRequestUC.type);
+        this.doRequest = (url, options) => {
+            return new Promise((resolve, reject) => {
+                fetch(url.href, options)
+                    .then((resp) => __awaiter(this, void 0, void 0, function* () {
+                    if (!resp.ok) {
+                        this.warn(`Response is not OK: ${resp}`);
+                        reject(new Error(`Response is not OK: ${resp}`));
+                    }
+                    return resp.json();
+                }))
+                    .then((json) => {
+                    resolve(json);
+                })
+                    .catch((e) => {
+                    this.warn(e.message);
+                    reject(e);
+                });
+            });
+        };
+        this.appObjects.registerSingleton(this);
+    }
+}

package/lib/Components/VivedAPI/UCs/PatchAssetFileUC.d.ts

@@ -0,0 +1,7 @@
+import { HostAppObject, HostAppObjectRepo, HostAppObjectUC } from "../../../HostAppObject";
+export declare abstract class PatchAssetFileUC extends HostAppObjectUC {
+    static type: string;
+    abstract doPatch(assetId: string, file: File): Promise<string>;
+    static get(appObjects: HostAppObjectRepo): PatchAssetFileUC | undefined;
+}
+export declare function makePatchAssetFileUC(appObject: HostAppObject): PatchAssetFileUC;

package/lib/Components/VivedAPI/UCs/PatchAssetFileUC.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makePatchAssetFileUC = exports.PatchAssetFileUC = void 0;
+const HostAppObject_1 = require("../../../HostAppObject");
+const Utilities_1 = require("../../../Utilities");
+const VivedAPIEntity_1 = require("../Entities/VivedAPIEntity");
+const FileUploadUC_1 = require("./FileUploadUC");
+const JsonRequestUC_1 = require("./JsonRequestUC");
+const SignedAuthTokenUC_1 = require("./SignedAuthTokenUC");
+class PatchAssetFileUC extends HostAppObject_1.HostAppObjectUC {
+    static get(appObjects) {
+        return HostAppObject_1.getSingletonComponent(PatchAssetFileUC.type, appObjects);
+    }
+}
+exports.PatchAssetFileUC = PatchAssetFileUC;
+PatchAssetFileUC.type = "PatchAssetFileUC";
+function makePatchAssetFileUC(appObject) {
+    return new PatchAssetFileUCImp(appObject);
+}
+exports.makePatchAssetFileUC = makePatchAssetFileUC;
+class PatchAssetFileUCImp extends PatchAssetFileUC {
+    constructor(appObject) {
+        super(appObject, PatchAssetFileUC.type);
+        this.doPatch = (assetId, file) => {
+            const getAuthToken = this.getAuthToken;
+            const vivedAPI = this.vivedAPI;
+            const jsonRequester = this.jsonRequester;
+            const fileUpload = this.fileUpload;
+            if (!getAuthToken || !vivedAPI || !jsonRequester || !fileUpload) {
+                return Promise.reject();
+            }
+            let extension = "";
+            const strArr = file.name.split(".");
+            extension = strArr[strArr.length - 1];
+            const filename = `${Utilities_1.generateUniqueID()}.${extension}`;
+            const assetFile = new File([file], `${filename}`, {
+                lastModified: Date.now()
+            });
+            return new Promise((resolve, reject) => {
+                fileUpload(assetFile)
+                    .then((_) => {
+                    return getAuthToken();
+                })
+                    .then((token) => {
+                    const url = vivedAPI.getEndpointURL(`assets/${assetId}`);
+                    const body = {
+                        filename
+                    };
+                    const options = {
+                        method: "PATCH",
+                        body: JSON.stringify(body),
+                        headers: {
+                            Authorization: "Bearer " + token
+                        }
+                    };
+                    return jsonRequester(url, options);
+                })
+                    .then((_) => {
+                    resolve(filename);
+                })
+                    .catch((e) => {
+                    reject(e);
+                    return;
+                });
+            });
+        };
+        this.appObjects.registerSingleton(this);
+    }
+    get jsonRequester() {
+        var _a;
+        return (_a = this.getCachedSingleton(JsonRequestUC_1.JsonRequestUC.type)) === null || _a === void 0 ? void 0 : _a.doRequest;
+    }
+    get getAuthToken() {
+        var _a;
+        return (_a = this.getCachedSingleton(SignedAuthTokenUC_1.SignedAuthTokenUC.type)) === null || _a === void 0 ? void 0 : _a.getUserAuthToken;
+    }
+    get fileUpload() {
+        var _a;
+        return (_a = this.getCachedSingleton(FileUploadUC_1.FileUploadUC.type)) === null || _a === void 0 ? void 0 : _a.doUpload;
+    }
+    get vivedAPI() {
+        return this.getCachedSingleton(VivedAPIEntity_1.VivedAPIEntity.type);
+    }
+}

package/lib/Components/VivedAPI/UCs/PatchAssetIsArchivedUC.d.ts

@@ -0,0 +1,7 @@
+import { HostAppObject, HostAppObjectRepo, HostAppObjectUC } from "../../../HostAppObject";
+export declare abstract class PatchAssetIsArchivedUC extends HostAppObjectUC {
+    static type: string;
+    abstract doPatch(assetID: string, isArchived: boolean): Promise<void>;
+    static get(appObjects: HostAppObjectRepo): PatchAssetIsArchivedUC | undefined;
+}
+export declare function makePatchAssetIsArchivedUC(appObject: HostAppObject): PatchAssetIsArchivedUC;

package/lib/Components/VivedAPI/UCs/PatchAssetIsArchivedUC.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makePatchAssetIsArchivedUC = exports.PatchAssetIsArchivedUC = void 0;
+const HostAppObject_1 = require("../../../HostAppObject");
+const VivedAPIEntity_1 = require("../Entities/VivedAPIEntity");
+const JsonRequestUC_1 = require("./JsonRequestUC");
+const SignedAuthTokenUC_1 = require("./SignedAuthTokenUC");
+class PatchAssetIsArchivedUC extends HostAppObject_1.HostAppObjectUC {
+    static get(appObjects) {
+        return HostAppObject_1.getSingletonComponent(PatchAssetIsArchivedUC.type, appObjects);
+    }
+}
+exports.PatchAssetIsArchivedUC = PatchAssetIsArchivedUC;
+PatchAssetIsArchivedUC.type = "PatchAssetIsArchivedUC";
+function makePatchAssetIsArchivedUC(appObject) {
+    return new PatchAssetIsArchivedUCImp(appObject);
+}
+exports.makePatchAssetIsArchivedUC = makePatchAssetIsArchivedUC;
+class PatchAssetIsArchivedUCImp extends PatchAssetIsArchivedUC {
+    constructor(appObject) {
+        super(appObject, PatchAssetIsArchivedUC.type);
+        this.doPatch = (assetID, isArchived) => {
+            const getAuthToken = this.getAuthToken;
+            const vivedAPI = this.vivedAPI;
+            const jsonRequester = this.jsonRequester;
+            if (!getAuthToken || !vivedAPI || !jsonRequester) {
+                return Promise.reject();
+            }
+            return new Promise((resolve, reject) => {
+                getAuthToken()
+                    .then((token) => {
+                    const postURL = vivedAPI.getEndpointURL(`assets/${assetID}`);
+                    const body = {
+                        archived: isArchived
+                    };
+                    const options = {
+                        method: "PATCH",
+                        body: JSON.stringify(body),
+                        headers: {
+                            Authorization: "Bearer " + token
+                        }
+                    };
+                    return jsonRequester(postURL, options);
+                })
+                    .then((_) => {
+                    resolve();
+                })
+                    .catch((e) => {
+                    reject(e);
+                    return;
+                });
+            });
+        };
+        this.appObjects.registerSingleton(this);
+    }
+    get jsonRequester() {
+        var _a;
+        return (_a = this.getCachedSingleton(JsonRequestUC_1.JsonRequestUC.type)) === null || _a === void 0 ? void 0 : _a.doRequest;
+    }
+    get getAuthToken() {
+        var _a;
+        return (_a = this.getCachedSingleton(SignedAuthTokenUC_1.SignedAuthTokenUC.type)) === null || _a === void 0 ? void 0 : _a.getUserAuthToken;
+    }
+    get vivedAPI() {
+        return this.getCachedSingleton(VivedAPIEntity_1.VivedAPIEntity.type);
+    }
+}

package/lib/Components/VivedAPI/UCs/PatchAssetMetaUC.d.ts

@@ -0,0 +1,13 @@
+import { HostAppObject, HostAppObjectRepo, HostAppObjectUC } from "../../../HostAppObject";
+export interface PatchAssetMetaDTO {
+    id: string;
+    name: string;
+    description: string;
+    archived: boolean;
+}
+export declare abstract class PatchAssetMetaUC extends HostAppObjectUC {
+    static type: string;
+    abstract doPatch(data: PatchAssetMetaDTO): Promise<void>;
+    static get(appObjects: HostAppObjectRepo): PatchAssetMetaUC | undefined;
+}
+export declare function makePatchAssetMetaUC(appObject: HostAppObject): PatchAssetMetaUC;

package/lib/Components/VivedAPI/UCs/PatchAssetMetaUC.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makePatchAssetMetaUC = exports.PatchAssetMetaUC = void 0;
+const HostAppObject_1 = require("../../../HostAppObject");
+const VivedAPIEntity_1 = require("../Entities/VivedAPIEntity");
+const JsonRequestUC_1 = require("./JsonRequestUC");
+const SignedAuthTokenUC_1 = require("./SignedAuthTokenUC");
+class PatchAssetMetaUC extends HostAppObject_1.HostAppObjectUC {
+    static get(appObjects) {
+        return HostAppObject_1.getSingletonComponent(PatchAssetMetaUC.type, appObjects);
+    }
+}
+exports.PatchAssetMetaUC = PatchAssetMetaUC;
+PatchAssetMetaUC.type = "PatchAssetMetaUC";
+function makePatchAssetMetaUC(appObject) {
+    return new PatchAssetMetaUCImp(appObject);
+}
+exports.makePatchAssetMetaUC = makePatchAssetMetaUC;
+class PatchAssetMetaUCImp extends PatchAssetMetaUC {
+    constructor(appObject) {
+        super(appObject, PatchAssetMetaUC.type);
+        this.doPatch = (data) => {
+            const getAuthToken = this.getAuthToken;
+            const vivedAPI = this.vivedAPI;
+            const jsonRequester = this.jsonRequester;
+            if (!getAuthToken || !vivedAPI || !jsonRequester) {
+                return Promise.reject();
+            }
+            const { id, name, description, archived } = data;
+            return new Promise((resolve, reject) => {
+                getAuthToken()
+                    .then((token) => {
+                    const postURL = vivedAPI.getEndpointURL(`assets/${id}`);
+                    const body = {
+                        name,
+                        description,
+                        archived
+                    };
+                    const options = {
+                        method: "PATCH",
+                        body: JSON.stringify(body),
+                        headers: {
+                            Authorization: "Bearer " + token
+                        }
+                    };
+                    return jsonRequester(postURL, options);
+                })
+                    .then((_) => {
+                    resolve();
+                })
+                    .catch((e) => {
+                    reject(e);
+                    return;
+                });
+            });
+        };
+        this.appObjects.registerSingleton(this);
+    }
+    get jsonRequester() {
+        var _a;
+        return (_a = this.getCachedSingleton(JsonRequestUC_1.JsonRequestUC.type)) === null || _a === void 0 ? void 0 : _a.doRequest;
+    }
+    get getAuthToken() {
+        var _a;
+        return (_a = this.getCachedSingleton(SignedAuthTokenUC_1.SignedAuthTokenUC.type)) === null || _a === void 0 ? void 0 : _a.getUserAuthToken;
+    }
+    get vivedAPI() {
+        return this.getCachedSingleton(VivedAPIEntity_1.VivedAPIEntity.type);
+    }
+}

package/lib/Components/VivedAPI/UCs/PatchAssetUC.d.ts

@@ -0,0 +1,14 @@
+import { HostAppObject, HostAppObjectRepo, HostAppObjectUC } from "../../../HostAppObject";
+export interface PatchAssetDTO {
+    id: string;
+    name: string;
+    description: string;
+    archived: boolean;
+    file: File;
+}
+export declare abstract class PatchAssetUC extends HostAppObjectUC {
+    static type: string;
+    abstract doPatch(data: PatchAssetDTO): Promise<void>;
+    static get(appObjects: HostAppObjectRepo): PatchAssetUC | undefined;
+}
+export declare function makePatchAssetUC(appObject: HostAppObject): PatchAssetUC;

package/lib/Components/VivedAPI/UCs/PatchAssetUC.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makePatchAssetUC = exports.PatchAssetUC = void 0;
+const HostAppObject_1 = require("../../../HostAppObject");
+const Utilities_1 = require("../../../Utilities");
+const VivedAPIEntity_1 = require("../Entities/VivedAPIEntity");
+const FileUploadUC_1 = require("./FileUploadUC");
+const JsonRequestUC_1 = require("./JsonRequestUC");
+const SignedAuthTokenUC_1 = require("./SignedAuthTokenUC");
+class PatchAssetUC extends HostAppObject_1.HostAppObjectUC {
+    static get(appObjects) {
+        return HostAppObject_1.getSingletonComponent(PatchAssetUC.type, appObjects);
+    }
+}
+exports.PatchAssetUC = PatchAssetUC;
+PatchAssetUC.type = "PatchAssetUC";
+function makePatchAssetUC(appObject) {
+    return new PatchAssetUCImp(appObject);
+}
+exports.makePatchAssetUC = makePatchAssetUC;
+class PatchAssetUCImp extends PatchAssetUC {
+    constructor(appObject) {
+        super(appObject, PatchAssetUC.type);
+        this.doPatch = (data) => {
+            const getAuthToken = this.getAuthToken;
+            const vivedAPI = this.vivedAPI;
+            const jsonRequester = this.jsonRequester;
+            const fileUpload = this.fileUpload;
+            if (!getAuthToken || !vivedAPI || !jsonRequester || !fileUpload) {
+                return Promise.reject();
+            }
+            const { id, file, name, description, archived } = data;
+            let extension = "";
+            const strArr = file.name.split(".");
+            extension = strArr[strArr.length - 1];
+            const filename = `${Utilities_1.generateUniqueID()}.${extension}`;
+            const assetFile = new File([file], `${filename}`, {
+                lastModified: Date.now()
+            });
+            return new Promise((resolve, reject) => {
+                fileUpload(assetFile)
+                    .then((_) => {
+                    return getAuthToken();
+                })
+                    .then((token) => {
+                    const url = vivedAPI.getEndpointURL(`assets/${id}`);
+                    const body = {
+                        archived,
+                        description,
+                        filename,
+                        name
+                    };
+                    const options = {
+                        method: "PATCH",
+                        body: JSON.stringify(body),
+                        headers: {
+                            Authorization: "Bearer " + token
+                        }
+                    };
+                    return jsonRequester(url, options);
+                })
+                    .then((_) => {
+                    resolve();
+                })
+                    .catch((e) => {
+                    reject(e);
+                    return;
+                });
+            });
+        };
+        this.appObjects.registerSingleton(this);
+    }
+    get jsonRequester() {
+        var _a;
+        return (_a = this.getCachedSingleton(JsonRequestUC_1.JsonRequestUC.type)) === null || _a === void 0 ? void 0 : _a.doRequest;
+    }
+    get getAuthToken() {
+        var _a;
+        return (_a = this.getCachedSingleton(SignedAuthTokenUC_1.SignedAuthTokenUC.type)) === null || _a === void 0 ? void 0 : _a.getUserAuthToken;
+    }
+    get fileUpload() {
+        var _a;
+        return (_a = this.getCachedSingleton(FileUploadUC_1.FileUploadUC.type)) === null || _a === void 0 ? void 0 : _a.doUpload;
+    }
+    get vivedAPI() {
+        return this.getCachedSingleton(VivedAPIEntity_1.VivedAPIEntity.type);
+    }
+}

package/lib/Components/VivedAPI/UCs/PostNewAssetUC.d.ts

@@ -0,0 +1,17 @@
+import { HostAppObject, HostAppObjectRepo, HostAppObjectUC } from '../../../HostAppObject';
+export interface NewAssetDTO {
+    name: string;
+    description: string;
+    ownerID: string;
+    file: File;
+}
+export interface NewAssetResponseDTO {
+    id: string;
+    filename: string;
+}
+export declare abstract class PostNewAssetUC extends HostAppObjectUC {
+    static type: string;
+    abstract doPost(data: NewAssetDTO): Promise<NewAssetResponseDTO>;
+    static get(appObjects: HostAppObjectRepo): PostNewAssetUC | undefined;
+}
+export declare function makePostNewAssetUC(appObject: HostAppObject): PostNewAssetUC;