@umbraco-engage/backoffice 17.0.0-rc1

package/dist/personalization/components/grouped-item/grouped-item-list-editor-base.element.js

@@ -0,0 +1,164 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    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, html, property, state, when, } from "@umbraco-cms/backoffice/external/lit";
+import { UmbLitElement } from "@umbraco-cms/backoffice/lit-element";
+import { UmbSorterController } from "@umbraco-cms/backoffice/sorter";
+import { umbConfirmModal, umbOpenModal } from "@umbraco-cms/backoffice/modal";
+export class UeGroupedItemListEditorBaseElement extends UmbLitElement {
+    #properties;
+    #sorter;
+    constructor(properties, contextToken) {
+        super();
+        this.#properties = properties;
+        this.consumeContext(contextToken, (context) => {
+            if (!context)
+                return;
+            this.workspaceContext = context;
+            this.observe(this.workspaceContext.current, (current) => {
+                this.data = current?.items;
+                this.#setSorter();
+            });
+        });
+    }
+    #setSorter() {
+        if (!this.sortable)
+            return;
+        this.#sorter =
+            this.#sorter ??
+                new UmbSorterController(this, {
+                    getUniqueOfElement: (element) => {
+                        return element.id;
+                    },
+                    getUniqueOfModel: (modelEntry) => {
+                        return modelEntry;
+                    },
+                    identifier: "Ue.SorterIdentifier.GroupedItem",
+                    itemSelector: "ue-group-box",
+                    containerSelector: "#items",
+                    onChange: ({ model }) => {
+                        this.workspaceContext?.sortItems(model);
+                    },
+                    onEnd: async () => {
+                        await this.workspaceContext?.requestSubmit();
+                    },
+                });
+        this.#sorter?.setModel(this.data?.map((x) => x.unique) ?? []);
+    }
+    async #onEdit(unique, position) {
+        if (!this.workspaceContext)
+            return;
+        let current;
+        if (!unique) {
+            current = this.workspaceContext.createItem();
+        }
+        else {
+            current = this.workspaceContext
+                .getCurrent()
+                ?.items.find((x) => x.unique === unique);
+        }
+        const value = await umbOpenModal(this, (await import("../../modal/index.js")).ENGAGE_GROUPED_ITEM_EDIT_ITEM_MODAL, {
+            data: {
+                current,
+                properties: this.#properties,
+                headline: (unique ? this.editLabel : this.addLabel) ?? "",
+            },
+            modal: {
+                size: "medium",
+            },
+        }).catch(() => { });
+        if (!value)
+            return;
+        this.workspaceContext.setItem(value, position);
+        await this.workspaceContext.requestSubmit();
+    }
+    async #onAdd() {
+        await this.#onEdit();
+    }
+    async #onAddInline(pos) {
+        await this.#onEdit(undefined, pos);
+    }
+    async #onDelete(unique) {
+        await umbConfirmModal(this, {
+            headline: this.localize.term("actions_delete"),
+            content: this.localize.term("engage_deleteItemsDescription", 1),
+            color: "danger",
+            confirmLabel: this.localize.term("actions_delete"),
+        });
+        await this.workspaceContext?.deleteItem(unique);
+    }
+    #renderItems() {
+        return this.data?.map((p, idx) => html `${when(this.sortable && this.data?.length && idx > 0, () => html `<uui-button-inline-create
+                @click=${() => this.#onAddInline(idx)}
+                label="Create Item"
+              ></uui-button-inline-create>`)}<ue-group-box
+            style="${`--engage-bar-color: ${p.color?.value}`}"
+            id=${p.unique}
+            .name=${p.title}
+            .description=${p.description}
+            .iconUrl=${p.iconUrl}
+            ><uui-action-bar slot="actions">
+              <uui-button
+                label=${this.editLabel ?? "edit"}
+                @click=${() => this.#onEdit(p.unique)}
+              >
+                <uui-icon name="edit"></uui-icon>
+              </uui-button>
+              <uui-button
+                label="delete"
+                @click=${() => this.#onDelete(p.unique)}
+              >
+                <uui-icon name="delete"></uui-icon>
+              </uui-button> </uui-action-bar
+          ></ue-group-box>`);
+    }
+    render() {
+        return html `<div id="items">${this.#renderItems()}</div>
+      <uui-button
+        @click=${this.#onAdd}
+        look="placeholder"
+        .label=${this.addLabel ?? ""}
+      ></uui-button>`;
+    }
+    static { this.styles = css `
+    :host {
+      --engage-groupbox-icon-size: var(--uui-size-20);
+    }
+
+    ue-group-box {
+      width: 100%;
+    }
+
+    #items > ue-group-box:not(:first-of-type) {
+      margin-top: var(--uui-size-layout-1);
+    }
+
+    :host([sortable]) #items > ue-group-box {
+      margin: var(--uui-size-space-4) 0;
+    }
+
+    :host([sortable]) #items {
+      > ue-group-box:first-child {
+        margin-top: 0;
+      }
+    }
+
+    :host([sortable]) #items > ue-group-box:last-child {
+      margin-bottom: 0;
+    }
+
+    uui-button[look="placeholder"] {
+      width: 100%;
+      margin-top: var(--uui-size-layout-1);
+    }
+  `; }
+}
+__decorate([
+    property({ type: Boolean, reflect: true })
+], UeGroupedItemListEditorBaseElement.prototype, "sortable", void 0);
+__decorate([
+    state()
+], UeGroupedItemListEditorBaseElement.prototype, "data", void 0);

package/dist/personalization/components/grouped-item/grouped-item-workspace-editor-base.element.d.ts

@@ -0,0 +1,23 @@
+import type { UeGroupedItemWorkspaceContext } from "../../context/index.js";
+import { UmbLitElement } from "@umbraco-cms/backoffice/lit-element";
+import type { IRoute } from "@umbraco-cms/backoffice/router";
+import type { UmbSubmittableWorkspaceContext } from "@umbraco-cms/backoffice/workspace";
+import type { UmbContextToken } from "@umbraco-cms/backoffice/context-api";
+import { type UeGroupedItemDetailModel, type UePropertyConfigData } from "../../../core/index.js";
+export declare abstract class UeGroupedItemWorkspaceEditorBaseElement<EntityModel extends UeGroupedItemDetailModel> extends UmbLitElement {
+    #private;
+    properties?: UePropertyConfigData<EntityModel>;
+    advancedProperties?: UePropertyConfigData<EntityModel>;
+    private _data?;
+    abstract headline: string;
+    abstract addGroupLabel: string;
+    abstract editModalHeadline?: string;
+    abstract itemLabel: string;
+    abstract icon: string;
+    abstract personalizationSection: string;
+    abstract routes: Array<IRoute>;
+    constructor(contextToken?: UmbContextToken<UmbSubmittableWorkspaceContext, UeGroupedItemWorkspaceContext<EntityModel, any>>);
+    load(unique: string): void;
+    render(): import("lit-html").TemplateResult<1>;
+    static styles: import("lit").CSSResult[];
+}

package/dist/personalization/components/grouped-item/grouped-item-workspace-editor-base.element.js

@@ -0,0 +1,146 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    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 { ENGAGE_CUSTOMER_JOURNEY_ENTITY_TYPE } from "../../journeys/constants.js";
+import { css, html, state } from "@umbraco-cms/backoffice/external/lit";
+import { UmbLitElement } from "@umbraco-cms/backoffice/lit-element";
+import { umbOpenModal } from "@umbraco-cms/backoffice/modal";
+import { ENGAGE_GROUPED_ITEM_EDIT_DETAIL_MODAL } from "../../index.js";
+export class UeGroupedItemWorkspaceEditorBaseElement extends UmbLitElement {
+    #workspaceContext;
+    constructor(contextToken) {
+        super();
+        if (!contextToken)
+            throw new Error("contextToken is missing");
+        this.consumeContext(contextToken, (context) => {
+            if (!context)
+                return;
+            this.#workspaceContext = context;
+            this.observe(context.data, (data) => (this._data = data));
+            this.observe(context.properties, (properties) => {
+                this.properties = properties;
+            });
+            this.observe(context.advancedProperties, (advancedProperties) => {
+                this.advancedProperties = advancedProperties;
+            });
+        });
+    }
+    load(unique) {
+        this.#workspaceContext?.load(unique);
+    }
+    #onEdit(unique) {
+        this.#workspaceContext?.setPath(unique);
+    }
+    #renderSidebar() {
+        return html `<uui-box slot="sidebar">
+      <div slot="headline">
+        <uui-icon name=${this.icon}></uui-icon>
+        ${this.headline}
+      </div>
+      ${this.#renderTree()}
+    </uui-box>`;
+    }
+    async #onAddGroup() {
+        if (!this.#workspaceContext)
+            return;
+        const value = await umbOpenModal(this, ENGAGE_GROUPED_ITEM_EDIT_DETAIL_MODAL, {
+            data: {
+                current: await this.#workspaceContext.createGroup(),
+                properties: this.properties,
+                advancedProperties: this.advancedProperties,
+                headline: this.addGroupLabel,
+            },
+            modal: {
+                size: "medium",
+            },
+        }).catch(() => { });
+        if (!value)
+            return;
+        this.#workspaceContext.setCurrent(value);
+        await this.#workspaceContext.requestSubmit();
+    }
+    //TODO: adding "no-display" class as a hack to hide the icon since there's no config for uui-ref-node to hide the default icon.
+    #renderTree() {
+        return html `<uui-ref-list
+        >${this._data?.map((group) => html `<uui-ref-node @open=${() => this.#onEdit(group.unique)}
+              ><uui-icon
+                slot="icon"
+                name="icon-users"
+                class="no-display"
+              ></uui-icon>
+              <div slot="name">
+                <span>${group.title}</span>
+                <small>${group.description ?? ""}</small>
+              </div>
+              <div slot="detail">
+                ${group.items?.length} ${this.itemLabel.toLowerCase()}
+              </div>
+
+              <ue-entity-actions-bundle
+                .entityType=${ENGAGE_CUSTOMER_JOURNEY_ENTITY_TYPE}
+                .unique=${group.unique}
+                .label=${this.localize.term("actions_viewActionsFor", [
+            group.title,
+        ])}
+              >
+              </ue-entity-actions-bundle>
+            </uui-ref-node>`)}</uui-ref-list
+      ><uui-button
+        look="placeholder"
+        @click=${() => this.#onAddGroup()}
+        .label=${this.addGroupLabel}
+      ></uui-button>`;
+    }
+    render() {
+        return html `<ue-sidebar-layout>
+      ${this.#renderSidebar()}
+      <umb-router-slot .routes=${this.routes}></umb-router-slot>
+    </ue-sidebar-layout>`;
+    }
+    static { this.styles = [
+        css `
+      :host {
+        --sidebar-layout-maxwidth: 1400px;
+        --sidebar-layout-margin: 0 auto;
+      }
+
+      uui-box {
+        width: 100%;
+      }
+
+      uui-icon {
+        margin-right: 6px;
+      }
+
+      uui-ref-node {
+        --uui-size-2: 0;
+      }
+
+      uui-button[look="placeholder"] {
+        margin-top: var(--uui-size-1);
+        width: 100%;
+      }
+
+      ue-entity-actions-bundle,
+      uui-action-bar {
+        --uui-size-2: 6px;
+        order: 2;
+      }
+
+      .no-display {
+        display: none;
+      }
+
+      [slot="name"] span {
+        font-weight: bold;
+        display: block;
+      }
+    `,
+    ]; }
+}
+__decorate([
+    state()
+], UeGroupedItemWorkspaceEditorBaseElement.prototype, "_data", void 0);

package/dist/personalization/components/grouped-item/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./grouped-item-detail-editor-base.element.js";
+export * from "./grouped-item-list-editor-base.element.js";
+export * from "./grouped-item-workspace-editor-base.element.js";

package/dist/personalization/components/grouped-item/index.js

@@ -0,0 +1,3 @@
+export * from "./grouped-item-detail-editor-base.element.js";
+export * from "./grouped-item-list-editor-base.element.js";
+export * from "./grouped-item-workspace-editor-base.element.js";

package/dist/personalization/components/grouped-scoring/collection/group-collection-base.repository.d.ts

@@ -0,0 +1,25 @@
+import type { UmbControllerHost } from "@umbraco-cms/backoffice/controller-api";
+import { UmbControllerBase } from "@umbraco-cms/backoffice/class-api";
+import type { UmbCollectionDataSource, UmbCollectionRepository } from "@umbraco-cms/backoffice/collection";
+import { UmbContextToken } from "@umbraco-cms/backoffice/context-api";
+import { UmbItemStoreBase } from "@umbraco-cms/backoffice/store";
+import { UeEntityBase } from "../../../../core/index.js";
+export interface UeGroupScoringRepositoryArgs<CollectionModel extends UeEntityBase, ItemModel extends UeEntityBase> {
+    dataSource: UeCollectionDataSourceConstructor<UmbCollectionDataSource<CollectionModel>>;
+    storeContextToken: UmbContextToken<UmbItemStoreBase<ItemModel>>;
+    mapFn: (item: CollectionModel) => ItemModel;
+}
+export interface UeCollectionDataSourceConstructor<UmbCollectionDataSourceType extends UmbCollectionDataSource<UeEntityBase> = UmbCollectionDataSource<UeEntityBase>> {
+    new (host: UmbControllerHost): UmbCollectionDataSourceType;
+}
+export declare abstract class UeGroupCollectionBaseRepository<CollectionModel extends UeEntityBase, ItemModel extends UeEntityBase> extends UmbControllerBase implements UmbCollectionRepository {
+    #private;
+    protected dataSource: UmbCollectionDataSource<CollectionModel>;
+    protected itemStore?: UmbItemStoreBase<ItemModel>;
+    constructor(host: UmbControllerHost, args: UeGroupScoringRepositoryArgs<CollectionModel, ItemModel>);
+    requestCollection(): Promise<{
+        data: import("@umbraco-cms/backoffice/repository").UmbPagedModel<CollectionModel> | undefined;
+        error: Error | import("@umbraco-cms/backoffice/resources").UmbApiError | import("@umbraco-cms/backoffice/resources").UmbCancelError | import("@umbraco-cms/backoffice/resources").UmbError | undefined;
+        asObservable: () => import("rxjs").Observable<ItemModel[]>;
+    }>;
+}

package/dist/personalization/components/grouped-scoring/collection/group-collection-base.repository.js

@@ -0,0 +1,24 @@
+import { UmbControllerBase } from "@umbraco-cms/backoffice/class-api";
+export class UeGroupCollectionBaseRepository extends UmbControllerBase {
+    #init;
+    #mapFn;
+    constructor(host, args) {
+        super(host);
+        this.dataSource = new args.dataSource(host);
+        this.#mapFn = args.mapFn;
+        this.#init = this.consumeContext(args.storeContextToken, async (context) => {
+            if (!context)
+                return;
+            this.itemStore = context;
+        }).asPromise({ preventTimeout: true });
+    }
+    async requestCollection() {
+        await this.#init;
+        const { data, error } = await this.dataSource.getCollection({});
+        if (data) {
+            this.itemStore?.appendItems(data.items.map((item) => ({ ...item, ...this.#mapFn(item) })));
+        }
+        const uniques = data?.items.map((item) => item.unique) ?? [];
+        return { data, error, asObservable: () => this.itemStore.items(uniques) };
+    }
+}

package/dist/personalization/components/grouped-scoring/collection/group-collection-base.server.data-source.d.ts

@@ -0,0 +1,24 @@
+import type { UmbCollectionDataSource } from "@umbraco-cms/backoffice/collection";
+import { UmbControllerBase } from "@umbraco-cms/backoffice/class-api";
+import type { UmbControllerHost } from "@umbraco-cms/backoffice/controller-api";
+import { UeEntityBase } from "../../../../core/index.js";
+export interface UeGroupCollectionServerDataSourceArgs<DtoModel> {
+    entityType: string;
+    getter: () => Promise<{
+        data: Array<DtoModel>;
+    }>;
+}
+export declare abstract class UeGroupCollectionServerDataSourceBase<DtoModel, CollectionModel extends UeEntityBase & DtoModel> extends UmbControllerBase implements UmbCollectionDataSource<CollectionModel> {
+    #private;
+    constructor(host: UmbControllerHost, args: UeGroupCollectionServerDataSourceArgs<DtoModel>);
+    getCollection(): Promise<{
+        error: import("@umbraco-cms/backoffice/resources").UmbApiError | import("@umbraco-cms/backoffice/resources").UmbCancelError | undefined;
+        data?: undefined;
+    } | {
+        data: {
+            items: Array<CollectionModel>;
+            total: number;
+        };
+        error?: undefined;
+    }>;
+}

package/dist/personalization/components/grouped-scoring/collection/group-collection-base.server.data-source.js

@@ -0,0 +1,26 @@
+import { tryExecute } from "@umbraco-cms/backoffice/resources";
+import { UmbControllerBase } from "@umbraco-cms/backoffice/class-api";
+export class UeGroupCollectionServerDataSourceBase extends UmbControllerBase {
+    #entityType;
+    #getter;
+    constructor(host, args) {
+        super(host);
+        this.#entityType = args.entityType;
+        this.#getter = args.getter;
+    }
+    async getCollection() {
+        const { data, error } = await tryExecute(this._host, this.#getter());
+        if (!data || error) {
+            return { error };
+        }
+        return {
+            data: {
+                items: data.map((d) => ({
+                    ...d,
+                    entityType: this.#entityType,
+                })),
+                total: data.length,
+            },
+        };
+    }
+}

package/dist/personalization/components/grouped-scoring/collection/group-table-collection-view-base.element.d.ts

@@ -0,0 +1,12 @@
+import { UmbTableItem } from "@umbraco-cms/backoffice/components";
+import { UeCollectionTableBaseElement } from "../../../../core/index.js";
+import { UeGroupDetailModel } from "../../index.js";
+export declare abstract class UeGroupCollectionTableViewBaseElement<CollectionModel extends UeGroupDetailModel> extends UeCollectionTableBaseElement<CollectionModel> {
+    constructor(args: {
+        entityType: string;
+    });
+    abstract appendColumns(): void;
+    abstract appendData(item: UmbTableItem, g: CollectionModel): void;
+    createTableColumns(): void;
+    createTableItems(result: Array<CollectionModel>): void;
+}

package/dist/personalization/components/grouped-scoring/collection/group-table-collection-view-base.element.js

@@ -0,0 +1,47 @@
+import { html } from "@umbraco-cms/backoffice/external/lit";
+import { UeCollectionTableBaseElement } from "../../../../core/index.js";
+export class UeGroupCollectionTableViewBaseElement extends UeCollectionTableBaseElement {
+    constructor(args) {
+        super({ entityType: args.entityType });
+    }
+    createTableColumns() {
+        this.tableColumns = [
+            {
+                alias: "groupName",
+                name: this.localize.term("engage_groupName"),
+                elementName: "ue-table-name-column-layout",
+            },
+            {
+                alias: "description",
+                width: "60%",
+                name: this.localize.term("engage_property_description"),
+            },
+        ];
+        this.appendColumns();
+    }
+    createTableItems(result) {
+        this.tableItems = result.map((g) => {
+            const item = {
+                id: g.unique,
+                data: [
+                    {
+                        columnAlias: "groupName",
+                        value: {
+                            name: g.name,
+                            unique: g.unique,
+                            modalPath: this.modalPath,
+                        },
+                    },
+                    {
+                        columnAlias: "description",
+                        value: html `<pre style="font-family: unset; white-space: pre-line">
+${g.description}</pre
+            >`,
+                    },
+                ],
+            };
+            this.appendData(item, g);
+            return item;
+        });
+    }
+}

package/dist/personalization/components/grouped-scoring/collection/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./group-collection-base.repository.js";
+export * from "./group-collection-base.server.data-source.js";
+export * from "./group-table-collection-view-base.element.js";

package/dist/personalization/components/grouped-scoring/collection/index.js

@@ -0,0 +1,3 @@
+export * from "./group-collection-base.repository.js";
+export * from "./group-collection-base.server.data-source.js";
+export * from "./group-table-collection-view-base.element.js";

package/dist/personalization/components/grouped-scoring/entities.d.ts

@@ -0,0 +1,25 @@
+import { UeEntityBase } from "../../../core/index.js";
+export interface UeGroupDetailModel extends UeEntityBase {
+    id: number;
+    name?: string | null | undefined;
+    description?: string | null | undefined;
+    created?: string | null;
+    createdByUmbracoUserKey?: string | null;
+    updated?: string | null;
+    updatedByUmbracoUserKey?: string | null;
+    invalid: boolean;
+    customerJourneyScoring: Array<UeGroupJourneyScoringModel>;
+    personaScoring: Array<UeGroupPersonaScoringModel>;
+}
+export interface UeGroupJourneyScoringModel extends UeScoringModel {
+    customerJourneyStepId: number;
+}
+export interface UeGroupPersonaScoringModel extends UeScoringModel {
+    personaId: number;
+}
+export interface UeScoringModel {
+    id: number;
+    unique: string;
+    score: number;
+    groupId: number;
+}

package/dist/personalization/components/grouped-scoring/entities.js

@@ -0,0 +1 @@
+export {};

package/dist/personalization/components/grouped-scoring/group-detail-server.data-source.d.ts

@@ -0,0 +1,54 @@
+import type { UmbControllerHost } from "@umbraco-cms/backoffice/controller-api";
+import type { UmbDetailDataSource } from "@umbraco-cms/backoffice/repository";
+import { UeGroupDetailModel } from "./entities.js";
+export interface UeGroupDetailServerDataSourceBaseArgs<DetailModel, DtoModel> {
+    entityType: string;
+    toDtoFn: (item: DetailModel) => DtoModel;
+    fromDtoFn: (dto: DtoModel) => DetailModel;
+    update: (arg: {
+        body: DtoModel;
+    }) => Promise<{
+        data: DtoModel;
+    }>;
+    read: (arg: {
+        query: {
+            id: string;
+        };
+    }) => Promise<{
+        data: DtoModel;
+    }>;
+    delete: (arg: {
+        query: {
+            id: string;
+        };
+    }) => Promise<unknown>;
+}
+export declare abstract class UeGroupDetailServerDataSourceBase<DetailModel extends UeGroupDetailModel, DtoModel> implements UmbDetailDataSource<DetailModel> {
+    #private;
+    constructor(host: UmbControllerHost, args: UeGroupDetailServerDataSourceBaseArgs<DetailModel, DtoModel>);
+    createScaffold(preset?: Partial<DetailModel>): Promise<{
+        data: DetailModel;
+    }>;
+    create(group: DetailModel): Promise<{
+        data: DetailModel;
+        error?: undefined;
+    } | {
+        error: import("@umbraco-cms/backoffice/resources").UmbApiError | import("@umbraco-cms/backoffice/resources").UmbCancelError | undefined;
+        data?: undefined;
+    }>;
+    update(group: DetailModel): Promise<{
+        data: DetailModel;
+        error?: undefined;
+    } | {
+        error: import("@umbraco-cms/backoffice/resources").UmbApiError | import("@umbraco-cms/backoffice/resources").UmbCancelError | undefined;
+        data?: undefined;
+    }>;
+    delete(id: string): Promise<import("@umbraco-cms/backoffice/resources").UmbApiWithErrorResponse>;
+    read(id: string): Promise<{
+        error: import("@umbraco-cms/backoffice/resources").UmbApiError | import("@umbraco-cms/backoffice/resources").UmbCancelError | undefined;
+        data?: undefined;
+    } | {
+        data: DetailModel;
+        error?: undefined;
+    }>;
+}

package/dist/personalization/components/grouped-scoring/group-detail-server.data-source.js

@@ -0,0 +1,52 @@
+import { tryExecute } from "@umbraco-cms/backoffice/resources";
+import { UmbId } from "@umbraco-cms/backoffice/id";
+export class UeGroupDetailServerDataSourceBase {
+    #host;
+    #args;
+    constructor(host, args) {
+        this.#host = host;
+        this.#args = args;
+    }
+    async createScaffold(preset) {
+        const data = {
+            entityType: this.#args.entityType,
+            unique: UmbId.new(),
+            name: "",
+            description: "",
+            id: 0,
+            invalid: false,
+            ...preset,
+        };
+        return { data };
+    }
+    async create(group) {
+        return await this.update(group);
+    }
+    async update(group) {
+        if (!group)
+            throw new Error("Group data is missing");
+        const { data, error } = await tryExecute(this.#host, this.#args.update({ body: this.#args.toDtoFn(group) }));
+        if (data) {
+            return { data: this.#args.fromDtoFn(data) };
+        }
+        return { error };
+    }
+    async delete(id) {
+        if (!id)
+            throw new Error("Group ID is missing");
+        return tryExecute(this.#host, this.#args.delete({
+            query: { id },
+        }));
+    }
+    async read(id) {
+        if (!id)
+            throw new Error("Group ID is missing");
+        const { data, error } = await tryExecute(this.#host, this.#args.read({
+            query: { id },
+        }));
+        if (error || !data) {
+            return { error };
+        }
+        return { data: this.#args.fromDtoFn(data) };
+    }
+}