@umbraco-cms/backoffice 17.2.1 → 17.3.0-rc

package/dist-cms/packages/documents/documents/collection/item/document-collection-item-card.element.js

@@ -4,24 +4,53 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
-import { css, customElement, html, ifDefined, nothing, property } from '../../../../../external/lit/index.js';
+import { UMB_DOCUMENT_COLLECTION_CONTEXT } from '../document-collection.context-token.js';
+import { UmbDocumentItemDataResolver } from '../../item/document-item-data-resolver.js';
+import { css, customElement, html, ifDefined, nothing, property, repeat, state, when, } from '../../../../../external/lit/index.js';
 import { UmbLitElement } from '../../../../core/lit-element/index.js';
 import { UmbDeselectedEvent, UmbSelectedEvent } from '../../../../core/event/index.js';
-import './document-grid-collection-card.element.js';
+import { UmbEntityContentTypeEntityContext } from '../../../../content/content-type/index.js';
+import { UMB_DOCUMENT_TYPE_ENTITY_TYPE } from '../../../document-types/index.js';
+import { DocumentVariantStateModel } from '../../../../core/backend-api/index.js';
+import { fromCamelCase } from '../../../../core/utils/index.js';
 let UmbDocumentCollectionItemCardElement = class UmbDocumentCollectionItemCardElement extends UmbLitElement {
-    constructor() {
-        super(...arguments);
-        this.selectable = false;
-        this.selected = false;
-        this.selectOnly = false;
-        this.disabled = false;
-    }
     #item;
+    #entityContentTypeContext;
+    #resolver;
     get item() {
         return this.#item;
     }
     set item(value) {
         this.#item = value;
+        this.#resolver.setData(value);
+        const documentTypeUnique = value?.documentType.unique;
+        this.#entityContentTypeContext.setEntityType(documentTypeUnique ? UMB_DOCUMENT_TYPE_ENTITY_TYPE : undefined);
+        this.#entityContentTypeContext.setUnique(documentTypeUnique);
+    }
+    #collectionContext;
+    constructor() {
+        super();
+        this.#entityContentTypeContext = new UmbEntityContentTypeEntityContext(this);
+        this.#resolver = new UmbDocumentItemDataResolver(this);
+        this.selectable = false;
+        this.selected = false;
+        this.selectOnly = false;
+        this.disabled = false;
+        this.consumeContext(UMB_DOCUMENT_COLLECTION_CONTEXT, (collectionContext) => {
+            this.#collectionContext = collectionContext;
+            this.#observeCollectionContext();
+        });
+        this.#resolver.observe(this.#resolver.name, (name) => (this._name = name || ''));
+        this.#resolver.observe(this.#resolver.state, (state) => (this._state = state || ''));
+        this.#resolver.observe(this.#resolver.createDate, (createDate) => (this._createDate = createDate));
+        this.#resolver.observe(this.#resolver.updateDate, (updateDate) => (this._updateDate = updateDate));
+    }
+    #observeCollectionContext() {
+        if (!this.#collectionContext)
+            return;
+        this.observe(this.#collectionContext.userDefinedProperties, (userDefinedProperties) => {
+            this._userDefinedProperties = userDefinedProperties;
+        }, '_observeUserDefinedProperties');
     }
     #onSelected(event) {
         if (!this.item)
@@ -35,30 +64,122 @@ let UmbDocumentCollectionItemCardElement = class UmbDocumentCollectionItemCardEl
         event.stopPropagation();
         this.dispatchEvent(new UmbDeselectedEvent(this.item.unique));
     }
+    #getPropertyValueByAlias(alias) {
+        if (!this.item)
+            return '';
+        switch (alias) {
+            case 'contentTypeAlias':
+                return this.item.documentType.alias;
+            case 'createDate':
+                return this._createDate?.toLocaleString();
+            case 'creator':
+            case 'owner':
+                return this.item.creator;
+            case 'name':
+                return this._name;
+            case 'state':
+                return this._state ? fromCamelCase(this._state) : '';
+            case 'published':
+                return this._state !== DocumentVariantStateModel.DRAFT ? 'True' : 'False';
+            case 'sortOrder':
+                return this.item.sortOrder;
+            case 'updateDate':
+                return this._updateDate?.toLocaleString();
+            case 'updater':
+                return this.item.updater;
+            default: {
+                const culture = this.#resolver.getCulture();
+                const prop = this.item.values.find((x) => x.alias === alias && (!x.culture || x.culture === culture));
+                return prop?.value ?? '';
+            }
+        }
+    }
+    #getStateTagConfig() {
+        if (!this._state)
+            return;
+        switch (this._state) {
+            case DocumentVariantStateModel.PUBLISHED:
+                return { color: 'positive', label: this.localize.term('content_published') };
+            case DocumentVariantStateModel.PUBLISHED_PENDING_CHANGES:
+                return { color: 'warning', label: this.localize.term('content_publishedPendingChanges') };
+            case DocumentVariantStateModel.DRAFT:
+                return { color: 'default', label: this.localize.term('content_unpublished') };
+            case DocumentVariantStateModel.NOT_CREATED:
+                return { color: 'danger', label: this.localize.term('content_notCreated') };
+            default:
+                return { color: 'danger', label: fromCamelCase(this._state) };
+        }
+    }
     render() {
         if (!this.item)
             return nothing;
         return html `
-			<umb-document-grid-collection-card
+			<uui-card-content-node
+				.name=${this._name}
 				href=${ifDefined(this.href)}
-				.item=${this.item}
-				.columns=${this.detailProperties}
 				?selectable=${this.selectable}
 				?select-only=${this.selectOnly}
 				?selected=${this.selected}
 				?disabled=${this.disabled}
 				@selected=${this.#onSelected}
 				@deselected=${this.#onDeselected}>
-				<umb-icon slot="icon" name=${this.item.documentType.icon}></umb-icon>
-			</umb-document-grid-collection-card>
+				${this.#renderIcon()} ${this.#renderState()}
+				<div id="properties">${this.#renderProperties()}</div>
+				<slot name="actions" slot="actions"></slot>
+			</uui-card-content-node>
+		`;
+    }
+    #renderIcon() {
+        if (!this.item)
+            return nothing;
+        return html `<umb-icon slot="icon" name=${this.item.documentType.icon}></umb-icon>`;
+    }
+    #renderState() {
+        const tagConfig = this.#getStateTagConfig();
+        if (!tagConfig)
+            return nothing;
+        return html `<uui-tag slot="tag" id="state" color=${tagConfig.color} look="secondary">${tagConfig.label}</uui-tag>`;
+    }
+    #renderProperties() {
+        if (!this._userDefinedProperties)
+            return;
+        return html `
+			<ul>
+				${repeat(this._userDefinedProperties, (column) => column.alias, (column) => this.#renderProperty(column))}
+			</ul>
+		`;
+    }
+    #renderProperty(column) {
+        const value = this.#getPropertyValueByAlias(column.alias);
+        return html `
+			<li>
+				<span>${this.localize.string(column.header)}:</span>
+				${when(column.nameTemplate, () => html `<umb-ufm-render inline .markdown=${column.nameTemplate} .value=${{ value }}></umb-ufm-render>`, () => html `${value}`)}
+			</li>
 		`;
     }
     static { this.styles = [
         css `
-			umb-document-grid-collection-card {
+			uui-card-content-node {
+				min-width: auto;
 				width: 100%;
 				min-height: 180px;
 			}
+
+			#properties {
+				font-size: var(--uui-type-small-size);
+				line-height: calc(2 * var(--uui-size-3));
+
+				> ul {
+					list-style: none;
+					padding-inline-start: 0px;
+					margin: 0;
+
+					> li > span {
+						font-weight: 700;
+					}
+				}
+			}
 		`,
     ]; }
 };
@@ -81,8 +202,20 @@ __decorate([
     property({ type: String })
 ], UmbDocumentCollectionItemCardElement.prototype, "href", void 0);
 __decorate([
-    property({ type: Array })
-], UmbDocumentCollectionItemCardElement.prototype, "detailProperties", void 0);
+    state()
+], UmbDocumentCollectionItemCardElement.prototype, "_name", void 0);
+__decorate([
+    state()
+], UmbDocumentCollectionItemCardElement.prototype, "_state", void 0);
+__decorate([
+    state()
+], UmbDocumentCollectionItemCardElement.prototype, "_createDate", void 0);
+__decorate([
+    state()
+], UmbDocumentCollectionItemCardElement.prototype, "_updateDate", void 0);
+__decorate([
+    state()
+], UmbDocumentCollectionItemCardElement.prototype, "_userDefinedProperties", void 0);
 UmbDocumentCollectionItemCardElement = __decorate([
     customElement('umb-document-collection-item-card')
 ], UmbDocumentCollectionItemCardElement);

package/dist-cms/packages/documents/documents/collection/views/manifests.js

@@ -3,15 +3,10 @@ import { UMB_COLLECTION_ALIAS_CONDITION } from '../../../../core/collection/inde
 export const manifests = [
     {
         type: 'collectionView',
+        kind: 'card',
         alias: UMB_DOCUMENT_GRID_COLLECTION_VIEW_ALIAS,
         name: 'Document Grid Collection View',
-        element: () => import('./grid/document-grid-collection-view.element.js'),
         weight: 200,
-        meta: {
-            label: 'Grid',
-            icon: 'icon-grid',
-            pathName: 'grid',
-        },
         conditions: [
             {
                 alias: UMB_COLLECTION_ALIAS_CONDITION,

package/dist-cms/packages/documents/documents/components/input-document/input-document.context.js

@@ -12,8 +12,8 @@ export class UmbDocumentPickerInputContext extends UmbPickerInputContext {
         const combinedPickerData = {
             ...pickerData,
         };
-        // transform allowedContentTypes to a pickable filter
-        combinedPickerData.pickableFilter = (item) => this.#pickableFilter(item, args?.allowedContentTypes);
+        // combine internal allowedContentTypes filter with user-supplied pickableFilter
+        combinedPickerData.pickableFilter = this._combinePickableFilters((item) => this.#pickableFilter(item, args?.allowedContentTypes), pickerData?.pickableFilter);
         // set default search data
         if (!pickerData?.search) {
             combinedPickerData.search = {

package/dist-cms/packages/documents/documents/entity-actions/duplicate/duplicate-document.action.js

@@ -1,25 +1,29 @@
 import { UMB_DOCUMENT_ENTITY_TYPE, UMB_DOCUMENT_ROOT_ENTITY_TYPE } from '../../entity.js';
+import { UmbDocumentItemRepository } from '../../item/index.js';
 import { UMB_DUPLICATE_DOCUMENT_MODAL } from './modal/index.js';
 import { UmbDuplicateDocumentRepository } from './repository/index.js';
 import { umbOpenModal } from '../../../../core/modal/index.js';
 import { UMB_ACTION_EVENT_CONTEXT } from '../../../../core/action/index.js';
 import { UmbEntityActionBase, UmbRequestReloadChildrenOfEntityEvent } from '../../../../core/entity-action/index.js';
+import { UmbDocumentTypeDetailRepository, UmbDocumentTypeStructureRepository, } from '../../../document-types/index.js';
 export class UmbDuplicateDocumentEntityAction extends UmbEntityActionBase {
     async execute() {
         if (!this.args.unique)
             throw new Error('Unique is not available');
         if (!this.args.entityType)
             throw new Error('Entity Type is not available');
+        const duplicateRepository = new UmbDuplicateDocumentRepository(this);
+        const selectableFilter = await this.#getSelectableFilterByDocumentUnique(this.args.unique);
         const value = await umbOpenModal(this, UMB_DUPLICATE_DOCUMENT_MODAL, {
             data: {
                 unique: this.args.unique,
                 entityType: this.args.entityType,
+                selectableFilter,
             },
         });
         const destinationUnique = value.destination.unique;
         if (destinationUnique === undefined)
             throw new Error('Destination Unique is not available');
-        const duplicateRepository = new UmbDuplicateDocumentRepository(this);
         const { error } = await duplicateRepository.requestDuplicate({
             unique: this.args.unique,
             destination: { unique: destinationUnique },
@@ -31,6 +35,31 @@ export class UmbDuplicateDocumentEntityAction extends UmbEntityActionBase {
         }
         this.#reloadMenu(destinationUnique);
     }
+    async #getSelectableFilterByDocumentUnique(documentUnique) {
+        // 1. Get the document to find its type
+        const itemRepository = new UmbDocumentItemRepository(this);
+        const { data } = await itemRepository.requestItems([documentUnique]);
+        const item = data?.[0];
+        if (!item)
+            throw new Error('Item is not available');
+        const documentTypeUnique = item.documentType.unique;
+        const structureRepository = new UmbDocumentTypeStructureRepository(this);
+        const typeDetailRepository = new UmbDocumentTypeDetailRepository(this);
+        const [{ data: allowedParents }, { data: documentType }] = await Promise.all([
+            structureRepository.requestAllowedParentsOf(documentTypeUnique),
+            typeDetailRepository.requestByUnique(documentTypeUnique),
+        ]);
+        const isAllowedAtRoot = documentType?.allowedAtRoot ?? false;
+        if (allowedParents) {
+            return (treeItem) => {
+                if (treeItem.unique === null) {
+                    return isAllowedAtRoot;
+                }
+                return allowedParents.some((parent) => parent.unique === treeItem.documentType?.unique);
+            };
+        }
+        return undefined;
+    }
     async #reloadMenu(destinationUnique) {
         const actionEventContext = await this.getContext(UMB_ACTION_EVENT_CONTEXT);
         if (!actionEventContext) {

package/dist-cms/packages/documents/documents/entity-actions/duplicate/modal/duplicate-document-modal.element.js

@@ -26,6 +26,11 @@ let UmbDocumentDuplicateToModalElement = class UmbDocumentDuplicateToModalElemen
         const target = event.target;
         this.updateValue({ includeDescendants: target.checked });
     }
+    #selectableFilter = (item) => {
+        if (!this.data?.selectableFilter)
+            return true;
+        return this.data.selectableFilter(item);
+    };
     render() {
         if (!this.data)
             return nothing;
@@ -37,6 +42,7 @@ let UmbDocumentDuplicateToModalElement = class UmbDocumentDuplicateToModalElemen
 						.props=${{
             expandTreeRoot: true,
             hideTreeItemActions: true,
+            selectableFilter: this.#selectableFilter,
         }}
 						@selection-change=${this.#onTreeSelectionChange}></umb-tree>
 				</uui-box>

package/dist-cms/packages/documents/documents/entity-actions/duplicate/modal/duplicate-document-modal.token.d.ts

@@ -1,6 +1,8 @@
 import type { UmbEntityModel } from '../../../../../core/entity/index.js';
 import { UmbModalToken } from '../../../../../core/modal/index.js';
+import type { UmbDocumentTreeItemModel } from '../../../types.js';
 export interface UmbDuplicateDocumentModalData extends UmbEntityModel {
+    selectableFilter?: (item: UmbDocumentTreeItemModel) => boolean;
 }
 export interface UmbDuplicateDocumentModalValue {
     destination: {

package/dist-cms/packages/documents/documents/entity-actions/move-to/document-move-to.action.d.ts

@@ -0,0 +1,7 @@
+import type { UmbTreeItemModel } from '../../../../core/tree/index.js';
+import { UmbMoveToEntityAction } from '../../../../core/tree/index.js';
+declare class UmbDocumentMoveToEntityAction extends UmbMoveToEntityAction {
+    #private;
+    protected _getPickableFilter(unique: string): Promise<((item: UmbTreeItemModel) => boolean) | undefined>;
+}
+export { UmbDocumentMoveToEntityAction as api };

package/dist-cms/packages/documents/documents/entity-actions/move-to/document-move-to.action.js

@@ -0,0 +1,31 @@
+import { UmbDocumentItemRepository } from '../../item/index.js';
+import { UmbDocumentTypeDetailRepository, UmbDocumentTypeStructureRepository, } from '../../../document-types/index.js';
+import { UmbMoveToEntityAction } from '../../../../core/tree/index.js';
+class UmbDocumentMoveToEntityAction extends UmbMoveToEntityAction {
+    async _getPickableFilter(unique) {
+        const itemRepository = new UmbDocumentItemRepository(this);
+        const { data } = await itemRepository.requestItems([unique]);
+        const item = data?.[0];
+        if (!item)
+            throw new Error('Item is not available');
+        const documentTypeUnique = item.documentType.unique;
+        const structureRepository = new UmbDocumentTypeStructureRepository(this);
+        const typeDetailRepository = new UmbDocumentTypeDetailRepository(this);
+        const [{ data: allowedParents }, { data: documentType }] = await Promise.all([
+            structureRepository.requestAllowedParentsOf(documentTypeUnique),
+            typeDetailRepository.requestByUnique(documentTypeUnique),
+        ]);
+        const isAllowedAtRoot = documentType?.allowedAtRoot ?? false;
+        if (!allowedParents)
+            return undefined;
+        return (treeItem) => this.#isPickable(treeItem, unique, isAllowedAtRoot, allowedParents);
+    }
+    #isPickable(treeItem, unique, isAllowedAtRoot, allowedParents) {
+        if (treeItem.unique === unique)
+            return false;
+        if (treeItem.unique === null)
+            return isAllowedAtRoot;
+        return allowedParents.some((parent) => parent.unique === treeItem.documentType?.unique);
+    }
+}
+export { UmbDocumentMoveToEntityAction as api };

package/dist-cms/packages/documents/documents/entity-actions/move-to/manifests.js

@@ -11,6 +11,7 @@ export const manifests = [
         alias: 'Umb.EntityAction.Document.MoveTo',
         name: 'Move Document Entity Action',
         forEntityTypes: [UMB_DOCUMENT_ENTITY_TYPE],
+        api: () => import('./document-move-to.action.js'),
         meta: {
             treeRepositoryAlias: UMB_DOCUMENT_TREE_REPOSITORY_ALIAS,
             moveRepositoryAlias: UMB_MOVE_DOCUMENT_REPOSITORY_ALIAS,

package/dist-cms/packages/documents/documents/item/repository/document-item.server.request-manager.d.ts

@@ -2,5 +2,6 @@ import type { UmbControllerHost } from '../../../../../libs/controller-api/index
 import { type DocumentItemResponseModel } from '../../../../core/backend-api/index.js';
 import { UmbManagementApiItemDataRequestManager } from '../../../../management-api/index.js';
 export declare class UmbManagementApiDocumentItemDataRequestManager extends UmbManagementApiItemDataRequestManager<DocumentItemResponseModel> {
+    #private;
     constructor(host: UmbControllerHost);
 }

package/dist-cms/packages/documents/documents/item/repository/document-item.server.request-manager.js

@@ -1,12 +1,14 @@
 /* eslint-disable local-rules/no-direct-api-import */
 import { documentItemCache } from './document-item.server.cache.js';
 import { DocumentService } from '../../../../core/backend-api/index.js';
-import { UmbManagementApiItemDataRequestManager } from '../../../../management-api/index.js';
+import { UmbManagementApiItemDataRequestManager, UmbManagementApiInFlightRequestCache, } from '../../../../management-api/index.js';
 export class UmbManagementApiDocumentItemDataRequestManager extends UmbManagementApiItemDataRequestManager {
+    static #inflightRequestCache = new UmbManagementApiInFlightRequestCache();
     constructor(host) {
         super(host, {
             getItems: (ids) => DocumentService.getItemDocument({ query: { id: ids } }),
             dataCache: documentItemCache,
+            inflightRequestCache: UmbManagementApiDocumentItemDataRequestManager.#inflightRequestCache,
             getUniqueMethod: (item) => item.id,
         });
     }

package/dist-cms/packages/documents/documents/publishing/publish/entity-bulk-action/publish.bulk-action.js

@@ -97,6 +97,7 @@ export class UmbDocumentPublishEntityBulkAction extends UmbEntityBulkActionBase
      * If all states are the same, returns that state.
      * If states differ, returns DRAFT (displays as "Unpublished") since mixed states can't be meaningfully represented
      * and DRAFT is more accurate than showing "Not created" (which shouldn't appear since those variants are filtered out).
+     * @param states
      */
     static #determineRepresentativeState(states) {
         if (states.length === 0)

package/dist-cms/packages/documents/documents/publishing/workspace-context/document-publishing.workspace-context.js

@@ -144,8 +144,7 @@ export class UmbDocumentPublishingWorkspaceContext extends UmbContextBase {
         const saveData = await this.#documentWorkspaceContext.constructSaveData(variantIds);
         await this.#documentWorkspaceContext.runMandatoryValidationForSaveData(saveData);
         await this.#documentWorkspaceContext.askServerToValidate(saveData, variantIds);
-        // TODO: Only validate the specified selection.. [NL]
-        return this.#documentWorkspaceContext.validateAndSubmit(async () => {
+        return this.#documentWorkspaceContext.validateVariantsAndSubmit(variantIds, async () => {
             if (!this.#documentWorkspaceContext) {
                 throw new Error('Document workspace context is missing');
             }
@@ -224,7 +223,7 @@ export class UmbDocumentPublishingWorkspaceContext extends UmbContextBase {
             return;
         const notificationContext = await this.getContext(UMB_NOTIFICATION_CONTEXT);
         const localize = new UmbLocalizationController(this);
-        const primaryVariantName = await this.observe(this.#documentWorkspaceContext.name(variantIds[0])).asPromise();
+        const primaryVariantName = this.#documentWorkspaceContext.getName(variantIds[0]) ?? '';
         const waitNotice = notificationContext?.peek('warning', {
             data: {
                 headline: localize.term('publish_publishAll', primaryVariantName),
@@ -241,7 +240,7 @@ export class UmbDocumentPublishingWorkspaceContext extends UmbContextBase {
             });
             // reload the document so all states are updated after the publish operation
             await this.#documentWorkspaceContext.reload();
-            this.#loadAndProcessLastPublished();
+            await this.#loadAndProcessLastPublished();
             // request reload of this entity
             const structureEvent = new UmbRequestReloadStructureForEntityEvent({ entityType, unique });
             this.#eventContext?.dispatchEvent(structureEvent);
@@ -267,6 +266,9 @@ export class UmbDocumentPublishingWorkspaceContext extends UmbContextBase {
             throw new Error('Entity type is missing');
         // TODO: remove meta
         await new UmbUnpublishDocumentEntityAction(this, { unique, entityType, meta: {} }).execute();
+        // Reload workspace data to reflect the unpublished state
+        await this.#documentWorkspaceContext.reload();
+        await this.#loadAndProcessLastPublished();
     }
     async #handleSaveAndPublish() {
         await this.#init;
@@ -302,8 +304,7 @@ export class UmbDocumentPublishingWorkspaceContext extends UmbContextBase {
         const saveData = await this.#documentWorkspaceContext.constructSaveData(variantIds);
         await this.#documentWorkspaceContext.runMandatoryValidationForSaveData(saveData, variantIds);
         await this.#documentWorkspaceContext.askServerToValidate(saveData, variantIds);
-        // TODO: Only validate the specified selection.. [NL]
-        return this.#documentWorkspaceContext.validateAndSubmit(async () => {
+        return this.#documentWorkspaceContext.validateVariantsAndSubmit(variantIds, async () => {
             return this.#performSaveAndPublish(variantIds, saveData);
         }, async (reason) => {
             // If data of the selection is not valid Then just save:
@@ -339,9 +340,14 @@ export class UmbDocumentPublishingWorkspaceContext extends UmbContextBase {
                     message: this.#localize.term('speechBubbles_editContentPublishedHeader'),
                 },
             });
+            // Clear stale published data and pending changes state so the
+            // persistedData observer does not run a comparison against outdated
+            // data during reload, which would briefly show a false-positive
+            // "pending changes" state.
+            this.#clear();
             // reload the document so all states are updated after the publish operation
             await this.#documentWorkspaceContext.reload();
-            this.#loadAndProcessLastPublished();
+            await this.#loadAndProcessLastPublished();
             const event = new UmbRequestReloadStructureForEntityEvent({ unique, entityType });
             this.#eventContext?.dispatchEvent(event);
         }

package/dist-cms/packages/documents/documents/recycle-bin/entity-action/bulk-trash/document-bulk-trash-with-relation.action.d.ts

@@ -0,0 +1,5 @@
+import { UmbBulkTrashWithRelationEntityAction } from '../../../../../relations/relations/index.js';
+export declare class UmbDocumentBulkTrashWithRelationEntityAction extends UmbBulkTrashWithRelationEntityAction {
+    protected _confirmTrash(): Promise<void>;
+}
+export { UmbDocumentBulkTrashWithRelationEntityAction as api };

package/dist-cms/packages/documents/documents/recycle-bin/entity-action/bulk-trash/document-bulk-trash-with-relation.action.js

@@ -0,0 +1,18 @@
+import { UMB_DOCUMENT_CONFIGURATION_CONTEXT } from '../../../global-contexts/index.js';
+import { UMB_BULK_TRASH_WITH_RELATION_CONFIRM_MODAL, UmbBulkTrashWithRelationEntityAction } from '../../../../../relations/relations/index.js';
+import { umbOpenModal } from '../../../../../core/modal/index.js';
+export class UmbDocumentBulkTrashWithRelationEntityAction extends UmbBulkTrashWithRelationEntityAction {
+    async _confirmTrash() {
+        const configContext = await this.getContext(UMB_DOCUMENT_CONFIGURATION_CONTEXT);
+        const config = await configContext?.getDocumentConfiguration();
+        await umbOpenModal(this, UMB_BULK_TRASH_WITH_RELATION_CONFIRM_MODAL, {
+            data: {
+                uniques: this.selection,
+                itemRepositoryAlias: this.args.meta.itemRepositoryAlias,
+                referenceRepositoryAlias: this.args.meta.referenceRepositoryAlias,
+                disableDeleteWhenReferenced: config?.disableDeleteWhenReferenced ?? false,
+            },
+        });
+    }
+}
+export { UmbDocumentBulkTrashWithRelationEntityAction as api };

package/dist-cms/packages/documents/documents/recycle-bin/entity-action/bulk-trash/manifests.js

@@ -13,6 +13,7 @@ export const manifests = [
         kind: UMB_ENTITY_BULK_ACTION_TRASH_WITH_RELATION_KIND,
         alias: 'Umb.EntityBulkAction.Document.Trash',
         name: 'Trash Document Entity Bulk Action',
+        api: () => import('./document-bulk-trash-with-relation.action.js'),
         weight: 10,
         forEntityTypes: [UMB_DOCUMENT_ENTITY_TYPE],
         meta: {

package/dist-cms/packages/documents/documents/recycle-bin/entity-action/manifests.js

@@ -12,6 +12,7 @@ export const manifests = [
         kind: 'trashWithRelation',
         alias: 'Umb.EntityAction.Document.RecycleBin.Trash',
         name: 'Trash Document Entity Action',
+        api: () => import('./trash/document-trash-with-relation.action.js'),
         forEntityTypes: [UMB_DOCUMENT_ENTITY_TYPE],
         meta: {
             itemRepositoryAlias: UMB_DOCUMENT_ITEM_REPOSITORY_ALIAS,

package/dist-cms/packages/documents/documents/recycle-bin/entity-action/trash/document-trash-with-relation.action.d.ts

@@ -0,0 +1,5 @@
+import { UmbTrashWithRelationEntityAction } from '../../../../../relations/relations/index.js';
+export declare class UmbDocumentTrashWithRelationEntityAction extends UmbTrashWithRelationEntityAction {
+    protected _confirmTrash(item: any): Promise<void>;
+}
+export { UmbDocumentTrashWithRelationEntityAction as api };

package/dist-cms/packages/documents/documents/recycle-bin/entity-action/trash/document-trash-with-relation.action.js

@@ -0,0 +1,21 @@
+import { UMB_DOCUMENT_CONFIGURATION_CONTEXT } from '../../../global-contexts/index.js';
+import { UMB_TRASH_WITH_RELATION_CONFIRM_MODAL } from '../../../../../relations/relations/index.js';
+import { umbOpenModal } from '../../../../../core/modal/index.js';
+import { UmbTrashWithRelationEntityAction } from '../../../../../relations/relations/index.js';
+export class UmbDocumentTrashWithRelationEntityAction extends UmbTrashWithRelationEntityAction {
+    async _confirmTrash(item) {
+        const configContext = await this.getContext(UMB_DOCUMENT_CONFIGURATION_CONTEXT);
+        const config = await configContext?.getDocumentConfiguration();
+        await umbOpenModal(this, UMB_TRASH_WITH_RELATION_CONFIRM_MODAL, {
+            data: {
+                unique: item.unique,
+                entityType: item.entityType,
+                itemRepositoryAlias: this.args.meta.itemRepositoryAlias,
+                referenceRepositoryAlias: this.args.meta.referenceRepositoryAlias,
+                itemDataResolver: this.args.meta.itemDataResolver,
+                disableDeleteWhenReferenced: config?.disableDeleteWhenReferenced ?? false,
+            },
+        });
+    }
+}
+export { UmbDocumentTrashWithRelationEntityAction as api };

package/dist-cms/packages/documents/documents/rollback/audit-log-action/manifests.d.ts

@@ -0,0 +1 @@
+export declare const manifests: Array<UmbExtensionManifest>;

package/dist-cms/packages/documents/documents/rollback/audit-log-action/manifests.js

@@ -0,0 +1,26 @@
+import { UMB_DOCUMENT_ENTITY_TYPE, UMB_DOCUMENT_USER_PERMISSION_CONDITION_ALIAS, UMB_USER_PERMISSION_DOCUMENT_ROLLBACK, } from '../../constants.js';
+import { UMB_DOCUMENT_ROLLBACK_REPOSITORY_ALIAS } from '../repository/constants.js';
+import { UMB_DOCUMENT_DETAIL_REPOSITORY_ALIAS } from '../../repository/detail/constants.js';
+import { UMB_ENTITY_IS_NOT_TRASHED_CONDITION_ALIAS } from '../../../../core/recycle-bin/index.js';
+export const manifests = [
+    {
+        type: 'auditLogAction',
+        kind: 'contentRollback',
+        alias: 'Umb.AuditLogAction.Document.Rollback',
+        name: 'Document Audit Log Rollback Action',
+        forEntityTypes: [UMB_DOCUMENT_ENTITY_TYPE],
+        meta: {
+            rollbackRepositoryAlias: UMB_DOCUMENT_ROLLBACK_REPOSITORY_ALIAS,
+            detailRepositoryAlias: UMB_DOCUMENT_DETAIL_REPOSITORY_ALIAS,
+        },
+        conditions: [
+            {
+                alias: UMB_DOCUMENT_USER_PERMISSION_CONDITION_ALIAS,
+                allOf: [UMB_USER_PERMISSION_DOCUMENT_ROLLBACK],
+            },
+            {
+                alias: UMB_ENTITY_IS_NOT_TRASHED_CONDITION_ALIAS,
+            },
+        ],
+    },
+];

package/dist-cms/packages/documents/documents/rollback/constants.d.ts

@@ -1,2 +1,2 @@
-export * from './modal/constants.js';
-export * from './repository/constants.js';
+export { UMB_ROLLBACK_MODAL_ALIAS, UMB_ROLLBACK_MODAL } from './modal/constants.js';
+export { UMB_DOCUMENT_ROLLBACK_REPOSITORY_ALIAS, UMB_ROLLBACK_REPOSITORY_ALIAS } from './repository/constants.js';

package/dist-cms/packages/documents/documents/rollback/constants.js

@@ -1,2 +1,2 @@
-export * from './modal/constants.js';
-export * from './repository/constants.js';
+export { UMB_ROLLBACK_MODAL_ALIAS, UMB_ROLLBACK_MODAL } from './modal/constants.js';
+export { UMB_DOCUMENT_ROLLBACK_REPOSITORY_ALIAS, UMB_ROLLBACK_REPOSITORY_ALIAS } from './repository/constants.js';

package/dist-cms/packages/documents/documents/rollback/entity-action/manifests.js

@@ -1,22 +1,21 @@
-import { UMB_USER_PERMISSION_DOCUMENT_ROLLBACK, UMB_DOCUMENT_ENTITY_TYPE } from '../../constants.js';
+import { UMB_DOCUMENT_ENTITY_TYPE, UMB_DOCUMENT_USER_PERMISSION_CONDITION_ALIAS, UMB_USER_PERMISSION_DOCUMENT_ROLLBACK, } from '../../constants.js';
+import { UMB_DOCUMENT_ROLLBACK_REPOSITORY_ALIAS } from '../repository/constants.js';
+import { UMB_DOCUMENT_DETAIL_REPOSITORY_ALIAS } from '../../repository/detail/constants.js';
 import { UMB_ENTITY_IS_NOT_TRASHED_CONDITION_ALIAS } from '../../../../core/recycle-bin/index.js';
 export const manifests = [
     {
         type: 'entityAction',
-        kind: 'default',
+        kind: 'contentRollback',
         alias: 'Umb.EntityAction.Document.Rollback',
         name: 'Rollback Document Entity Action',
-        weight: 450,
-        api: () => import('./rollback.action.js'),
         forEntityTypes: [UMB_DOCUMENT_ENTITY_TYPE],
         meta: {
-            icon: 'icon-history',
-            label: '#actions_rollback',
-            additionalOptions: true,
+            rollbackRepositoryAlias: UMB_DOCUMENT_ROLLBACK_REPOSITORY_ALIAS,
+            detailRepositoryAlias: UMB_DOCUMENT_DETAIL_REPOSITORY_ALIAS,
         },
         conditions: [
             {
-                alias: 'Umb.Condition.UserPermission.Document',
+                alias: UMB_DOCUMENT_USER_PERMISSION_CONDITION_ALIAS,
                 allOf: [UMB_USER_PERMISSION_DOCUMENT_ROLLBACK],
             },
             {

package/dist-cms/packages/documents/documents/rollback/entity-action/rollback.action.d.ts

@@ -1,4 +1,5 @@
 import { UmbEntityActionBase } from '../../../../core/entity-action/index.js';
+/** @deprecated Use the rollback entity action kind from `@umbraco-cms/backoffice/content` instead. Scheduled for removal in Umbraco 19. */
 export declare class UmbRollbackDocumentEntityAction extends UmbEntityActionBase<never> {
     #private;
     execute(): Promise<void>;