@masterteam/task-schedule 0.0.22 → 0.0.24

package/README.md

@@ -26,10 +26,10 @@ Main context fields:
 - `dateFormat`: default `dd/MM/yyyy`
 - `height`: default `760px`
 - `pdfFonts`: optional `{ regular?: string; arabic?: string; size?: number }`
-- `mppRequestTimeoutMs`: optional timeout for MPP import, apply, and export requests. Defaults to `300000` ms.
-- `mppPreviewMaxRows`: optional MPP import normalization cap. Defaults to `400` preview rows.
-- `mppPreviewMaxResponseBytes`: optional maximum import response size to parse for preview rows. Defaults to `5000000` bytes; larger successful responses are treated as direct backend-applied imports.
-- `mppKeepRawPayload`: optional flag to retain the raw MPP import response on `TaskScheduleImportResult.raw`. Defaults to `false`.
+- `mppRequestTimeoutMs`: optional timeout for MPP import, apply, and export requests. Defaults to `300000` ms.
+- `mppPreviewMaxRows`: optional MPP import normalization cap. Defaults to `400` preview rows.
+- `mppPreviewMaxResponseBytes`: optional maximum import response size to parse for preview rows. Defaults to `5000000` bytes; larger successful responses are treated as direct backend-applied imports.
+- `mppKeepRawPayload`: optional flag to retain the raw MPP import response on `TaskScheduleImportResult.raw`. Defaults to `false`.
 
 ## Outputs
 
@@ -108,16 +108,17 @@ Backend routes used:
 - Custom view config: `GET /api/schedulemanager/{levelId}/schedule/{customViewId}`
 - Team members (edit/resources mode): `GET /api/levels/{levelId}/TeamMember`
 
-Runtime mutations (when `levelDataId` exists):
-
-- `POST /api/process-submit` for create/update/delete/progress
-- `PUT /api/levels/{levelId}/{levelDataId}/schedule/bulk-update`
-- `PUT /api/levels/{levelId}/{levelDataId}/schedule/reorder`
+Runtime mutations (when `levelDataId` exists):
+
+- `POST /api/process-submit` for create/update/delete/progress
+- `PUT /api/levels/{levelId}/{levelDataId}/schedule/bulk-update`
+- `PUT /api/levels/{levelId}/{levelDataId}/schedule/reorder`
 - `POST /api/levels/{levelId}/{levelDataId}/schedule/baselines` (set baseline)
 - `GET /api/levels/{levelId}/{levelDataId}/schedule/mpp` (export)
-
-Plain schedule reads no longer use legacy `/api/tasks/...` read routes.
-Import dialog keeps its current MPP preview/apply flow unless `endpoints.importTasks` / `endpoints.applyImportedTasks` are overridden.
+
+Plain schedule reads no longer use legacy `/api/tasks/...` read routes.
+Import dialog keeps its current MPP preview/apply flow unless `endpoints.importTasks` / `endpoints.applyImportedTasks` are overridden.
+Row drag/drop reorder is optimistic: the component sends the parent/order write requests and leaves the current Gantt view in place instead of immediately reloading the schedule.
 
 For `schedule/read` query responses, `TaskScheduleFetchService` maps native fields through `catalog.properties`: it resolves each property's `normalizedKey` to the Gantt field and reads the matching `record.values[property.key]` wrapper. Date fields prefer `raw` values and are converted from valid date/UTC strings to local date-only `Date` objects before binding to Syncfusion Gantt.
 
@@ -141,11 +142,11 @@ When no PDF font is provided, package fallback uses embedded `TASK_SCHEDULE_DEFA
 
 ## Import Dialog
 
-Use `TaskScheduleImportDialog` with `ModalService` to import `.mpp`/`.xer` files and apply tasks (replace or append).  
-The dialog is Tailwind-based and uses `@masterteam/components` (`mt-button`, `mt-entity-preview`).
-Imported rows render as a checkbox tree so nested MPP summary tasks and children stay readable before apply.
-If the MPP import endpoint returns a successful empty body or a response larger than `mppPreviewMaxResponseBytes`, the package treats it as a direct backend-applied import, closes the dialog with a success result, and lets the host schedule reload instead of rendering an empty preview.
-The preview is capped by `maxRows`/`context.mppPreviewMaxRows` to keep large MPP files responsive. Select-all and apply operate on the visible preview rows only when the backend returns more rows than the preview cap. The full raw import payload is not retained unless `context.mppKeepRawPayload` is enabled.
+Use `TaskScheduleImportDialog` with `ModalService` to import `.mpp`/`.xer` files and apply tasks (replace or append).  
+The dialog is Tailwind-based and uses `@masterteam/components` (`mt-button`, `mt-entity-preview`).
+Imported rows render as a checkbox tree so nested MPP summary tasks and children stay readable before apply.
+If the MPP import endpoint returns a successful empty body or a response larger than `mppPreviewMaxResponseBytes`, the package treats it as a direct backend-applied import, closes the dialog with a success result, and lets the host schedule reload instead of rendering an empty preview.
+The preview is capped by `maxRows`/`context.mppPreviewMaxRows` to keep large MPP files responsive. Select-all and apply operate on the visible preview rows only when the backend returns more rows than the preview cap. The full raw import payload is not retained unless `context.mppKeepRawPayload` is enabled.
 
 ## Shell Component
 

package/fesm2022/masterteam-task-schedule.mjs

@@ -1280,7 +1280,6 @@ function normalizeLookupKey(value) {
         .replace(/[^a-z0-9]/g, '');
 }
 
-const DEFAULT_TASK_MODULE_ID = 3;
 const DEFAULT_MPP_REQUEST_TIMEOUT_MS = 300_000;
 class TaskScheduleActionService {
     http = inject(HttpClient);
@@ -1507,9 +1506,14 @@ class TaskScheduleActionService {
         return this.submitTaskMutation(context, 'UpdateProgress', payload, taskId);
     }
     applyImportedTasks(context, payload) {
+        // Submit/import the reviewed preview tasks. The level-scoped route is the
+        // preferred contract (Pplus4-style split flow): upload/parse only previews,
+        // this PATCH saves. The old `tasks/{levelDataId}/import` shape fed levelId
+        // into a levelDataId slot — wrong record — so imports never saved correctly.
         const endpoint = this.interpolateEndpointTemplate(this.readEndpoint(context, 'applyImportedTasks') ??
-            'tasks/{levelId}/import', {
+            'levels/{levelId}/{levelDataId}/tasks/import', {
             levelId: this.requireId(context.levelId, 'Apply import requires levelId.'),
+            levelDataId: this.requireId(context.levelDataId, 'Apply import requires levelDataId.'),
         });
         return this.readData(this.http
             .patch(endpoint, payload)
@@ -1521,9 +1525,17 @@ class TaskScheduleActionService {
             operationKey: 'SetBaseline',
             levelId: this.requireProcessId(context.levelId),
             levelDataId: this.requireProcessId(context.levelDataId),
-            moduleId: context.taskModuleId ?? DEFAULT_TASK_MODULE_ID,
             fields: [],
         };
+        // The backend resolves the module from `moduleKey` — the task
+        // create/update/delete/progress mutations (buildProcessSubmitRequest) all
+        // omit moduleId and work. SetBaseline used to force a hardcoded moduleId
+        // (was DEFAULT_TASK_MODULE_ID = 3), which targets the wrong module on any
+        // template whose Task module isn't id 3 → "Record '<levelDataId>' was not
+        // found". Only forward an explicitly-provided override.
+        if (context.taskModuleId !== undefined && context.taskModuleId !== null) {
+            request.moduleId = context.taskModuleId;
+        }
         const endpoint = this.interpolateEndpointTemplate(this.readEndpoint(context, 'processSubmit') ?? 'process-submit', {});
         return this.readData(this.http.post(endpoint, request));
     }
@@ -2641,15 +2653,24 @@ class TaskScheduleDialog {
         this.ref.close(response);
     }
     mapSubmitRequest(request) {
-        if (this.mode() !== 'create' || !this.parentGuid()) {
-            return request;
+        // Schedule items submit under their type-specific schedule module key
+        // ('Task' | 'Milestone' | 'Deliverable'), not the generic 'ModuleData' the
+        // form loads with. The backend only maps the task_* fields (and the parent
+        // link) when the schedule module key is used.
+        const moduleKey = this.selectedType() ?? request.moduleKey;
+        const isSubtaskCreate = this.mode() === 'create' && !!this.parentGuid();
+        if (!isSubtaskCreate) {
+            return { ...request, moduleKey };
         }
         return {
             ...request,
+            moduleKey,
             fields: [
                 ...(request.fields ?? []),
                 {
-                    propertyKey: 'parentId',
+                    // Parent reference is the anchor row's schedule guid / externalId,
+                    // not its numeric database id.
+                    propertyKey: 'externalParentId',
                     value: this.parentGuid(),
                 },
             ],
@@ -3124,12 +3145,12 @@ class TaskScheduleImportDialog {
             subtasks: [],
             children: [],
         };
-        payloadTask['startDate'] = this.toApiDate(task.startDate);
-        payloadTask['finishDate'] = this.toApiDate(task.finishDate);
-        payloadTask['baselineStart'] = this.toApiDate(task.baselineStartDate ?? task.baselineStart);
-        payloadTask['baselineFinish'] = this.toApiDate(task.baselineEndDate ?? task.baselineFinish);
-        payloadTask['actualStart'] = this.toApiDate(task.actualStartDate ?? task.actualStart);
-        payloadTask['actualFinish'] = this.toApiDate(task.actualFinishDate ?? task.actualFinish);
+        payloadTask['startDate'] = this.toApiDateTime(task.startDate);
+        payloadTask['finishDate'] = this.toApiDateTime(task.finishDate);
+        payloadTask['baselineStart'] = this.toApiDateTime(task.baselineStartDate ?? task.baselineStart);
+        payloadTask['baselineFinish'] = this.toApiDateTime(task.baselineEndDate ?? task.baselineFinish);
+        payloadTask['actualStart'] = this.toApiDateTime(task.actualStartDate ?? task.actualStart);
+        payloadTask['actualFinish'] = this.toApiDateTime(task.actualFinishDate ?? task.actualFinish);
         payloadTask['customProperties'] =
             task.customProperties ?? task.props ?? [];
         payloadTask['isMilestone'] =
@@ -3327,6 +3348,21 @@ class TaskScheduleImportDialog {
         const day = String(date.getDate()).padStart(2, '0');
         return `${year}-${month}-${day}`;
     }
+    /**
+     * Submit/import payload dates must be ISO 8601 UTC timestamps ending with
+     * 'Z' (backend rejects bare 'YYYY-MM-DD' with VAL_001). `toApiDate` yields a
+     * calendar day for display/editing; this widens it to a full UTC instant for
+     * the import call. Date-only strings parse as UTC midnight, so the calendar
+     * day is preserved (no timezone shift).
+     */
+    toApiDateTime(value) {
+        const normalized = this.toApiDate(value);
+        if (!normalized) {
+            return null;
+        }
+        const date = new Date(normalized);
+        return Number.isNaN(date.getTime()) ? null : date.toISOString();
+    }
     countTasks(tasks, maxCount) {
         let count = 0;
         const walk = (rows) => {
@@ -3940,25 +3976,22 @@ class TaskSchedule {
         const { taskId, parentId } = rowDropUpdate;
         const sub = this.actionService
             .updateParent(context, taskId, parentId)
-            .pipe(finalize(() => {
-            const payload = this.actionService.buildOrderPayload(this.ganttObj?.flatData);
-            if (!payload.length) {
-                this.reloadSchedule();
-                return;
-            }
-            const orderSub = this.actionService
-                .updateOrder(context, payload)
-                .subscribe({
-                next: () => this.reloadSchedule(),
-                error: () => this.reloadSchedule(),
-            });
-            this.operationSub.add(orderSub);
-        }))
             .subscribe({
-            error: () => this.reloadSchedule(),
+            next: () => this.persistCurrentOrder(context),
+            error: (error) => this.emitActionError(this.getErrorMessage(error)),
         });
         this.operationSub.add(sub);
     }
+    persistCurrentOrder(context) {
+        const payload = this.actionService.buildOrderPayload(this.ganttObj?.flatData);
+        if (!payload.length) {
+            return;
+        }
+        const orderSub = this.actionService.updateOrder(context, payload).subscribe({
+            error: (error) => this.emitActionError(this.getErrorMessage(error)),
+        });
+        this.operationSub.add(orderSub);
+    }
     updateTask(args) {
         const context = this.context();
         if (!context) {