@uipath/tasks-tool 1.201.0-preview.115 → 1.201.0-preview.122

package/src/commands/metadata.ts

@@ -0,0 +1,139 @@
+import {
+    catchError,
+    extractErrorMessage,
+    OutputFormatter,
+    processContext,
+    RESULTS,
+} from "@uipath/common";
+import type { TaskEditMetadataOptions } from "@uipath/uipath-typescript";
+import { TaskPriority } from "@uipath/uipath-typescript";
+import type { Command } from "commander";
+
+import { connectTasksClient } from "./_shared/connect";
+import {
+    addFolderScopeOptions,
+    type FolderScopeOptions,
+    resolveFolderId,
+} from "./_shared/folder-picker";
+import { parseIntArg } from "./_shared/parse";
+
+interface MetadataOptions extends FolderScopeOptions {
+    title?: string;
+    priority?: string;
+    catalogId?: string;
+    unsetCatalog?: boolean;
+    note?: string;
+}
+
+export const registerMetadataCommand = (program: Command) => {
+    addFolderScopeOptions(
+        program
+            .command("metadata")
+            .description("Edit a task's metadata")
+            .argument("<task-id>", "Task ID"),
+    )
+        .option("--title <title>", "New title")
+        .option(
+            "--priority <priority>",
+            "New priority (Low, Medium, High, Critical)",
+        )
+        .option("--catalog-id <id>", "Associate a task catalog by ID")
+        .option("--unset-catalog", "Remove the task's catalog association")
+        .option("--note <text>", "Comment recorded with the edit")
+        .trackedAction(
+            processContext,
+            async (taskId: string, options: MetadataOptions) => {
+                const sdk = await connectTasksClient();
+                if (!sdk) return;
+
+                const parsedTaskId = parseIntArg(taskId, "<task-id>");
+                if (parsedTaskId === null) return;
+
+                if (options.catalogId && options.unsetCatalog) {
+                    OutputFormatter.error({
+                        Result: RESULTS.Failure,
+                        Message:
+                            "--catalog-id and --unset-catalog cannot be used together",
+                        Instructions:
+                            "Pass --catalog-id to associate a catalog, or --unset-catalog to clear it, not both.",
+                    });
+                    processContext.exit(1);
+                    return;
+                }
+
+                const hasEdit =
+                    options.title !== undefined ||
+                    options.priority !== undefined ||
+                    options.catalogId !== undefined ||
+                    options.unsetCatalog === true ||
+                    options.note !== undefined;
+                if (!hasEdit) {
+                    OutputFormatter.error({
+                        Result: RESULTS.Failure,
+                        Message: "No metadata changes provided",
+                        Instructions:
+                            "Pass at least one of --title, --priority, --catalog-id, --unset-catalog, or --note.",
+                    });
+                    processContext.exit(1);
+                    return;
+                }
+
+                const folderId = await resolveFolderId(options);
+                if (folderId === null) return;
+
+                const editOptions: TaskEditMetadataOptions = { folderId };
+                if (options.title !== undefined) {
+                    editOptions.title = options.title;
+                }
+                if (options.priority !== undefined) {
+                    if (
+                        !Object.values(TaskPriority).includes(
+                            options.priority as TaskPriority,
+                        )
+                    ) {
+                        OutputFormatter.error({
+                            Result: RESULTS.Failure,
+                            Message: `Invalid priority '${options.priority}'`,
+                            Instructions: `Valid priorities: ${Object.values(TaskPriority).join(", ")}`,
+                        });
+                        processContext.exit(1);
+                        return;
+                    }
+                    editOptions.priority = options.priority as TaskPriority;
+                }
+                if (options.catalogId !== undefined) {
+                    const parsedCatalogId = parseIntArg(
+                        options.catalogId,
+                        "--catalog-id",
+                    );
+                    if (parsedCatalogId === null) return;
+                    editOptions.taskCatalogId = parsedCatalogId;
+                }
+                if (options.unsetCatalog) {
+                    editOptions.unlinkTaskCatalog = true;
+                }
+                if (options.note !== undefined) {
+                    editOptions.noteText = options.note;
+                }
+
+                const [editError] = await catchError(
+                    sdk.tasks.editMetadata(parsedTaskId, editOptions),
+                );
+                if (editError) {
+                    OutputFormatter.error({
+                        Result: RESULTS.Failure,
+                        Message: `Error editing metadata on task '${taskId}'`,
+                        Instructions: await extractErrorMessage(editError),
+                    });
+                    processContext.exit(1);
+                    return;
+                }
+
+                OutputFormatter.success({
+                    Result: RESULTS.Success,
+                    Code: "TaskMetadataEdited",
+                    Data: { taskId: parsedTaskId },
+                });
+            },
+        );
+};