@alfresco/aca-content 4.0.0-4895233349

package/esm2020/lib/services/content-service-extension.service.mjs

@@ -0,0 +1,63 @@
+/*!
+ * Copyright © 2005-2023 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Alfresco Example Content Application
+ *
+ * This file is part of the Alfresco Example Content Application.
+ * If the software was purchased under a paid Alfresco license, the terms of
+ * the paid license agreement will prevail. Otherwise, the software is
+ * provided under the following open source license terms:
+ *
+ * The Alfresco Example Content Application is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * The Alfresco Example Content Application is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * from Hyland Software. If not, see <http://www.gnu.org/licenses/>.
+ */
+import { Injectable } from '@angular/core';
+import { AppConfigService } from '@alfresco/adf-core';
+import { take } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "@alfresco/adf-core";
+export class ContentServiceExtensionService {
+    constructor(appConfigService) {
+        this.appConfigService = appConfigService;
+        this.updateContentServiceAvailability();
+    }
+    updateContentServiceAvailability() {
+        this.appConfigService.onLoad.pipe(take(1)).subscribe((config) => {
+            if (config.plugins && config.plugins.contentService === false) {
+                this.disableContentServices();
+            }
+            else {
+                this.enableContentServices();
+            }
+        });
+    }
+    disableContentServices() {
+        if (localStorage) {
+            localStorage.setItem('contentService', 'false');
+        }
+    }
+    enableContentServices() {
+        if (localStorage && localStorage.getItem('contentService') === 'false') {
+            localStorage.setItem('contentService', 'true');
+        }
+    }
+}
+ContentServiceExtensionService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.1.3", ngImport: i0, type: ContentServiceExtensionService, deps: [{ token: i1.AppConfigService }], target: i0.ɵɵFactoryTarget.Injectable });
+ContentServiceExtensionService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.1.3", ngImport: i0, type: ContentServiceExtensionService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.1.3", ngImport: i0, type: ContentServiceExtensionService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.AppConfigService }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/services/content-url.service.mjs

@@ -0,0 +1,72 @@
+/*!
+ * Copyright © 2005-2023 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Alfresco Example Content Application
+ *
+ * This file is part of the Alfresco Example Content Application.
+ * If the software was purchased under a paid Alfresco license, the terms of
+ * the paid license agreement will prevail. Otherwise, the software is
+ * provided under the following open source license terms:
+ *
+ * The Alfresco Example Content Application is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * The Alfresco Example Content Application is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * from Hyland Software. If not, see <http://www.gnu.org/licenses/>.
+ */
+import { Injectable } from '@angular/core';
+import { of } from 'rxjs';
+import { getRepositoryStatus } from '@alfresco/aca-shared/store';
+import { take, map, catchError, mergeMap } from 'rxjs/operators';
+import { Store } from '@ngrx/store';
+import { ContentApiService } from '@alfresco/aca-shared';
+import { ContentVersionService } from '@alfresco/adf-content-services';
+import { AlfrescoApiService } from '@alfresco/adf-core';
+import * as i0 from "@angular/core";
+import * as i1 from "@ngrx/store";
+import * as i2 from "@alfresco/aca-shared";
+import * as i3 from "@alfresco/adf-core";
+export class ContentUrlService extends ContentVersionService {
+    constructor(store, contentApiService, alfrescoApiService) {
+        super(alfrescoApiService);
+        this.store = store;
+        this.contentApiService = contentApiService;
+    }
+    getNodeContentUrl(nodeId, attachment = true) {
+        return this.isDirectAccessUrlEnabled().pipe(mergeMap((dauEnabled) => {
+            if (dauEnabled) {
+                return this.contentApiService.requestNodeDirectAccessUrl(nodeId).pipe(map((dauObj) => dauObj.entry.contentUrl), catchError(() => of(this.contentApiService.getContentUrl(nodeId, true))));
+            }
+            else {
+                return of(this.contentApiService.getContentUrl(nodeId, attachment));
+            }
+        }));
+    }
+    getVersionContentUrl(nodeId, versionId, attachment = true) {
+        return this.isDirectAccessUrlEnabled().pipe(mergeMap((dauEnabled) => {
+            if (dauEnabled) {
+                return this.contentApiService.requestVersionDirectAccessUrl(nodeId, versionId).pipe(map((dauObj) => dauObj.entry.contentUrl), catchError(() => of(this.contentApiService.getVersionContentUrl(nodeId, versionId, true))));
+            }
+            else {
+                return of(this.contentApiService.getVersionContentUrl(nodeId, versionId, attachment));
+            }
+        }));
+    }
+    isDirectAccessUrlEnabled() {
+        return this.store.select(getRepositoryStatus).pipe(take(1), map((repository) => !!repository?.status?.isDirectAccessUrlEnabled));
+    }
+}
+ContentUrlService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.1.3", ngImport: i0, type: ContentUrlService, deps: [{ token: i1.Store }, { token: i2.ContentApiService }, { token: i3.AlfrescoApiService }], target: i0.ɵɵFactoryTarget.Injectable });
+ContentUrlService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.1.3", ngImport: i0, type: ContentUrlService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.1.3", ngImport: i0, type: ContentUrlService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return [{ type: i1.Store }, { type: i2.ContentApiService }, { type: i3.AlfrescoApiService }]; } });
+//# sourceMappingURL=data:application/json;base64,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