@talxis/base-controls 1.2604.2 → 1.2605.2-alpha

package/dist/components/TaskGrid/extensions/dataverse/DataverseTaskStrategy.d.ts

@@ -0,0 +1,122 @@
+/// <reference types="@types/powerapps-component-framework" />
+/// <reference types="@types/xrm" />
+import { IRecord, IRawRecord, IAvailableColumnOptions, IAvailableRelatedColumn, IRecordSaveOperationResult, IColumn } from "@talxis/client-libraries";
+import { ITaskDataProviderStrategy, ITaskDataProvider, IDeleteTasksResult, IEditTasksResult } from "../../providers";
+interface IFormParameters {
+    pageInput: Xrm.Navigation.PageInputEntityRecord;
+    navigationOptions: Xrm.Navigation.NavigationOptions;
+}
+/** Constructor parameters for {@link DataverseTaskStrategy}. */
+export interface IDataverseTaskStrategyParams {
+    /** FetchXML used to load tasks. May contain Liquid template variables (e.g. `{{ projectId }}`). */
+    fetchXml: string;
+    /** When `true`, new tasks are created inline in the grid row without opening a form dialog. Defaults to `true`. */
+    isInlineCreateEnabled?: boolean;
+    /** When `false`, the edit form is opened in read-only mode. Defaults to `true`. */
+    isEditingEnabled?: boolean;
+    /** When `true`, deleting a task will also delete its child tasks. Defaults to `false`. */
+    isCascadeDeleteEnabled?: boolean;
+    /** When `true`, deleting tasks with children is enabled. Defaults to `false`. */
+    isDeletingTasksWithChildrenEnabled?: boolean;
+    /** Form ID to open when editing a single existing task. */
+    editFormId?: string;
+    /** Form ID to open when creating a new task via dialog (non-inline). */
+    createFormId?: string;
+    /** Form ID to open when bulk-editing multiple selected tasks. */
+    bulkEditFormId?: string;
+    /** Project record reference. When provided, new tasks are pre-linked to this project. */
+    projectReference?: ComponentFramework.EntityReference;
+    /** When set, the task hierarchy is rooted at this task ID. */
+    rootTaskId?: string;
+    /**
+     * Optional hook to intercept and override the `Xrm.Navigation.navigateTo` parameters for
+     * any form operation (`create`, `edit`, `bulkEdit`, `open`).
+     * Return the modified `pageInput` and `navigationOptions` to customize the dialog.
+     */
+    formStrategy?: {
+        onGetFormParameters?: (operation: 'create' | 'edit' | 'bulkEdit' | 'open', defaultParameters: IFormParameters) => IFormParameters;
+    };
+}
+/** Extends {@link ITaskDataProviderStrategy} with a Dataverse-specific accessor for the project reference. */
+export interface IDataverseTaskStrategy extends ITaskDataProviderStrategy {
+    /** Returns the resolved project entity reference, or `null` if no project was provided at construction time. */
+    getProjectReference(): ComponentFramework.EntityReference | null;
+}
+/**
+ * Ready-to-use {@link ITaskDataProviderStrategy} implementation for the Dataverse / Talxis platform.
+ *
+ * Handles all task CRUD operations, drag-and-drop reordering (via LexoRank), template-based creation,
+ * and lookup-many column rendering — all backed by the Xrm WebApi and FetchXML.
+ *
+ * Normally instantiated automatically by {@link DataverseTaskGridDescriptor}. Construct directly only
+ * when you need to pass a custom `formStrategy` or override specific behaviour.
+ */
+export declare class DataverseTaskStrategy implements IDataverseTaskStrategy {
+    private _fetchXml;
+    private _entitySetName;
+    private _entityName;
+    private _projectReference?;
+    private _projectMetadata?;
+    private _rootTaskId?;
+    private _taskTree;
+    private _provider;
+    private _editFormId?;
+    private _createFormId?;
+    private _bulkEditFormId?;
+    private _fetchXmlDataProvider;
+    private _isInlineCreateEnabled;
+    private _isEditingEnabled;
+    private _isDeletingTasksWithChildrenEnabled;
+    private _isCascadeDeleteEnabled;
+    private _lookupManyColumns;
+    private _lookupManyHandlers;
+    private _getFormParameters;
+    /** @param params — see {@link IDataverseTaskStrategyParams} for full documentation of each option. */
+    constructor(params: IDataverseTaskStrategyParams);
+    onGetRawRecords(ids: string[], select?: string): Promise<IRawRecord[]>;
+    /** Returns the project entity reference resolved during `onInitialize`, or `null` when none was provided. */
+    getProjectReference(): ComponentFramework.EntityReference | null;
+    private _harmonizeLookupManyData;
+    private _convertLookupManyToEntityReference;
+    private _getRawRecordsByIds;
+    onInitialize(provider: ITaskDataProvider): Promise<{
+        columns: IColumn[];
+        rawData: IRawRecord[];
+        metadata: any;
+    }>;
+    private _getLookupManyColumns;
+    private _restoreVirtualColumnMetadata;
+    private _injectLookupManyFilterOperators;
+    private _getFieldMapping;
+    private _getFetchXml;
+    onGetAvailableColumns(options?: IAvailableColumnOptions): Promise<IColumn[]>;
+    onGetAvailableRelatedColumns(): Promise<IAvailableRelatedColumn[]>;
+    onGetQuickFindColumns(): string[];
+    onCreateTask(parentTaskId?: string): Promise<IRawRecord | null>;
+    onDeleteTasks(taskIds: string[]): Promise<IDeleteTasksResult | null>;
+    onCreateTemplateFromTask(taskId: string): Promise<IRawRecord | null>;
+    onCreateTasksFromTemplate(templateId: string, parentTaskId?: string): Promise<IRawRecord[] | null>;
+    onEditTasks(taskIds: string[]): Promise<IEditTasksResult | null>;
+    onMoveTask(movingTaskId: string, movingToTaskId: string, position: "above" | "below" | "child"): Promise<IRawRecord[] | null>;
+    /**
+     * Saves a single dirty field on a task record.
+     * Lookup-many fields are persisted through their dedicated {@link LookupManyHandler}; all other fields use the standard FetchXML provider save path.
+     * TaskGrid uses auto-save, so exactly one dirty field is expected per call.
+     */
+    onRecordSave(record: IRecord): Promise<IRecordSaveOperationResult>;
+    /** Returns `true` when the task's `stateCode` attribute equals `0` (active). */
+    onIsRecordActive(recordId: string): boolean;
+    /** Opens the task record in a side dialog. When `context.columnName` is a lookup-many column, the dialog is focused on that column. */
+    onOpenDatasetItem(entityReference: ComponentFramework.EntityReference, context?: {
+        columnName?: string;
+    }): Promise<void>;
+    /** Returns the root task ID supplied at construction time, used to scope the displayed hierarchy. */
+    onGetRootTaskId?(): string | undefined;
+    private _getNavigationalPropertyName;
+    private _getFormNavigationOptions;
+    private _getLookupManyHandlerForColumn;
+    private _editSingleTask;
+    private _editMultipleTasks;
+    private _updateStackRank;
+}
+export {};

package/dist/components/TaskGrid/extensions/dataverse/DataverseTaskStrategy.js

@@ -0,0 +1,453 @@
+import { FetchXmlDataProvider, Operators, DataTypes, Sanitizer } from '@talxis/client-libraries';
+import { LexoRank } from 'lexorank';
+import { Liquid } from 'liquidjs';
+import { LookupManyHandler, LOOKUP_MANY_COLUMN_NAME_SUFFIX } from './lookup-many/LookupManyHandler.js';
+
+const LIQUID = new Liquid();
+/**
+ * Ready-to-use {@link ITaskDataProviderStrategy} implementation for the Dataverse / Talxis platform.
+ *
+ * Handles all task CRUD operations, drag-and-drop reordering (via LexoRank), template-based creation,
+ * and lookup-many column rendering — all backed by the Xrm WebApi and FetchXML.
+ *
+ * Normally instantiated automatically by {@link DataverseTaskGridDescriptor}. Construct directly only
+ * when you need to pass a custom `formStrategy` or override specific behaviour.
+ */
+class DataverseTaskStrategy {
+    /** @param params — see {@link IDataverseTaskStrategyParams} for full documentation of each option. */
+    constructor(params) {
+        this._lookupManyColumns = [];
+        this._lookupManyHandlers = {};
+        this._fetchXml = params.fetchXml;
+        this._projectReference = params.projectReference;
+        this._editFormId = params.editFormId;
+        this._rootTaskId = params.rootTaskId;
+        this._createFormId = params.createFormId;
+        this._bulkEditFormId = params.bulkEditFormId;
+        this._isInlineCreateEnabled = params.isInlineCreateEnabled ?? true;
+        this._isEditingEnabled = params.isEditingEnabled ?? true;
+        this._isDeletingTasksWithChildrenEnabled = params.isDeletingTasksWithChildrenEnabled ?? false;
+        this._isCascadeDeleteEnabled = params.isCascadeDeleteEnabled ?? false;
+        this._getFormParameters = params.formStrategy?.onGetFormParameters ?? ((operation, defaultParameters) => defaultParameters);
+    }
+    async onGetRawRecords(ids, select) {
+        let records = [];
+        const expands = await Promise.all(this._lookupManyColumns.map(async (col) => {
+            const referencedEntityNavigationPropertyName = col.navigationPropertyName;
+            const handler = this._lookupManyHandlers[col.name] ?? new LookupManyHandler({
+                entityName: this._entityName,
+                navigationPropertyName: referencedEntityNavigationPropertyName
+            });
+            this._lookupManyHandlers[col.name] = handler;
+            await handler.init();
+            return handler.getExpand();
+        }));
+        const parts = [];
+        if (select)
+            parts.push(`$select=${select}`);
+        if (expands.length > 0)
+            parts.push(`$expand=${expands.join(',')}`);
+        const query = `?$filter=Microsoft.Dynamics.CRM.In(PropertyName='${this._fetchXmlDataProvider.getMetadata().PrimaryIdAttribute}', PropertyValues=[${ids.map((id) => `'${id}'`).join(',')}])${parts.length > 0 ? `&${parts.join('&')}` : ''}`;
+        records = await this._getRawRecordsByIds({ ids, query });
+        if (this._lookupManyColumns.length > 0) {
+            await Promise.all(records.map(record => this._harmonizeLookupManyData(record)));
+        }
+        return records;
+    }
+    /** Returns the project entity reference resolved during `onInitialize`, or `null` when none was provided. */
+    getProjectReference() {
+        return this._projectReference ?? null;
+    }
+    async _harmonizeLookupManyData(record) {
+        const nextLinkSuffix = '@odata.nextLink';
+        for (const lookupManyCol of this._lookupManyColumns) {
+            const referencedEntityNavigationPropertyName = lookupManyCol.navigationPropertyName;
+            record[lookupManyCol.name] = await this._convertLookupManyToEntityReference(record[referencedEntityNavigationPropertyName], lookupManyCol);
+            delete record[referencedEntityNavigationPropertyName];
+            delete record[`${referencedEntityNavigationPropertyName}${nextLinkSuffix}`];
+        }
+        return record;
+    }
+    async _convertLookupManyToEntityReference(data, col) {
+        const metadata = await window.Xrm.Utility.getEntityMetadata(col.metadata?.Targets[0]);
+        return data.map(record => {
+            return {
+                id: {
+                    guid: record[metadata.PrimaryIdAttribute]
+                },
+                name: record[metadata.PrimaryNameAttribute],
+                etn: metadata.LogicalName,
+                rawData: record
+            };
+        });
+    }
+    async _getRawRecordsByIds(params) {
+        const maxIdsPerRequest = 800;
+        const batches = [];
+        const { ids, query } = params;
+        let currentBatch = [];
+        for (const [i, taskId] of Object.entries(ids)) {
+            if (currentBatch.length <= maxIdsPerRequest) {
+                currentBatch.push(taskId);
+            }
+            else {
+                batches.push(currentBatch);
+                currentBatch = [taskId];
+            }
+            if (+i + 1 === ids.length) {
+                batches.push(currentBatch);
+            }
+        }
+        const batchedTasks = await Promise.all(batches.map(async (batchIds) => {
+            const { entities } = await window.Xrm.WebApi.retrieveMultipleRecords(this._entityName, query);
+            return entities;
+        }));
+        return batchedTasks.flat();
+    }
+    async onInitialize(provider) {
+        this._provider = provider;
+        this._taskTree = provider.getRecordTree();
+        this._fetchXml = this._getFetchXml();
+        const virtualColumns = structuredClone(provider.getColumns().filter(col => col.isVirtual));
+        this._fetchXmlDataProvider = new FetchXmlDataProvider({ fetchXml: this._fetchXml, loadAllRecords: true });
+        this._fetchXmlDataProvider.setColumns(provider.getColumns());
+        this._fetchXmlDataProvider.setLinking(provider.getLinking());
+        await this._fetchXmlDataProvider.refresh();
+        this._entityName = this._fetchXmlDataProvider.getEntityName();
+        this._entitySetName = this._fetchXmlDataProvider.getMetadata().EntitySetName;
+        this._lookupManyColumns = this._getLookupManyColumns();
+        const columns = this._fetchXmlDataProvider.getColumns();
+        this._restoreVirtualColumnMetadata(virtualColumns, columns);
+        this._injectLookupManyFilterOperators(columns);
+        const metadata = this._fetchXmlDataProvider.getMetadata();
+        const fetchXmlProviderData = this._fetchXmlDataProvider.getRawData();
+        const enrichedData = await this.onGetRawRecords(this._fetchXmlDataProvider.getSortedRecordIds(), this._fetchXmlDataProvider.getMetadata().PrimaryIdAttribute);
+        const finalRawData = fetchXmlProviderData.map((record, i) => {
+            return {
+                ...enrichedData[i],
+                ...record,
+            };
+        });
+        if (this._projectReference) {
+            this._projectMetadata = await window.Xrm.Utility.getEntityMetadata(this._projectReference.etn);
+        }
+        return {
+            rawData: finalRawData,
+            columns,
+            metadata
+        };
+    }
+    _getLookupManyColumns() {
+        return this._fetchXmlDataProvider.getColumns().filter(col => col.name.endsWith(LOOKUP_MANY_COLUMN_NAME_SUFFIX)).map(col => {
+            return {
+                ...col,
+                navigationPropertyName: col.name.replace(LOOKUP_MANY_COLUMN_NAME_SUFFIX, '')
+            };
+        });
+    }
+    //fetch xml provider will override virtual column metadata by default, so we need to restore it after initialization.
+    _restoreVirtualColumnMetadata(virtualColumns, columns) {
+        columns.map((col, i) => {
+            const virtualCol = virtualColumns.find(virtualCol => virtualCol.name === col.name);
+            if (virtualCol) {
+                columns[i] = virtualCol;
+            }
+        });
+    }
+    _injectLookupManyFilterOperators(columns) {
+        columns.map(col => {
+            if (col.name.endsWith(LOOKUP_MANY_COLUMN_NAME_SUFFIX)) {
+                col.metadata = {
+                    ...col.metadata,
+                    SupportedFilterConditionOperators: Operators.GetOperatorsForDataType(DataTypes.MultiSelectOptionSet).map(op => op.Value)
+                };
+            }
+        });
+    }
+    _getFieldMapping() {
+        return this._provider.getNativeColumns();
+    }
+    _getFetchXml() {
+        return LIQUID.parseAndRenderSync(this._fetchXml, {
+            projectId: this._projectReference?.id.guid,
+        });
+    }
+    async onGetAvailableColumns(options) {
+        return this._fetchXmlDataProvider.getAvailableColumns(options);
+    }
+    async onGetAvailableRelatedColumns() {
+        return this._fetchXmlDataProvider.getAvailableRelatedColumns();
+    }
+    onGetQuickFindColumns() {
+        return [];
+    }
+    async onCreateTask(parentTaskId) {
+        const data = {};
+        let pageInput = {
+            pageType: 'entityrecord',
+            entityName: this._entityName,
+            data: data,
+            formId: this._createFormId
+        };
+        //prefill project
+        if (this._projectReference) {
+            const projectIdColumnName = this._getFieldMapping().projectId;
+            data[`${projectIdColumnName}`] = this._projectReference.id.guid;
+            data[`${projectIdColumnName}name`] = this._projectReference.name;
+            data[`${projectIdColumnName}type`] = this._projectReference.etn;
+        }
+        //prefill parent task
+        if (parentTaskId) {
+            const parentIdColumnName = this._getFieldMapping().parentId;
+            data[`${parentIdColumnName}`] = parentTaskId;
+            data[`${parentIdColumnName}name`] = this._provider.getRecordsMap()[parentTaskId].getNamedReference().name;
+            data[`${parentIdColumnName}type`] = this._entityName;
+        }
+        const node = this._taskTree.getNode(parentTaskId ?? null);
+        let payload = {};
+        payload[`${this._getFieldMapping().stackRank}`] = await this._updateStackRank({ previousTaskId: undefined, nextTaskId: node.directChildren[0]?.getRecordId(), skipSave: true });
+        if (this._projectReference) {
+            payload[`${await this._getNavigationalPropertyName(this._projectReference.etn, this._getFieldMapping().projectId)}@odata.bind`] = `/${this._projectMetadata?.EntitySetName}(${this._projectReference.id.guid})`;
+        }
+        if (parentTaskId) {
+            payload[`${await this._getNavigationalPropertyName(this._entityName, this._getFieldMapping().parentId)}@odata.bind`] = `/${this._entitySetName}(${parentTaskId})`;
+        }
+        if (this._isInlineCreateEnabled) {
+            const result = await window.Xrm.WebApi.createRecord(this._entityName, payload);
+            const rawRecord = (await this.onGetRawRecords([result.id]))[0];
+            return rawRecord;
+        }
+        const { pageInput: resolvedPageInput, navigationOptions: resolvedNavigationOptions } = this._getFormParameters('create', {
+            pageInput,
+            navigationOptions: this._getFormNavigationOptions()
+        });
+        const navigateToResult = await Xrm.Navigation.navigateTo(resolvedPageInput, resolvedNavigationOptions);
+        if (navigateToResult.savedEntityReference) {
+            const entityReference = Sanitizer.Lookup.getEntityReference(navigateToResult.savedEntityReference[0]);
+            await window.Xrm.WebApi.updateRecord(this._entityName, entityReference.id.guid, payload);
+            const rawRecord = (await this.onGetRawRecords([entityReference.id.guid]))[0];
+            return rawRecord;
+        }
+        else {
+            return null;
+        }
+    }
+    async onDeleteTasks(taskIds) {
+        const allTaskIds = new Set(taskIds);
+        let success = true;
+        const notDeletableTaskIds = [];
+        if (this._isCascadeDeleteEnabled) {
+            for (const taskId of taskIds) {
+                const children = this._taskTree.getNode(taskId)?.allChildren.map(c => c.getRecordId()) ?? [];
+                children.map(id => allTaskIds.add(id));
+            }
+        }
+        if (!this._isDeletingTasksWithChildrenEnabled) {
+            for (const taskId of allTaskIds) {
+                if (this._taskTree.hasChildren(taskId)) {
+                    success = false;
+                    allTaskIds.delete(taskId);
+                    notDeletableTaskIds.push(taskId);
+                }
+            }
+        }
+        const result = await this._fetchXmlDataProvider.deleteRecords([...allTaskIds]);
+        return {
+            success: result.success && success,
+            deletedTaskIds: [...allTaskIds],
+            errors: [...result.results.filter(result => !result.success).map(result => {
+                    return {
+                        id: result.recordId,
+                        error: result.errorMessage
+                    };
+                }), ...notDeletableTaskIds.map(id => {
+                    return {
+                        id,
+                        //TODO: localize
+                        error: 'Cannot delete task with children.'
+                    };
+                })]
+        };
+    }
+    onCreateTemplateFromTask(taskId) {
+        throw new Error("Method not implemented.");
+    }
+    onCreateTasksFromTemplate(templateId, parentTaskId) {
+        throw new Error("Method not implemented.");
+    }
+    async onEditTasks(taskIds) {
+        if (taskIds.length === 1) {
+            const result = await this._editSingleTask(taskIds[0]);
+            if (!result)
+                return null;
+            return {
+                success: true,
+                updatedRecords: [result]
+            };
+        }
+        return this._editMultipleTasks(taskIds);
+    }
+    async onMoveTask(movingTaskId, movingToTaskId, position) {
+        const movingToRecord = this._provider.getRecordsMap()[movingToTaskId];
+        let payload = {};
+        if (position === 'child') {
+            //change parent
+            payload[`${await this._getNavigationalPropertyName(this._entityName, this._getFieldMapping().parentId)}@odata.bind`] = `/${this._entitySetName}(${movingToTaskId})`;
+            const firstChild = this._taskTree.getNode(movingToTaskId).directChildren
+                .find(c => c.getRecordId() !== movingTaskId);
+            if (firstChild) {
+                //change stack rank to be before first child
+                payload[`${this._getFieldMapping().stackRank}`] = await this._updateStackRank({ recordId: movingTaskId, previousTaskId: undefined, nextTaskId: firstChild.getRecordId(), skipSave: true });
+            }
+            await window.Xrm.WebApi.updateRecord(this._entityName, movingTaskId, payload);
+            const rawRecord = (await this.onGetRawRecords([movingTaskId]))[0];
+            return [rawRecord];
+        }
+        else {
+            const movingToRecordParent = this._taskTree.getNodeMap().get(movingToRecord.getRecordId())?.parent;
+            payload[`${await this._getNavigationalPropertyName(this._entityName, this._getFieldMapping().parentId)}@odata.bind`] = movingToRecordParent ? `/${this._entitySetName}(${movingToRecordParent.getRecordId()})` : null;
+            const movingToRecordNode = this._taskTree.getNodeMap().get(movingToRecord.getRecordId());
+            const siblings = this._taskTree.getNodeMap().get(movingToRecordParent?.getRecordId() ?? null)?.directChildren ?? [];
+            let prevSiblingId;
+            let nextSiblingId;
+            if (position === 'above') {
+                prevSiblingId = siblings[movingToRecordNode.index - 1]?.getRecordId();
+                nextSiblingId = movingToRecord.getRecordId();
+            }
+            else {
+                prevSiblingId = movingToRecord.getRecordId();
+                nextSiblingId = siblings[movingToRecordNode.index + 1]?.getRecordId();
+            }
+            payload[`${this._getFieldMapping().stackRank}`] = await this._updateStackRank({ recordId: movingTaskId, previousTaskId: prevSiblingId, nextTaskId: nextSiblingId, skipSave: true });
+            await window.Xrm.WebApi.updateRecord(this._entityName, movingTaskId, payload);
+            const rawRecord = (await this.onGetRawRecords([movingTaskId]))[0];
+            return [rawRecord];
+        }
+    }
+    /**
+     * Saves a single dirty field on a task record.
+     * Lookup-many fields are persisted through their dedicated {@link LookupManyHandler}; all other fields use the standard FetchXML provider save path.
+     * TaskGrid uses auto-save, so exactly one dirty field is expected per call.
+     */
+    async onRecordSave(record) {
+        const dirtyField = record.getFields().find(field => field.isDirty());
+        if (dirtyField?.getColumn().name.endsWith(LOOKUP_MANY_COLUMN_NAME_SUFFIX)) {
+            const handler = this._getLookupManyHandlerForColumn(dirtyField.getColumn().name);
+            return handler.saveRecord(record, dirtyField.getColumn().name);
+        }
+        else {
+            return this._fetchXmlDataProvider.onRecordSave(record);
+        }
+    }
+    /** Returns `true` when the task's `stateCode` attribute equals `0` (active). */
+    onIsRecordActive(recordId) {
+        const record = this._provider.getRecordsMap()[recordId];
+        return record.getValue(this._provider.getNativeColumns().stateCode) == 0;
+    }
+    /** Opens the task record in a side dialog. When `context.columnName` is a lookup-many column, the dialog is focused on that column. */
+    async onOpenDatasetItem(entityReference, context) {
+        const { pageInput, navigationOptions } = this._getFormParameters('open', {
+            pageInput: {
+                pageType: 'entityrecord',
+                entityName: entityReference.etn,
+                entityId: entityReference.id.guid,
+            },
+            navigationOptions: this._getFormNavigationOptions()
+        });
+        await window.Xrm.Navigation.navigateTo(pageInput, navigationOptions);
+    }
+    /** Returns the root task ID supplied at construction time, used to scope the displayed hierarchy. */
+    onGetRootTaskId() {
+        return this._rootTaskId;
+    }
+    async _getNavigationalPropertyName(referencedEntityName, referencingAttribute) {
+        const metadata = await window.Xrm.Utility.getEntityMetadata(this._entityName);
+        const relationship = metadata.ManyToOneRelationships.getAll().find((rel) => rel.ReferencedEntity === referencedEntityName &&
+            rel.ReferencingAttribute === referencingAttribute);
+        if (!relationship) {
+            throw new Error(`Could not find many-to-one relationship targeting ${referencedEntityName} on ${metadata.LogicalName}`);
+        }
+        return relationship.ReferencingEntityNavigationPropertyName;
+    }
+    _getFormNavigationOptions() {
+        return {
+            target: 2,
+            width: { value: 80, unit: '%' },
+            position: 1,
+        };
+    }
+    _getLookupManyHandlerForColumn(colName) {
+        const handler = this._lookupManyHandlers[colName];
+        if (!handler) {
+            throw new Error(`No LookupManyHandler found for column ${colName}`);
+        }
+        return handler;
+    }
+    async _editSingleTask(recordId) {
+        const { pageInput, navigationOptions } = this._getFormParameters('edit', {
+            pageInput: {
+                pageType: 'entityrecord',
+                entityName: this._entityName,
+                entityId: recordId,
+                formId: this._editFormId,
+                data: {
+                    isEditingEnabled: this._isEditingEnabled
+                }
+            },
+            navigationOptions: this._getFormNavigationOptions()
+        });
+        await window.Xrm.Navigation.navigateTo(pageInput, navigationOptions);
+        const result = await this.onGetRawRecords([recordId]);
+        return result[0];
+    }
+    async _editMultipleTasks(recordIds) {
+        const { pageInput, navigationOptions } = this._getFormParameters('bulkEdit', {
+            //@ts-ignore - not documented, passing of record id array is possible in Power Apps - https://butenko.pro/2021/10/14/howto-open-bulk-editing-of-records-using-xrm-navigation-navigateto/
+            pageInput: {
+                //@ts-ignore - typings
+                pageType: 'bulkedit',
+                entityName: this._entityName,
+                entityIds: recordIds,
+                formId: this._bulkEditFormId
+            },
+            navigationOptions: {
+                target: 2,
+                position: 2,
+            }
+        });
+        await window.Xrm.Navigation.navigateTo(pageInput, navigationOptions);
+        const rawRecords = await this.onGetRawRecords(recordIds);
+        return {
+            success: true,
+            updatedRecords: rawRecords
+        };
+    }
+    async _updateStackRank(params) {
+        const stackRankCol = this._getFieldMapping().stackRank;
+        const rawDataMap = this._provider.getRawDataMap();
+        const prevRankStr = params.previousTaskId ? rawDataMap[params.previousTaskId]?.[stackRankCol] : undefined;
+        const nextRankStr = params.nextTaskId ? rawDataMap[params.nextTaskId]?.[stackRankCol] : undefined;
+        let newRank;
+        if (prevRankStr && nextRankStr) {
+            newRank = LexoRank.parse(prevRankStr).between(LexoRank.parse(nextRankStr)).format();
+        }
+        else if (nextRankStr) {
+            newRank = LexoRank.parse(nextRankStr).genPrev().format();
+        }
+        else if (prevRankStr) {
+            newRank = LexoRank.parse(prevRankStr).genNext().format();
+        }
+        else {
+            newRank = LexoRank.middle().format();
+        }
+        if (!params.skipSave && params.recordId) {
+            await window.Xrm.WebApi.updateRecord(this._entityName, params.recordId, {
+                [stackRankCol]: newRank
+            });
+        }
+        return newRank;
+    }
+}
+
+export { DataverseTaskStrategy };
+//# sourceMappingURL=DataverseTaskStrategy.js.map