@alfresco/adf-content-services
Version:
Alfresco ADF content services
134 lines • 21.2 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.
*/
import { Injectable } from '@angular/core';
import { MatDialog } from '@angular/material/dialog';
import { CardViewSelectItemModel, CardViewTextItemModel } from '@alfresco/adf-core';
import { of, Subject, zip } from 'rxjs';
import { distinctUntilChanged, map } from 'rxjs/operators';
import { ContentTypeDialogComponent } from '../../content-type/content-type-dialog.component';
import { ContentTypeService } from '../../content-type/content-type.service';
import { PropertyGroupTranslatorService } from './property-groups-translator.service';
import { VersionCompatibilityService } from '../../version-compatibility/version-compatibility.service';
import * as i0 from "@angular/core";
import * as i1 from "../../content-type/content-type.service";
import * as i2 from "@angular/material/dialog";
import * as i3 from "../../version-compatibility/version-compatibility.service";
import * as i4 from "./property-groups-translator.service";
export class ContentTypePropertiesService {
constructor(contentTypeService, dialog, versionCompatibilityService, propertyGroupTranslatorService) {
this.contentTypeService = contentTypeService;
this.dialog = dialog;
this.versionCompatibilityService = versionCompatibilityService;
this.propertyGroupTranslatorService = propertyGroupTranslatorService;
}
getContentTypeCardItem(node) {
if (this.versionCompatibilityService.isVersionSupported('7')) {
return this.contentTypeService.getContentTypeByPrefix(node.nodeType).pipe(map((contentType) => {
const contentTypesOptions$ = this.getContentTypesAsSelectOption(contentType);
const contentTypeCard = this.buildContentTypeSelectCardModel(contentType.entry.id, contentTypesOptions$);
const filteredProperties = this.getContentTypeSpecificProperties(contentType);
const propertiesCard = this.buildCardItemsFromPropertyList(filteredProperties, node.properties);
return [contentTypeCard, ...propertiesCard];
}));
}
else {
return of([this.buildContentTypeTextCardModel(node.nodeType)]);
}
}
buildCardItemsFromPropertyList(properties, currentProperties) {
return properties.map((property) => {
const propertyValue = currentProperties ? currentProperties[property.id] : null;
return this.buildCardItemFromProperty(property, propertyValue);
});
}
buildCardItemFromProperty(property, propertyValue) {
return this.propertyGroupTranslatorService.translateProperty(property, propertyValue, true);
}
getContentTypeSpecificProperties(contentType) {
return contentType.entry.properties.filter((property) => property.id.startsWith(contentType.entry.model.namespacePrefix));
}
buildContentTypeTextCardModel(currentValue) {
const contentTypeCard = new CardViewTextItemModel({
label: 'CORE.METADATA.BASIC.CONTENT_TYPE',
value: currentValue,
key: 'nodeType',
editable: false
});
return contentTypeCard;
}
buildContentTypeSelectCardModel(currentValue, options$) {
const contentTypeCard = new CardViewSelectItemModel({
label: 'CORE.METADATA.BASIC.CONTENT_TYPE',
value: currentValue,
key: 'nodeType',
editable: true,
options$,
displayNoneOption: false
});
return contentTypeCard;
}
getContentTypesAsSelectOption(currentType) {
const childrenTypes$ = this.contentTypeService.getContentTypeChildren(currentType.entry.id);
return zip(childrenTypes$, of(currentType)).pipe(distinctUntilChanged(), map(([contentTypesEntries, currentContentType]) => {
const updatedTypes = this.appendCurrentType(currentContentType, contentTypesEntries);
return updatedTypes.map((contentType) => ({ key: contentType.entry.id, label: contentType.entry.title ?? contentType.entry.id }));
}));
}
appendCurrentType(currentType, contentTypesEntries) {
const resultTypes = [...contentTypesEntries];
const currentTypePresent = contentTypesEntries.find((type) => type.entry.id === currentType.entry.id);
if (!currentTypePresent) {
resultTypes.push(currentType);
}
return resultTypes;
}
openContentTypeDialogConfirm(nodeType) {
const select = new Subject();
select.subscribe({
complete: this.close.bind(this)
});
const data = {
title: 'CORE.METADATA.CONTENT_TYPE.DIALOG.TITLE',
description: 'CORE.METADATA.CONTENT_TYPE.DIALOG.DESCRIPTION',
confirmMessage: 'CORE.METADATA.CONTENT_TYPE.DIALOG.CONFIRM',
select,
nodeType
};
this.openDialog(data, 'adf-content-type-dialog', '600px');
return select;
}
close() {
this.dialog.closeAll();
}
openDialog(data, panelClass, width) {
this.dialog.open(ContentTypeDialogComponent, {
data,
panelClass,
width,
disableClose: true
});
}
static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: ContentTypePropertiesService, deps: [{ token: i1.ContentTypeService }, { token: i2.MatDialog }, { token: i3.VersionCompatibilityService }, { token: i4.PropertyGroupTranslatorService }], target: i0.ɵɵFactoryTarget.Injectable }); }
static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: ContentTypePropertiesService, providedIn: 'root' }); }
}
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: ContentTypePropertiesService, decorators: [{
type: Injectable,
args: [{
providedIn: 'root'
}]
}], ctorParameters: () => [{ type: i1.ContentTypeService }, { type: i2.MatDialog }, { type: i3.VersionCompatibilityService }, { type: i4.PropertyGroupTranslatorService }] });
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"content-type-property.service.js","sourceRoot":"","sources":["../../../../../../../lib/content-services/src/lib/content-metadata/services/content-type-property.service.ts"],"names":[],"mappings":"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","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 { Injectable } from '@angular/core';\nimport { MatDialog } from '@angular/material/dialog';\nimport { CardViewItem, CardViewSelectItemModel, CardViewSelectItemOption, CardViewTextItemModel } from '@alfresco/adf-core';\nimport { Observable, of, Subject, zip } from 'rxjs';\nimport { distinctUntilChanged, map } from 'rxjs/operators';\nimport { ContentTypeDialogComponent } from '../../content-type/content-type-dialog.component';\nimport { ContentTypeDialogComponentData } from '../../content-type/content-type-metadata.interface';\nimport { ContentTypeService } from '../../content-type/content-type.service';\nimport { Node, Property, TypeEntry } from '@alfresco/js-api';\nimport { PropertyGroupTranslatorService } from './property-groups-translator.service';\nimport { VersionCompatibilityService } from '../../version-compatibility/version-compatibility.service';\n\n@Injectable({\n    providedIn: 'root'\n})\nexport class ContentTypePropertiesService {\n    constructor(\n        private contentTypeService: ContentTypeService,\n        private dialog: MatDialog,\n        private versionCompatibilityService: VersionCompatibilityService,\n        private propertyGroupTranslatorService: PropertyGroupTranslatorService\n    ) {}\n\n    getContentTypeCardItem(node: Node): Observable<CardViewItem[]> {\n        if (this.versionCompatibilityService.isVersionSupported('7')) {\n            return this.contentTypeService.getContentTypeByPrefix(node.nodeType).pipe(\n                map((contentType) => {\n                    const contentTypesOptions$ = this.getContentTypesAsSelectOption(contentType);\n                    const contentTypeCard = this.buildContentTypeSelectCardModel(contentType.entry.id, contentTypesOptions$);\n                    const filteredProperties = this.getContentTypeSpecificProperties(contentType);\n                    const propertiesCard = this.buildCardItemsFromPropertyList(filteredProperties, node.properties);\n                    return [contentTypeCard, ...propertiesCard];\n                })\n            );\n        } else {\n            return of([this.buildContentTypeTextCardModel(node.nodeType)]);\n        }\n    }\n\n    buildCardItemsFromPropertyList(properties: Property[], currentProperties: any): CardViewItem[] {\n        return properties.map((property) => {\n            const propertyValue = currentProperties ? currentProperties[property.id] : null;\n            return this.buildCardItemFromProperty(property, propertyValue);\n        });\n    }\n\n    private buildCardItemFromProperty(property: Property, propertyValue: any): CardViewItem {\n        return this.propertyGroupTranslatorService.translateProperty(property, propertyValue, true);\n    }\n\n    private getContentTypeSpecificProperties(contentType: TypeEntry): Property[] {\n        return contentType.entry.properties.filter((property) => property.id.startsWith(contentType.entry.model.namespacePrefix));\n    }\n\n    private buildContentTypeTextCardModel(currentValue: string): CardViewTextItemModel {\n        const contentTypeCard = new CardViewTextItemModel({\n            label: 'CORE.METADATA.BASIC.CONTENT_TYPE',\n            value: currentValue,\n            key: 'nodeType',\n            editable: false\n        });\n\n        return contentTypeCard;\n    }\n\n    private buildContentTypeSelectCardModel(\n        currentValue: string,\n        options$: Observable<CardViewSelectItemOption<string>[]>\n    ): CardViewSelectItemModel<string> {\n        const contentTypeCard = new CardViewSelectItemModel({\n            label: 'CORE.METADATA.BASIC.CONTENT_TYPE',\n            value: currentValue,\n            key: 'nodeType',\n            editable: true,\n            options$,\n            displayNoneOption: false\n        });\n\n        return contentTypeCard;\n    }\n\n    private getContentTypesAsSelectOption(currentType: TypeEntry): Observable<CardViewSelectItemOption<string>[]> {\n        const childrenTypes$ = this.contentTypeService.getContentTypeChildren(currentType.entry.id);\n        return zip(childrenTypes$, of(currentType)).pipe(\n            distinctUntilChanged(),\n            map(([contentTypesEntries, currentContentType]) => {\n                const updatedTypes = this.appendCurrentType(currentContentType, contentTypesEntries);\n                return updatedTypes.map((contentType) => ({ key: contentType.entry.id, label: contentType.entry.title ?? contentType.entry.id }));\n            })\n        );\n    }\n\n    private appendCurrentType(currentType: TypeEntry, contentTypesEntries: TypeEntry[]): TypeEntry[] {\n        const resultTypes = [...contentTypesEntries];\n        const currentTypePresent = contentTypesEntries.find((type) => type.entry.id === currentType.entry.id);\n        if (!currentTypePresent) {\n            resultTypes.push(currentType);\n        }\n        return resultTypes;\n    }\n\n    openContentTypeDialogConfirm(nodeType): Observable<boolean> {\n        const select = new Subject<boolean>();\n        select.subscribe({\n            complete: this.close.bind(this)\n        });\n\n        const data: ContentTypeDialogComponentData = {\n            title: 'CORE.METADATA.CONTENT_TYPE.DIALOG.TITLE',\n            description: 'CORE.METADATA.CONTENT_TYPE.DIALOG.DESCRIPTION',\n            confirmMessage: 'CORE.METADATA.CONTENT_TYPE.DIALOG.CONFIRM',\n            select,\n            nodeType\n        };\n\n        this.openDialog(data, 'adf-content-type-dialog', '600px');\n        return select;\n    }\n\n    close() {\n        this.dialog.closeAll();\n    }\n\n    private openDialog(data: ContentTypeDialogComponentData, panelClass: string, width: string) {\n        this.dialog.open(ContentTypeDialogComponent, {\n            data,\n            panelClass,\n            width,\n            disableClose: true\n        });\n    }\n}\n"]}