@alfresco/adf-content-services
Version:
Alfresco ADF content services
126 lines • 13.6 kB
JavaScript
/*!
* @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.
*/
/* eslint-disable @angular-eslint/no-input-rename */
import { ChangeDetectorRef, Directive, ElementRef, Host, Inject, Input, Optional, Renderer2 } from '@angular/core';
import { EXTENDIBLE_COMPONENT } from '@alfresco/adf-core';
import { ContentService } from '../common/services/content.service';
import * as i0 from "@angular/core";
import * as i1 from "../common/services/content.service";
export class CheckAllowableOperationDirective {
constructor(elementRef, renderer, contentService, changeDetector, parentComponent) {
this.elementRef = elementRef;
this.renderer = renderer;
this.contentService = contentService;
this.changeDetector = changeDetector;
this.parentComponent = parentComponent;
/**
* Node permission to check (create, delete, update, updatePermissions,
* !create, !delete, !update, !updatePermissions).
*/
this.permission = null;
/** Nodes to check permission for. */
this.nodes = [];
}
ngOnChanges(changes) {
if (changes.nodes && !changes.nodes.firstChange) {
this.updateElement();
}
}
/**
* Updates disabled state for the decorated element
*
* @returns the new state
*/
updateElement() {
const enable = this.hasAllowableOperations(this.nodes, this.permission);
if (enable) {
this.enable();
}
else {
this.disable();
}
return enable;
}
enable() {
if (this.parentComponent) {
this.parentComponent.disabled = false;
this.changeDetector.detectChanges();
}
else {
this.enableElement();
}
}
disable() {
if (this.parentComponent) {
this.parentComponent.disabled = true;
this.changeDetector.detectChanges();
}
else {
this.disableElement();
}
}
/**
* Enables decorated element
*
*/
enableElement() {
this.renderer.removeAttribute(this.elementRef.nativeElement, 'disabled');
}
/**
* Disables decorated element
*
*/
disableElement() {
this.renderer.setAttribute(this.elementRef.nativeElement, 'disabled', 'true');
}
/**
* Checks whether all nodes have a particular permission
*
* @param nodes Node collection to check
* @param permission Permission to check for each node
* @returns `true` if there are allowable operations, otherwise `false`
*/
hasAllowableOperations(nodes, permission) {
if (nodes && nodes.length > 0) {
return nodes.every((node) => this.contentService.hasAllowableOperations(node.entry, permission));
}
return false;
}
static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: CheckAllowableOperationDirective, deps: [{ token: i0.ElementRef }, { token: i0.Renderer2 }, { token: i1.ContentService }, { token: i0.ChangeDetectorRef }, { token: EXTENDIBLE_COMPONENT, host: true, optional: true }], target: i0.ɵɵFactoryTarget.Directive }); }
static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "17.1.3", type: CheckAllowableOperationDirective, isStandalone: true, selector: "[adf-check-allowable-operation]", inputs: { permission: ["adf-check-allowable-operation", "permission"], nodes: ["adf-nodes", "nodes"] }, usesOnChanges: true, ngImport: i0 }); }
}
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: CheckAllowableOperationDirective, decorators: [{
type: Directive,
args: [{
standalone: true,
selector: '[adf-check-allowable-operation]'
}]
}], ctorParameters: () => [{ type: i0.ElementRef }, { type: i0.Renderer2 }, { type: i1.ContentService }, { type: i0.ChangeDetectorRef }, { type: undefined, decorators: [{
type: Host
}, {
type: Optional
}, {
type: Inject,
args: [EXTENDIBLE_COMPONENT]
}] }], propDecorators: { permission: [{
type: Input,
args: ['adf-check-allowable-operation']
}], nodes: [{
type: Input,
args: ['adf-nodes']
}] } });
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"check-allowable-operation.directive.js","sourceRoot":"","sources":["../../../../../../lib/content-services/src/lib/directives/check-allowable-operation.directive.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,oDAAoD;AAEpD,OAAO,EAAE,iBAAiB,EAAE,SAAS,EAAE,UAAU,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAa,QAAQ,EAAE,SAAS,EAAiB,MAAM,eAAe,CAAC;AAE7I,OAAO,EAAE,oBAAoB,EAAE,MAAM,oBAAoB,CAAC;AAC1D,OAAO,EAAE,cAAc,EAAE,MAAM,oCAAoC,CAAC;;;AAOpE,MAAM,OAAO,gCAAgC;IAYzC,YACY,UAAsB,EACtB,QAAmB,EACnB,cAA8B,EAC9B,cAAiC,EAKjC,eAA+C;QAR/C,eAAU,GAAV,UAAU,CAAY;QACtB,aAAQ,GAAR,QAAQ,CAAW;QACnB,mBAAc,GAAd,cAAc,CAAgB;QAC9B,mBAAc,GAAd,cAAc,CAAmB;QAKjC,oBAAe,GAAf,eAAe,CAAgC;QApB3D;;;WAGG;QAEH,eAAU,GAAW,IAAI,CAAC;QAE1B,qCAAqC;QAErC,UAAK,GAAgB,EAAE,CAAC;IAYrB,CAAC;IAEJ,WAAW,CAAC,OAAsB;QAC9B,IAAI,OAAO,CAAC,KAAK,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,WAAW,EAAE,CAAC;YAC9C,IAAI,CAAC,aAAa,EAAE,CAAC;QACzB,CAAC;IACL,CAAC;IAED;;;;OAIG;IACH,aAAa;QACT,MAAM,MAAM,GAAG,IAAI,CAAC,sBAAsB,CAAC,IAAI,CAAC,KAAK,EAAE,IAAI,CAAC,UAAU,CAAC,CAAC;QAExE,IAAI,MAAM,EAAE,CAAC;YACT,IAAI,CAAC,MAAM,EAAE,CAAC;QAClB,CAAC;aAAM,CAAC;YACJ,IAAI,CAAC,OAAO,EAAE,CAAC;QACnB,CAAC;QAED,OAAO,MAAM,CAAC;IAClB,CAAC;IAEO,MAAM;QACV,IAAI,IAAI,CAAC,eAAe,EAAE,CAAC;YACvB,IAAI,CAAC,eAAe,CAAC,QAAQ,GAAG,KAAK,CAAC;YACtC,IAAI,CAAC,cAAc,CAAC,aAAa,EAAE,CAAC;QACxC,CAAC;aAAM,CAAC;YACJ,IAAI,CAAC,aAAa,EAAE,CAAC;QACzB,CAAC;IACL,CAAC;IAEO,OAAO;QACX,IAAI,IAAI,CAAC,eAAe,EAAE,CAAC;YACvB,IAAI,CAAC,eAAe,CAAC,QAAQ,GAAG,IAAI,CAAC;YACrC,IAAI,CAAC,cAAc,CAAC,aAAa,EAAE,CAAC;QACxC,CAAC;aAAM,CAAC;YACJ,IAAI,CAAC,cAAc,EAAE,CAAC;QAC1B,CAAC;IACL,CAAC;IAED;;;OAGG;IACH,aAAa;QACT,IAAI,CAAC,QAAQ,CAAC,eAAe,CAAC,IAAI,CAAC,UAAU,CAAC,aAAa,EAAE,UAAU,CAAC,CAAC;IAC7E,CAAC;IAED;;;OAGG;IACH,cAAc;QACV,IAAI,CAAC,QAAQ,CAAC,YAAY,CAAC,IAAI,CAAC,UAAU,CAAC,aAAa,EAAE,UAAU,EAAE,MAAM,CAAC,CAAC;IAClF,CAAC;IAED;;;;;;OAMG;IACH,sBAAsB,CAAC,KAAkB,EAAE,UAAkB;QACzD,IAAI,KAAK,IAAI,KAAK,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YAC5B,OAAO,KAAK,CAAC,KAAK,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,cAAc,CAAC,sBAAsB,CAAC,IAAI,CAAC,KAAK,EAAE,UAAU,CAAC,CAAC,CAAC;QACrG,CAAC;QAED,OAAO,KAAK,CAAC;IACjB,CAAC;8GA9FQ,gCAAgC,oIAoB7B,oBAAoB;kGApBvB,gCAAgC;;2FAAhC,gCAAgC;kBAJ5C,SAAS;mBAAC;oBACP,UAAU,EAAE,IAAI;oBAChB,QAAQ,EAAE,iCAAiC;iBAC9C;;0BAmBQ,IAAI;;0BACJ,QAAQ;;0BACR,MAAM;2BAAC,oBAAoB;yCAdhC,UAAU;sBADT,KAAK;uBAAC,+BAA+B;gBAKtC,KAAK;sBADJ,KAAK;uBAAC,WAAW","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\n/* eslint-disable @angular-eslint/no-input-rename */\n\nimport { ChangeDetectorRef, Directive, ElementRef, Host, Inject, Input, OnChanges, Optional, Renderer2, SimpleChanges } from '@angular/core';\nimport { NodeEntry } from '@alfresco/js-api';\nimport { EXTENDIBLE_COMPONENT } from '@alfresco/adf-core';\nimport { ContentService } from '../common/services/content.service';\nimport { NodeAllowableOperationSubject } from '../interfaces/node-allowable-operation-subject.interface';\n\n@Directive({\n    standalone: true,\n    selector: '[adf-check-allowable-operation]'\n})\nexport class CheckAllowableOperationDirective implements OnChanges {\n    /**\n     * Node permission to check (create, delete, update, updatePermissions,\n     * !create, !delete, !update, !updatePermissions).\n     */\n    @Input('adf-check-allowable-operation')\n    permission: string = null;\n\n    /** Nodes to check permission for. */\n    @Input('adf-nodes')\n    nodes: NodeEntry[] = [];\n\n    constructor(\n        private elementRef: ElementRef,\n        private renderer: Renderer2,\n        private contentService: ContentService,\n        private changeDetector: ChangeDetectorRef,\n\n        @Host()\n        @Optional()\n        @Inject(EXTENDIBLE_COMPONENT)\n        private parentComponent?: NodeAllowableOperationSubject\n    ) {}\n\n    ngOnChanges(changes: SimpleChanges) {\n        if (changes.nodes && !changes.nodes.firstChange) {\n            this.updateElement();\n        }\n    }\n\n    /**\n     * Updates disabled state for the decorated element\n     *\n     * @returns the new state\n     */\n    updateElement(): boolean {\n        const enable = this.hasAllowableOperations(this.nodes, this.permission);\n\n        if (enable) {\n            this.enable();\n        } else {\n            this.disable();\n        }\n\n        return enable;\n    }\n\n    private enable(): void {\n        if (this.parentComponent) {\n            this.parentComponent.disabled = false;\n            this.changeDetector.detectChanges();\n        } else {\n            this.enableElement();\n        }\n    }\n\n    private disable(): void {\n        if (this.parentComponent) {\n            this.parentComponent.disabled = true;\n            this.changeDetector.detectChanges();\n        } else {\n            this.disableElement();\n        }\n    }\n\n    /**\n     * Enables decorated element\n     *\n     */\n    enableElement(): void {\n        this.renderer.removeAttribute(this.elementRef.nativeElement, 'disabled');\n    }\n\n    /**\n     * Disables decorated element\n     *\n     */\n    disableElement(): void {\n        this.renderer.setAttribute(this.elementRef.nativeElement, 'disabled', 'true');\n    }\n\n    /**\n     * Checks whether all nodes have a particular permission\n     *\n     * @param  nodes Node collection to check\n     * @param  permission Permission to check for each node\n     * @returns `true` if there are allowable operations, otherwise `false`\n     */\n    hasAllowableOperations(nodes: NodeEntry[], permission: string): boolean {\n        if (nodes && nodes.length > 0) {\n            return nodes.every((node) => this.contentService.hasAllowableOperations(node.entry, permission));\n        }\n\n        return false;\n    }\n}\n"]}