@alfresco/adf-content-services 8.1.0-16116688508 → 8.1.0-16117584844

package/esm2022/lib/permission-manager/components/user-role-column/user-role-column.component.mjs

@@ -0,0 +1,111 @@
+/*!
+ * @license
+ * Copyright © 2005-2025 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { Component, EventEmitter, Input, Output, ViewEncapsulation } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { MatFormFieldModule } from '@angular/material/form-field';
+import { MatSelectModule } from '@angular/material/select';
+import { TranslatePipe } from '@ngx-translate/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+import * as i2 from "@angular/material/form-field";
+import * as i3 from "@angular/material/select";
+import * as i4 from "@angular/material/core";
+export class UserRoleColumnComponent {
+    constructor() {
+        this.readonly = false;
+        this.placeholder = 'PERMISSION_MANAGER.LABELS.SELECT-ROLE';
+        this.roleChanged = new EventEmitter();
+        /* dropdown options, including i18n support */
+        this.options = [];
+    }
+    onRoleChanged(newRole) {
+        this.value = newRole;
+        this.roleChanged.emit(newRole);
+    }
+    i18nRoleValue(value) {
+        if (value) {
+            return `ADF.ROLES.${value.toUpperCase()}`;
+        }
+        return value;
+    }
+    ngOnChanges(changes) {
+        if (changes.value) {
+            this.i18nValue = this.i18nRoleValue(changes.value.currentValue);
+        }
+        if (changes.roles) {
+            const roles = changes.roles.currentValue || [];
+            this.options = roles.map((role) => ({ label: this.i18nRoleValue(role.label), role: role.role }));
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: UserRoleColumnComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.13", type: UserRoleColumnComponent, isStandalone: true, selector: "adf-user-role-column", inputs: { roles: "roles", value: "value", readonly: "readonly", placeholder: "placeholder" }, outputs: { roleChanged: "roleChanged" }, host: { classAttribute: "adf-user-role-column adf-datatable-content-cell adf-expand-cell-4" }, usesOnChanges: true, ngImport: i0, template: `
+        <mat-form-field class="adf-role-selector-field" *ngIf="!readonly" subscriptSizing="dynamic">
+            <mat-select
+                class="adf-role-selector"
+                (click)="$event.stopPropagation()"
+                [placeholder]="placeholder | translate"
+                [value]="value"
+                (selectionChange)="onRoleChanged($event.value)"
+                (keyup.arrowdown)="$event.stopPropagation()"
+                (keyup.arrowup)="$event.stopPropagation()"
+            >
+                <mat-option *ngFor="let option of options" [value]="option.role">
+                    {{ option.label | translate }}
+                </mat-option>
+            </mat-select>
+        </mat-form-field>
+
+        <span class="adf-datatable-cell-value adf-readonly-role" [title]="i18nValue | translate" *ngIf="readonly">
+            {{ i18nValue | translate }}
+        </span>
+    `, isInline: true, styles: [".adf-role-selector-field.mat-mdc-form-field{width:100%;max-width:200px;height:40px}.adf-role-selector-field.mat-mdc-form-field .mat-mdc-form-field-infix:not(:disabled){padding-top:8px}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "ngmodule", type: MatFormFieldModule }, { kind: "component", type: i2.MatFormField, selector: "mat-form-field", inputs: ["hideRequiredMarker", "color", "floatLabel", "appearance", "subscriptSizing", "hintLabel"], exportAs: ["matFormField"] }, { kind: "ngmodule", type: MatSelectModule }, { kind: "component", type: i3.MatSelect, selector: "mat-select", inputs: ["aria-describedby", "panelClass", "disabled", "disableRipple", "tabIndex", "hideSingleSelectionIndicator", "placeholder", "required", "multiple", "disableOptionCentering", "compareWith", "value", "aria-label", "aria-labelledby", "errorStateMatcher", "typeaheadDebounceInterval", "sortComparator", "id", "panelWidth"], outputs: ["openedChange", "opened", "closed", "selectionChange", "valueChange"], exportAs: ["matSelect"] }, { kind: "component", type: i4.MatOption, selector: "mat-option", inputs: ["value", "id", "disabled"], outputs: ["onSelectionChange"], exportAs: ["matOption"] }, { kind: "pipe", type: TranslatePipe, name: "translate" }], encapsulation: i0.ViewEncapsulation.None }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: UserRoleColumnComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'adf-user-role-column', standalone: true, imports: [CommonModule, MatFormFieldModule, MatSelectModule, TranslatePipe], template: `
+        <mat-form-field class="adf-role-selector-field" *ngIf="!readonly" subscriptSizing="dynamic">
+            <mat-select
+                class="adf-role-selector"
+                (click)="$event.stopPropagation()"
+                [placeholder]="placeholder | translate"
+                [value]="value"
+                (selectionChange)="onRoleChanged($event.value)"
+                (keyup.arrowdown)="$event.stopPropagation()"
+                (keyup.arrowup)="$event.stopPropagation()"
+            >
+                <mat-option *ngFor="let option of options" [value]="option.role">
+                    {{ option.label | translate }}
+                </mat-option>
+            </mat-select>
+        </mat-form-field>
+
+        <span class="adf-datatable-cell-value adf-readonly-role" [title]="i18nValue | translate" *ngIf="readonly">
+            {{ i18nValue | translate }}
+        </span>
+    `, encapsulation: ViewEncapsulation.None, host: { class: 'adf-user-role-column adf-datatable-content-cell adf-expand-cell-4' }, styles: [".adf-role-selector-field.mat-mdc-form-field{width:100%;max-width:200px;height:40px}.adf-role-selector-field.mat-mdc-form-field .mat-mdc-form-field-infix:not(:disabled){padding-top:8px}\n"] }]
+        }], propDecorators: { roles: [{
+                type: Input
+            }], value: [{
+                type: Input
+            }], readonly: [{
+                type: Input
+            }], placeholder: [{
+                type: Input
+            }], roleChanged: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/permission-manager/index.mjs

@@ -0,0 +1,18 @@
+/*!
+ * @license
+ * Copyright © 2005-2025 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+export * from './public-api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9saWIvY29udGVudC1zZXJ2aWNlcy9zcmMvbGliL3Blcm1pc3Npb24tbWFuYWdlci9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7Ozs7Ozs7Ozs7O0dBZUc7QUFFSCxjQUFjLGNBQWMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qIVxuICogQGxpY2Vuc2VcbiAqIENvcHlyaWdodCDCqSAyMDA1LTIwMjUgSHlsYW5kIFNvZnR3YXJlLCBJbmMuIGFuZCBpdHMgYWZmaWxpYXRlcy4gQWxsIHJpZ2h0cyByZXNlcnZlZC5cbiAqXG4gKiBMaWNlbnNlZCB1bmRlciB0aGUgQXBhY2hlIExpY2Vuc2UsIFZlcnNpb24gMi4wICh0aGUgXCJMaWNlbnNlXCIpO1xuICogeW91IG1heSBub3QgdXNlIHRoaXMgZmlsZSBleGNlcHQgaW4gY29tcGxpYW5jZSB3aXRoIHRoZSBMaWNlbnNlLlxuICogWW91IG1heSBvYnRhaW4gYSBjb3B5IG9mIHRoZSBMaWNlbnNlIGF0XG4gKlxuICogICAgIGh0dHA6Ly93d3cuYXBhY2hlLm9yZy9saWNlbnNlcy9MSUNFTlNFLTIuMFxuICpcbiAqIFVubGVzcyByZXF1aXJlZCBieSBhcHBsaWNhYmxlIGxhdyBvciBhZ3JlZWQgdG8gaW4gd3JpdGluZywgc29mdHdhcmVcbiAqIGRpc3RyaWJ1dGVkIHVuZGVyIHRoZSBMaWNlbnNlIGlzIGRpc3RyaWJ1dGVkIG9uIGFuIFwiQVMgSVNcIiBCQVNJUyxcbiAqIFdJVEhPVVQgV0FSUkFOVElFUyBPUiBDT05ESVRJT05TIE9GIEFOWSBLSU5ELCBlaXRoZXIgZXhwcmVzcyBvciBpbXBsaWVkLlxuICogU2VlIHRoZSBMaWNlbnNlIGZvciB0aGUgc3BlY2lmaWMgbGFuZ3VhZ2UgZ292ZXJuaW5nIHBlcm1pc3Npb25zIGFuZFxuICogbGltaXRhdGlvbnMgdW5kZXIgdGhlIExpY2Vuc2UuXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9wdWJsaWMtYXBpJztcbiJdfQ==

package/esm2022/lib/permission-manager/models/member.model.mjs

@@ -0,0 +1,59 @@
+/*!
+ * @license
+ * Copyright © 2005-2025 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { EcmUserModel } from '../../common/models/ecm-user.model';
+export class MemberModel {
+    constructor(input) {
+        this.readonly = false;
+        if (input) {
+            Object.assign(this, input);
+        }
+    }
+    static parseFromSearchResult({ entry }) {
+        const result = new MemberModel();
+        if (entry.nodeType === 'cm:person') {
+            const person = new EcmUserModel({
+                firstName: entry.properties['cm:firstName'],
+                lastName: entry.properties['cm:lastName'],
+                email: entry.properties['cm:email'],
+                id: entry.properties['cm:userName']
+            });
+            result.id = person.id;
+            result.entry = { person };
+            result.accessStatus = 'ALLOWED';
+            return result;
+        }
+        if (entry.nodeType === 'cm:authorityContainer') {
+            const group = {
+                id: entry.properties['cm:authorityName'],
+                displayName: entry.properties['cm:authorityDisplayName'] || entry.properties['cm:authorityName']
+            };
+            result.id = group.id;
+            result.entry = { group };
+            result.accessStatus = 'ALLOWED';
+            return result;
+        }
+        return null;
+    }
+    toPermissionElement() {
+        return {
+            authorityId: this.id,
+            name: this.role,
+            accessStatus: this.accessStatus
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/permission-manager/models/permission.model.mjs

@@ -0,0 +1,29 @@
+/*!
+ * @license
+ * Copyright © 2005-2025 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+export class PermissionDisplayModel {
+    constructor(obj) {
+        this.isInherited = false;
+        if (obj) {
+            this.authorityId = obj.authorityId;
+            this.name = obj.name;
+            this.accessStatus = obj.accessStatus;
+            this.isInherited = obj.isInherited !== null && obj.isInherited !== undefined ? obj.isInherited : false;
+            this.icon = obj.icon ? obj.icon : 'vpn_key';
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/permission-manager/models/role.model.mjs

@@ -0,0 +1,18 @@
+/*!
+ * @license
+ * Copyright © 2005-2025 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicm9sZS5tb2RlbC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL2xpYi9jb250ZW50LXNlcnZpY2VzL3NyYy9saWIvcGVybWlzc2lvbi1tYW5hZ2VyL21vZGVscy9yb2xlLm1vZGVsLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7Ozs7Ozs7Ozs7R0FlRyIsInNvdXJjZXNDb250ZW50IjpbIi8qIVxuICogQGxpY2Vuc2VcbiAqIENvcHlyaWdodCDCqSAyMDA1LTIwMjUgSHlsYW5kIFNvZnR3YXJlLCBJbmMuIGFuZCBpdHMgYWZmaWxpYXRlcy4gQWxsIHJpZ2h0cyByZXNlcnZlZC5cbiAqXG4gKiBMaWNlbnNlZCB1bmRlciB0aGUgQXBhY2hlIExpY2Vuc2UsIFZlcnNpb24gMi4wICh0aGUgXCJMaWNlbnNlXCIpO1xuICogeW91IG1heSBub3QgdXNlIHRoaXMgZmlsZSBleGNlcHQgaW4gY29tcGxpYW5jZSB3aXRoIHRoZSBMaWNlbnNlLlxuICogWW91IG1heSBvYnRhaW4gYSBjb3B5IG9mIHRoZSBMaWNlbnNlIGF0XG4gKlxuICogICAgIGh0dHA6Ly93d3cuYXBhY2hlLm9yZy9saWNlbnNlcy9MSUNFTlNFLTIuMFxuICpcbiAqIFVubGVzcyByZXF1aXJlZCBieSBhcHBsaWNhYmxlIGxhdyBvciBhZ3JlZWQgdG8gaW4gd3JpdGluZywgc29mdHdhcmVcbiAqIGRpc3RyaWJ1dGVkIHVuZGVyIHRoZSBMaWNlbnNlIGlzIGRpc3RyaWJ1dGVkIG9uIGFuIFwiQVMgSVNcIiBCQVNJUyxcbiAqIFdJVEhPVVQgV0FSUkFOVElFUyBPUiBDT05ESVRJT05TIE9GIEFOWSBLSU5ELCBlaXRoZXIgZXhwcmVzcyBvciBpbXBsaWVkLlxuICogU2VlIHRoZSBMaWNlbnNlIGZvciB0aGUgc3BlY2lmaWMgbGFuZ3VhZ2UgZ292ZXJuaW5nIHBlcm1pc3Npb25zIGFuZFxuICogbGltaXRhdGlvbnMgdW5kZXIgdGhlIExpY2Vuc2UuXG4gKi9cblxuZXhwb3J0IGludGVyZmFjZSBSb2xlTW9kZWwge1xuICAgIGxhYmVsOiBzdHJpbmc7XG4gICAgcm9sZTogc3RyaW5nO1xufVxuIl19

package/esm2022/lib/permission-manager/permission-manager.module.mjs

@@ -0,0 +1,84 @@
+/*!
+ * @license
+ * Copyright © 2005-2025 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { NgModule } from '@angular/core';
+import { PermissionListComponent } from './components/permission-list/permission-list.component';
+import { AddPermissionComponent } from './components/add-permission/add-permission.component';
+import { AddPermissionDialogComponent } from './components/add-permission/add-permission-dialog.component';
+import { InheritPermissionDirective } from './components/inherited-button.directive';
+import { AddPermissionPanelComponent } from './components/add-permission/add-permission-panel.component';
+import { UserNameColumnComponent } from './components/user-name-column/user-name-column.component';
+import { UserIconColumnComponent } from './components/user-icon-column/user-icon-column.component';
+import { UserRoleColumnComponent } from './components/user-role-column/user-role-column.component';
+import { NodePathColumnComponent } from './components/node-path-column/node-path-column.component';
+import { PopOverDirective } from './components/pop-over.directive';
+import { PermissionContainerComponent } from './components/permission-container/permission-container.component';
+import * as i0 from "@angular/core";
+export const CONTENT_PERMISSION_MANAGER_DIRECTIVES = [
+    AddPermissionPanelComponent,
+    AddPermissionComponent,
+    AddPermissionDialogComponent,
+    NodePathColumnComponent,
+    PermissionContainerComponent,
+    PermissionListComponent,
+    UserNameColumnComponent,
+    UserIconColumnComponent,
+    UserRoleColumnComponent,
+    InheritPermissionDirective,
+    PopOverDirective
+];
+/** @deprecated use `...CONTENT_PERMISSION_MANAGER_DIRECTIVES` or import the standalone components directly */
+export class PermissionManagerModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: PermissionManagerModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.2.13", ngImport: i0, type: PermissionManagerModule, imports: [AddPermissionPanelComponent,
+            AddPermissionComponent,
+            AddPermissionDialogComponent,
+            NodePathColumnComponent,
+            PermissionContainerComponent,
+            PermissionListComponent,
+            UserNameColumnComponent,
+            UserIconColumnComponent,
+            UserRoleColumnComponent,
+            InheritPermissionDirective,
+            PopOverDirective], exports: [AddPermissionPanelComponent,
+            AddPermissionComponent,
+            AddPermissionDialogComponent,
+            NodePathColumnComponent,
+            PermissionContainerComponent,
+            PermissionListComponent,
+            UserNameColumnComponent,
+            UserIconColumnComponent,
+            UserRoleColumnComponent,
+            InheritPermissionDirective,
+            PopOverDirective] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: PermissionManagerModule, imports: [AddPermissionPanelComponent,
+            AddPermissionComponent,
+            AddPermissionDialogComponent,
+            NodePathColumnComponent,
+            PermissionContainerComponent,
+            PermissionListComponent,
+            UserNameColumnComponent,
+            UserIconColumnComponent,
+            UserRoleColumnComponent] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: PermissionManagerModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [...CONTENT_PERMISSION_MANAGER_DIRECTIVES],
+                    exports: [...CONTENT_PERMISSION_MANAGER_DIRECTIVES]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/permission-manager/public-api.mjs

@@ -0,0 +1,36 @@
+/*!
+ * @license
+ * Copyright © 2005-2025 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+export * from './components/permission-list/permission-list.component';
+export * from './components/inherited-button.directive';
+export * from './models/permission.model';
+export * from './services/node-permission-dialog.service';
+export * from './services/node-permission.service';
+export * from './components/add-permission/add-permission-dialog-data.interface';
+export * from './components/add-permission/add-permission-panel.component';
+export * from './components/add-permission/add-permission.component';
+export * from './components/add-permission/add-permission-dialog.component';
+export * from './components/add-permission/search-config-permission.service';
+export * from './components/user-icon-column/user-icon-column.component';
+export * from './components/user-name-column/user-name-column.component';
+export * from './components/user-role-column/user-role-column.component';
+export * from './components/node-path-column/node-path-column.component';
+export * from './components/permission-container/permission-container.component';
+export * from './components/pop-over.directive';
+export * from './models/member.model';
+export * from './models/role.model';
+export * from './permission-manager.module';
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/permission-manager/services/node-permission-dialog.service.mjs

@@ -0,0 +1,78 @@
+import { MatDialog } from '@angular/material/dialog';
+import { Injectable } from '@angular/core';
+import { Subject, throwError } from 'rxjs';
+import { switchMap } from 'rxjs/operators';
+import { NodePermissionService } from './node-permission.service';
+import { AddPermissionDialogComponent } from '../components/add-permission/add-permission-dialog.component';
+import { ContentService } from '../../common/services/content.service';
+import { AllowableOperationsEnum } from '../../common/models/allowable-operations.enum';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/material/dialog";
+import * as i2 from "./node-permission.service";
+import * as i3 from "../../common/services/content.service";
+export class NodePermissionDialogService {
+    constructor(dialog, nodePermissionService, contentService) {
+        this.dialog = dialog;
+        this.nodePermissionService = nodePermissionService;
+        this.contentService = contentService;
+    }
+    /**
+     * Opens a dialog to add permissions to a node.
+     *
+     * @param node target node
+     * @param roles settable roles for the node
+     * @param title Dialog title
+     * @returns Node with updated permissions
+     */
+    openAddPermissionDialog(node, roles, title) {
+        if (this.contentService.hasAllowableOperations(node, AllowableOperationsEnum.UPDATEPERMISSIONS)) {
+            const confirm = new Subject();
+            confirm.subscribe({
+                complete: this.close.bind(this)
+            });
+            const data = {
+                node,
+                title,
+                confirm,
+                roles
+            };
+            this.openDialog(data, 'adf-add-permission-dialog', '800px');
+            return confirm;
+        }
+        else {
+            const errors = new Error(JSON.stringify({ error: { statusCode: 403 } }));
+            errors.message = 'PERMISSION_MANAGER.ERROR.NOT-ALLOWED';
+            return throwError(errors);
+        }
+    }
+    openDialog(data, currentPanelClass, chosenWidth) {
+        this.dialog.open(AddPermissionDialogComponent, { data, panelClass: currentPanelClass, width: chosenWidth, restoreFocus: true });
+    }
+    /**
+     * Closes the currently-open dialog.
+     */
+    close() {
+        this.dialog.closeAll();
+    }
+    /**
+     * Opens a dialog to update permissions for a node.
+     *
+     * @param nodeId ID of the target node
+     * @param title Dialog title
+     * @returns Node with updated permissions
+     */
+    updateNodePermissionByDialog(nodeId, title) {
+        return this.nodePermissionService
+            .getNodeWithRoles(nodeId)
+            .pipe(switchMap(({ node, roles }) => this.openAddPermissionDialog(node, roles, title).pipe(switchMap((selection) => this.nodePermissionService.updateNodePermissions(nodeId, selection)))));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: NodePermissionDialogService, deps: [{ token: i1.MatDialog }, { token: i2.NodePermissionService }, { token: i3.ContentService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: NodePermissionDialogService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: NodePermissionDialogService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.MatDialog }, { type: i2.NodePermissionService }, { type: i3.ContentService }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"node-permission-dialog.service.js","sourceRoot":"","sources":["../../../../../../../lib/content-services/src/lib/permission-manager/services/node-permission-dialog.service.ts"],"names":[],"mappings":"AAkBA,OAAO,EAAE,SAAS,EAAE,MAAM,0BAA0B,CAAC;AACrD,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAC3C,OAAO,EAAc,OAAO,EAAE,UAAU,EAAE,MAAM,MAAM,CAAC;AACvD,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAC3C,OAAO,EAAE,qBAAqB,EAAE,MAAM,2BAA2B,CAAC;AAClE,OAAO,EAAE,4BAA4B,EAAE,MAAM,8DAA8D,CAAC;AAG5G,OAAO,EAAE,cAAc,EAAE,MAAM,uCAAuC,CAAC;AACvE,OAAO,EAAE,uBAAuB,EAAE,MAAM,+CAA+C,CAAC;;;;;AAKxF,MAAM,OAAO,2BAA2B;IACpC,YAAoB,MAAiB,EAAU,qBAA4C,EAAU,cAA8B;QAA/G,WAAM,GAAN,MAAM,CAAW;QAAU,0BAAqB,GAArB,qBAAqB,CAAuB;QAAU,mBAAc,GAAd,cAAc,CAAgB;IAAG,CAAC;IAEvI;;;;;;;OAOG;IACH,uBAAuB,CAAC,IAAU,EAAE,KAAkB,EAAE,KAAc;QAClE,IAAI,IAAI,CAAC,cAAc,CAAC,sBAAsB,CAAC,IAAI,EAAE,uBAAuB,CAAC,iBAAiB,CAAC,EAAE,CAAC;YAC9F,MAAM,OAAO,GAAG,IAAI,OAAO,EAAuB,CAAC;YAEnD,OAAO,CAAC,SAAS,CAAC;gBACd,QAAQ,EAAE,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC;aAClC,CAAC,CAAC;YAEH,MAAM,IAAI,GAA4B;gBAClC,IAAI;gBACJ,KAAK;gBACL,OAAO;gBACP,KAAK;aACR,CAAC;YAEF,IAAI,CAAC,UAAU,CAAC,IAAI,EAAE,2BAA2B,EAAE,OAAO,CAAC,CAAC;YAC5D,OAAO,OAAO,CAAC;QACnB,CAAC;aAAM,CAAC;YACJ,MAAM,MAAM,GAAG,IAAI,KAAK,CAAC,IAAI,CAAC,SAAS,CAAC,EAAE,KAAK,EAAE,EAAE,UAAU,EAAE,GAAG,EAAE,EAAE,CAAC,CAAC,CAAC;YACzE,MAAM,CAAC,OAAO,GAAG,sCAAsC,CAAC;YACxD,OAAO,UAAU,CAAC,MAAM,CAAC,CAAC;QAC9B,CAAC;IACL,CAAC;IAEO,UAAU,CAAC,IAAS,EAAE,iBAAyB,EAAE,WAAmB;QACxE,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,4BAA4B,EAAE,EAAE,IAAI,EAAE,UAAU,EAAE,iBAAiB,EAAE,KAAK,EAAE,WAAW,EAAE,YAAY,EAAE,IAAI,EAAE,CAAC,CAAC;IACpI,CAAC;IAED;;OAEG;IACH,KAAK;QACD,IAAI,CAAC,MAAM,CAAC,QAAQ,EAAE,CAAC;IAC3B,CAAC;IAED;;;;;;OAMG;IACH,4BAA4B,CAAC,MAAe,EAAE,KAAc;QACxD,OAAO,IAAI,CAAC,qBAAqB;aAC5B,gBAAgB,CAAC,MAAM,CAAC;aACxB,IAAI,CACD,SAAS,CAAC,CAAC,EAAE,IAAI,EAAE,KAAK,EAAE,EAAE,EAAE,CAC1B,IAAI,CAAC,uBAAuB,CAAC,IAAI,EAAE,KAAK,EAAE,KAAK,CAAC,CAAC,IAAI,CACjD,SAAS,CAAC,CAAC,SAAS,EAAE,EAAE,CAAC,IAAI,CAAC,qBAAqB,CAAC,qBAAqB,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC,CAChG,CACJ,CACJ,CAAC;IACV,CAAC;+GA/DQ,2BAA2B;mHAA3B,2BAA2B,cAFxB,MAAM;;4FAET,2BAA2B;kBAHvC,UAAU;mBAAC;oBACR,UAAU,EAAE,MAAM;iBACrB","sourcesContent":["/*!\n * @license\n * Copyright © 2005-2025 Hyland Software, Inc. and its affiliates. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { Node, PermissionElement } from '@alfresco/js-api';\nimport { MatDialog } from '@angular/material/dialog';\nimport { Injectable } from '@angular/core';\nimport { Observable, Subject, throwError } from 'rxjs';\nimport { switchMap } from 'rxjs/operators';\nimport { NodePermissionService } from './node-permission.service';\nimport { AddPermissionDialogComponent } from '../components/add-permission/add-permission-dialog.component';\nimport { AddPermissionDialogData } from '../components/add-permission/add-permission-dialog-data.interface';\nimport { RoleModel } from '../models/role.model';\nimport { ContentService } from '../../common/services/content.service';\nimport { AllowableOperationsEnum } from '../../common/models/allowable-operations.enum';\n\n@Injectable({\n    providedIn: 'root'\n})\nexport class NodePermissionDialogService {\n    constructor(private dialog: MatDialog, private nodePermissionService: NodePermissionService, private contentService: ContentService) {}\n\n    /**\n     * Opens a dialog to add permissions to a node.\n     *\n     * @param node target node\n     * @param roles settable roles for the node\n     * @param title Dialog title\n     * @returns Node with updated permissions\n     */\n    openAddPermissionDialog(node: Node, roles: RoleModel[], title?: string): Observable<PermissionElement[]> {\n        if (this.contentService.hasAllowableOperations(node, AllowableOperationsEnum.UPDATEPERMISSIONS)) {\n            const confirm = new Subject<PermissionElement[]>();\n\n            confirm.subscribe({\n                complete: this.close.bind(this)\n            });\n\n            const data: AddPermissionDialogData = {\n                node,\n                title,\n                confirm,\n                roles\n            };\n\n            this.openDialog(data, 'adf-add-permission-dialog', '800px');\n            return confirm;\n        } else {\n            const errors = new Error(JSON.stringify({ error: { statusCode: 403 } }));\n            errors.message = 'PERMISSION_MANAGER.ERROR.NOT-ALLOWED';\n            return throwError(errors);\n        }\n    }\n\n    private openDialog(data: any, currentPanelClass: string, chosenWidth: string) {\n        this.dialog.open(AddPermissionDialogComponent, { data, panelClass: currentPanelClass, width: chosenWidth, restoreFocus: true });\n    }\n\n    /**\n     * Closes the currently-open dialog.\n     */\n    close() {\n        this.dialog.closeAll();\n    }\n\n    /**\n     * Opens a dialog to update permissions for a node.\n     *\n     * @param nodeId ID of the target node\n     * @param title Dialog title\n     * @returns Node with updated permissions\n     */\n    updateNodePermissionByDialog(nodeId?: string, title?: string): Observable<Node> {\n        return this.nodePermissionService\n            .getNodeWithRoles(nodeId)\n            .pipe(\n                switchMap(({ node, roles }) =>\n                    this.openAddPermissionDialog(node, roles, title).pipe(\n                        switchMap((selection) => this.nodePermissionService.updateNodePermissions(nodeId, selection))\n                    )\n                )\n            );\n    }\n}\n"]}