@c8y/ngx-components 1017.0.338 → 1017.0.343

package/fesm2020/c8y-ngx-components-ecosystem-shared.mjs

@@ -10,7 +10,7 @@ import * as i3 from '@c8y/client';
 import { ApplicationAvailability, ApplicationType } from '@c8y/client';
 import * as i2$1 from '@ngx-translate/core';
 import { saveAs } from 'file-saver';
-import { groupBy, uniqBy, get, pick, kebabCase, cloneDeep } from 'lodash-es';
+import { groupBy, uniqBy, get, pick, omit, isUndefined, kebabCase, cloneDeep } from 'lodash-es';
 import { BehaviorSubject, defer, merge, combineLatest } from 'rxjs';
 import { map, shareReplay, debounceTime, take, distinctUntilKeyChanged, tap, filter, switchMap } from 'rxjs/operators';
 import { gt, coerce } from 'semver';
@@ -32,6 +32,7 @@ var ERROR_TYPE;
 (function (ERROR_TYPE) {
     ERROR_TYPE["TYPE_VALIDATION"] = "TYPE_VALIDATION";
     ERROR_TYPE["ALREADY_SUBSCRIBED"] = "ALREADY_SUBSCRIBED";
+    ERROR_TYPE["ALREADY_EXIST"] = "ALREADY_EXIST";
     ERROR_TYPE["INTERNAL_ERROR"] = "INTERNAL_ERROR";
     ERROR_TYPE["NO_MANIFEST_FILE"] = "NO_MANIFEST_FILE";
     ERROR_TYPE["INVALID_PACKAGE"] = "INVALID_PACKAGE";
@@ -39,6 +40,7 @@ var ERROR_TYPE;
     ERROR_TYPE["MICROSERVICE_NAME_TOO_LONG"] = "MICROSERVICE_NAME_TOO_LONG";
     ERROR_TYPE["APPLICATION_CREATION_FAILED"] = "APPLICATION_CREATION_FAILED";
     ERROR_TYPE["KEY_OR_CONTEXT_PATH_MISMATCH"] = "KEY_OR_CONTEXT_PATH_MISMATCH";
+    ERROR_TYPE["VERSION_NOT_FOUND"] = "VERSION_NOT_FOUND";
 })(ERROR_TYPE || (ERROR_TYPE = {}));
 const PRODUCT_EXPERIENCE = {
     APPLICATIONS: {
@@ -91,6 +93,7 @@ const PRODUCT_EXPERIENCE = {
 };
 
 const ERROR_MESSAGES = {
+    [ERROR_TYPE.ALREADY_EXIST]: gettext('Could not deploy the application, as the application with the same name, context-path or key exist already.'),
     [ERROR_TYPE.TYPE_VALIDATION]: gettext('Wrong file format. Expected a *.zip file with a valid manifest.'),
     [ERROR_TYPE.ALREADY_SUBSCRIBED]: gettext('Could not subscribe to the microservice because another application with the same context path is already subscribed.'),
     [ERROR_TYPE.NO_MANIFEST_FILE]: gettext('Could not find a manifest.'),
@@ -99,7 +102,8 @@ const ERROR_MESSAGES = {
     [ERROR_TYPE.INTERNAL_ERROR]: gettext('An internal error occurred, try to upload again.'),
     [ERROR_TYPE.MICROSERVICE_NAME_TOO_LONG]: gettext('Microservice name "{{ name }}" must not be longer than {{ maxChars }} characters.'),
     [ERROR_TYPE.APPLICATION_CREATION_FAILED]: gettext('Application creation failed.'),
-    [ERROR_TYPE.KEY_OR_CONTEXT_PATH_MISMATCH]: gettext('The contextPath or key of the uploaded archive do not match with the existing app.')
+    [ERROR_TYPE.KEY_OR_CONTEXT_PATH_MISMATCH]: gettext('The "contextPath`KEEP_ORIGINAL`" or "key`KEEP_ORIGINAL`" of the uploaded archive do not match with the existing application.'),
+    [ERROR_TYPE.VERSION_NOT_FOUND]: gettext('The selected version was not found on the server.')
 };
 const APP_STATE = {
     SUBSCRIBED: {
@@ -129,7 +133,7 @@ const APP_STATE = {
 };
 const packageProperties = [
     {
-        label: gettext('Version'),
+        label: gettext('Latest version'),
         key: 'version'
     },
     {
@@ -264,6 +268,14 @@ class EcosystemService {
         return webApps.sort((a, b) => a.name.localeCompare(b.name));
     }
     async getPackageApplications(customFilter = {}) {
+        const filterCallback = app => this.isPackage(app);
+        return this.getApplicationsFiltered(customFilter, filterCallback);
+    }
+    async getHostedAndPackageApplications(customFilter = {}) {
+        const filterCallback = app => this.isPackage(app) || this.isApplication(app);
+        return this.getApplicationsFiltered(customFilter, filterCallback);
+    }
+    async getApplicationsFiltered(customFilter = {}, filterCallback = (app) => !!app) {
         const filter = Object.assign({}, customFilter);
         const sharedFilter = Object.assign({
             availability: ApplicationAvailability.SHARED,
@@ -274,7 +286,7 @@ class EcosystemService {
             this.getApplications(filter),
             this.applicationService.list(sharedFilter)
         ]);
-        const webApps = [...apps, ...shared].filter(app => this.isPackage(app));
+        const webApps = [...apps, ...shared].filter(filterCallback);
         // an app could be subscribed to a tenant, but also have it's availability set to SHARED, in that case it would occur twice.
         const uniqWebApps = uniqBy(webApps, (app) => app.id);
         return uniqWebApps.sort((a, b) => a.name.localeCompare(b.name));
@@ -357,18 +369,6 @@ class EcosystemService {
         };
         return config;
     }
-    async updateAppManifest(application, sourcePackage) {
-        const { id } = application;
-        const cleanedApp = this.removeAppProperties(application);
-        if (!cleanedApp.manifest) {
-            cleanedApp.manifest = {};
-        }
-        cleanedApp.manifest.isPackage = false;
-        cleanedApp.manifest.source = sourcePackage.id;
-        return await this.applicationService
-            .binary(id)
-            .updateFiles([{ path: CUMULOCITY_JSON, contents: JSON.stringify(cleanedApp) }]);
-    }
     async listArchives(appId) {
         const filter = {
             pageSize: 100
@@ -576,6 +576,78 @@ class EcosystemService {
             this.alertError(ex);
         }
     }
+    async deployApp(selectedPackage, formGroupValue, model) {
+        // Create new app config
+        const config = this.createConfig(selectedPackage, formGroupValue);
+        const requestedVersion = model.selected.version;
+        let cleanManifest;
+        try {
+            const manifest = await this.applicationService.getAppManifest(selectedPackage, requestedVersion);
+            cleanManifest = omit(manifest, ['name', 'contextPath', 'key']);
+        }
+        catch (ex) {
+            throw new EcosystemError(ERROR_TYPE.VERSION_NOT_FOUND);
+        }
+        config.isSetup = true;
+        config.manifest = cleanManifest;
+        config.availability = ApplicationAvailability.PRIVATE;
+        config.manifest.isPackage = false;
+        config.manifest.source = selectedPackage.id;
+        config.manifest.package = 'blueprint';
+        // because of a issue with SHARED availability we always should check again
+        // if the app not exist already
+        const allExistingApps = await this.getHostedAndPackageApplications();
+        const doesAppKeyOrContextPathExist = this.checkIfAppNameKeyPathExists(allExistingApps, config);
+        if (doesAppKeyOrContextPathExist) {
+            throw new EcosystemError(ERROR_TYPE.ALREADY_EXIST);
+        }
+        // Create new app
+        const newApp = (await this.applicationService.create(config)).data;
+        try {
+            // Binary upload can fail if SHARED package
+            // in this case, catch error and fall back to
+            // clone API.
+            await this.uploadBinaryFromOtherPackage(selectedPackage, newApp, model.selected.binaryId, requestedVersion);
+        }
+        catch (error) {
+            if (error?.res?.status === 404) {
+                await this.fallbackToClone(newApp, selectedPackage, requestedVersion);
+            }
+        }
+        return newApp;
+    }
+    async fallbackToClone(application, selectedPackage, requestedVersion) {
+        let wasSuccess = true;
+        let clonedPkg;
+        try {
+            clonedPkg = (await this.applicationService.clone(selectedPackage, requestedVersion)).data;
+            await this.uploadBinaryFromOtherPackage(selectedPackage, application, clonedPkg.activeVersionId, requestedVersion, clonedPkg);
+        }
+        catch (error) {
+            this.alertError(error);
+            wasSuccess = false;
+        }
+        finally {
+            await this.deleteApp(clonedPkg, true);
+        }
+        return wasSuccess;
+    }
+    async uploadBinaryFromOtherPackage(selectedPackage, applicationToUploadBinaryTo, binaryId, requestedVersion, useBinariesFrom) {
+        const { data: binaryDetails } = await this.inventoryService.detail(binaryId);
+        // Get binary from specific package version
+        const binary = await this.getBinary(useBinariesFrom || selectedPackage, {
+            id: binaryId
+        });
+        // Create zip
+        const fileBinary = new Blob([binary], { type: binaryDetails.contentType });
+        const file = new File([fileBinary], binaryDetails.name, {
+            type: binaryDetails.contentType
+        });
+        // Upload binary to new app
+        await this.uploadArchiveToApp(file, applicationToUploadBinaryTo);
+        // update the app manifest
+        await this.updateAppManifest(applicationToUploadBinaryTo, selectedPackage, requestedVersion);
+    }
     getAppState(app) {
         if (!this.isOwner(app)) {
             return APP_STATE.SUBSCRIBED;
@@ -657,6 +729,43 @@ class EcosystemService {
             throw new EcosystemError(ERROR_TYPE.KEY_OR_CONTEXT_PATH_MISMATCH);
         }
     }
+    filterContainString(name, filterTerm) {
+        const term = filterTerm.toLowerCase().trim();
+        return name && name.toLowerCase().indexOf(term) > -1;
+    }
+    async updateAppManifest(application, selectedPackage, requestedVersion) {
+        const { id } = application;
+        const cleanedApp = this.removeAppProperties(application);
+        let manifest = selectedPackage.manifest || {};
+        if (requestedVersion) {
+            try {
+                const versionedAppManifest = await this.applicationService.getAppManifest(selectedPackage, requestedVersion);
+                manifest = versionedAppManifest;
+            }
+            catch (ex) {
+                throw new EcosystemError(ERROR_TYPE.VERSION_NOT_FOUND);
+            }
+        }
+        cleanedApp.manifest = manifest;
+        cleanedApp.manifest.isPackage = false;
+        cleanedApp.manifest.source = selectedPackage.id;
+        return await this.applicationService
+            .binary(id)
+            .updateFiles([{ path: CUMULOCITY_JSON, contents: JSON.stringify(cleanedApp) }]);
+    }
+    checkIfAppNameKeyPathExists(existingApps, app, retryNo) {
+        if (isUndefined(retryNo)) {
+            return existingApps.find(existingApp => existingApp.name === app.name ||
+                existingApp.key === app.key ||
+                existingApp.contextPath === app.contextPath);
+        }
+        return existingApps.find(existingApp => existingApp.name === app.name ||
+            existingApp.key === app.key ||
+            existingApp.contextPath === app.contextPath ||
+            existingApp.name === [app.name, retryNo].join('-') ||
+            existingApp.key === [app.key, retryNo].join('-') ||
+            existingApp.contextPath === [app.contextPath, retryNo].join('-'));
+    }
     getAppKey(appModel, name) {
         let key = appModel?.key;
         if (!key) {
@@ -693,17 +802,9 @@ class EcosystemService {
         }
         return baseName;
     }
-    checkIfAppNameKeyPathExists(existingApps, app, retryNo) {
-        return existingApps.find(existingApp => existingApp.name === app.name ||
-            existingApp.key === app.key ||
-            existingApp.contextPath === app.contextPath ||
-            existingApp.name === [app.name, retryNo].join('-') ||
-            existingApp.key === [app.key, retryNo].join('-') ||
-            existingApp.contextPath === [app.contextPath, retryNo].join('-'));
-    }
     removeAppProperties(app) {
         const tempApp = cloneDeep(app);
-        const propertiesToRemove = ['id', 'owner', 'activeVersionId', 'self'];
+        const propertiesToRemove = ['id', 'owner', 'activeVersionId', 'self', 'type'];
         propertiesToRemove.forEach(prop => delete tempApp[prop]);
         return tempApp;
     }