XS⚠️ ◾ Added work item cancel status logic (#685)

* added cancel status logic

* clean up

* use util to format error message

Author: babakamyljanovssw

src/backend/db/migrations/0002_add_portal_work_item_id_to_shaves.sql

@@ -0,0 +1 @@
+ALTER TABLE `shaves` ADD COLUMN `portal_work_item_id` text;

src/backend/db/migrations/meta/_journal.json

@@ -15,6 +15,13 @@
       "when": 1767769174030,
       "tag": "0001_schema_v2_add_tables",
       "breakpoints": true
+    },
+    {
+      "idx": 2,
+      "version": "6",
+      "when": 1770622000000,
+      "tag": "0002_add_portal_work_item_id_to_shaves",
+      "breakpoints": true
     }
   ]
 }

src/backend/db/schema.ts

@@ -135,6 +135,7 @@ export const shaves = sqliteTable(
     title: text("title").notNull(),
     projectName: text("project_name"),
     workItemUrl: text("work_item_url"),
+    portalWorkItemId: text("portal_work_item_id"),
     shaveStatus: text("shave_status").$type<ShaveStatus>().default(ShaveStatus.Unknown).notNull(),
     videoEmbedUrl: text("video_embed_url"),
     totalTokens: integer("total_tokens"),

src/backend/db/services/shave-service.test.ts

@@ -1,3 +1,4 @@
+import { randomUUID } from "node:crypto";
 import { beforeEach, describe, expect, it } from "vitest";
 import { ShaveStatus, VideoHostingProvider } from "../../types";
 import { createTestDb } from "../client";
@@ -142,6 +143,15 @@ describe("ShaveService", () => {
       expect(updated?.videoEmbedUrl).toBe(testShaveData.videoEmbedUrl);
     });
 
+    it("should update portal work item id", () => {
+      const created = createShave(testShaveData);
+
+      const updated = updateShave(created.id, { portalWorkItemId: randomUUID() });
+
+      expect(updated).toBeDefined();
+      expect(updated?.portalWorkItemId).toBeTruthy();
+    });
+
     it("should return undefined when updating non-existent shave", () => {
       const result = updateShave("non-existent-id", { title: "New Title" });
       expect(result).toBeUndefined();
@@ -168,6 +178,15 @@ describe("ShaveService", () => {
       expect(updated?.shaveStatus).toBe(ShaveStatus.Completed);
     });
 
+    it("should update to cancelled status", () => {
+      const created = createShave(testShaveData);
+
+      const updated = updateShaveStatus(created.id, ShaveStatus.Cancelled);
+
+      expect(updated).toBeDefined();
+      expect(updated?.shaveStatus).toBe(ShaveStatus.Cancelled);
+    });
+
     it("should return undefined when updating non-existent shave", () => {
       const result = updateShaveStatus("non-existent-id", ShaveStatus.Completed);
       expect(result).toBeUndefined();

src/backend/ipc/channels.ts

@@ -98,6 +98,7 @@ export const IPC_CHANNELS = {
 
   // Portal API
   PORTAL_GET_MY_SHAVES: "portal:get-my-shaves",
+  PORTAL_CANCEL_WORK_ITEM: "portal:cancel-work-item",
 
   // Shave Management
   SHAVE_CREATE: "shave:create",

src/backend/ipc/portal-handlers.ts

@@ -65,4 +65,38 @@ export function registerPortalHandlers(microsoftAuthService: MicrosoftAuthServic
       return { success: false, error: formatErrorMessage(error) };
     }
   });
+
+  ipcMain.handle(IPC_CHANNELS.PORTAL_CANCEL_WORK_ITEM, async (_event, workItemId?: string) => {
+    if (!workItemId) {
+      return { success: false, error: "Work item id is required" };
+    }
+
+    try {
+      const result = await microsoftAuthService.getToken();
+
+      const apiUrl = config.portalApiUrl();
+      const portalApiUrl = new URL(apiUrl);
+      const requestUrl = new URL(portalApiUrl.origin);
+      requestUrl.pathname = `${portalApiUrl.pathname.replace(/\/$/, "")}/desktopapp/work-items/${workItemId}:cancel`;
+
+      const response = await fetch(requestUrl.toString(), {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${result.accessToken}`,
+          Accept: "application/json",
+        },
+      });
+
+      if (!response.ok) {
+        const errorText = await response.text();
+        console.warn("Portal API error:", errorText);
+        return { success: false, error: errorText || response.statusText } as const;
+      }
+
+      return { success: true } as const;
+    } catch (error) {
+      console.error("Portal API error:", formatErrorMessage(error));
+      return { success: false, error: formatErrorMessage(error) } as const;
+    }
+  });
 }

src/backend/ipc/process-video-handlers.ts

@@ -305,6 +305,13 @@ export class ProcessVideoIPCHandlers {
           const errorMessage = formatErrorMessage(portalResult.error);
           notify(ProgressStage.ERROR, { error: errorMessage });
           workflowManager.failStage(WorkflowProgressStage.UPDATING_METADATA, errorMessage);
+        } else if (shaveId) {
+          try {
+            const shaveService = ShaveService.getInstance();
+            shaveService.updateShave(shaveId, { portalWorkItemId: portalResult.workItemId });
+          } catch (savePortalIdError) {
+            console.warn("[ProcessVideo] Failed to persist portal work item id", savePortalIdError);
+          }
         }
       }
 

src/backend/preload.ts

@@ -116,6 +116,7 @@ const IPC_CHANNELS = {
 
   // Portal API
   PORTAL_GET_MY_SHAVES: "portal:get-my-shaves",
+  PORTAL_CANCEL_WORK_ITEM: "portal:cancel-work-item",
 
   // Shave Management
   SHAVE_CREATE: "shave:create",
@@ -136,14 +137,14 @@ const onIpcEvent = <T>(channel: string, callback: (payload: T) => void) => {
 
 const electronAPI = {
   pipelines: {
-    processVideoFile: (filePath: string, shaveId?: number) =>
+    processVideoFile: (filePath: string, shaveId?: string) =>
       ipcRenderer.invoke(IPC_CHANNELS.PROCESS_VIDEO_FILE, filePath, shaveId),
-    processVideoUrl: (url: string, shaveId?: number) =>
+    processVideoUrl: (url: string, shaveId?: string) =>
       ipcRenderer.invoke(IPC_CHANNELS.PROCESS_VIDEO_URL, url, shaveId),
     retryVideo: (
       intermediateOutput: string,
       videoUploadResult: VideoUploadResult,
-      shaveId?: number,
+      shaveId?: string,
     ) =>
       ipcRenderer.invoke(IPC_CHANNELS.RETRY_VIDEO, intermediateOutput, videoUploadResult, shaveId),
   },
@@ -314,6 +315,8 @@ const electronAPI = {
   },
   portal: {
     getMyShaves: () => ipcRenderer.invoke(IPC_CHANNELS.PORTAL_GET_MY_SHAVES),
+    cancelWorkItem: (workItemId: string) =>
+      ipcRenderer.invoke(IPC_CHANNELS.PORTAL_CANCEL_WORK_ITEM, workItemId),
   },
   shave: {
     create: (

src/backend/services/portal/actions.ts

@@ -4,6 +4,7 @@ import { basename } from "node:path";
 import FormData from "form-data";
 import { z } from "zod";
 import { config } from "../../config/env";
+import { formatErrorMessage } from "../../utils/error-utils";
 import { MicrosoftAuthService } from "../auth/microsoft-auth";
 
 /**
@@ -80,20 +81,24 @@ export const WorkItemDtoSchema = z.object({
 });
 export type WorkItemDto = z.infer<typeof WorkItemDtoSchema>;
 
+const PostTaskRecordResponseSchema = z.object({
+  workItemId: z.string().uuid(),
+});
+
 /**
  * Sends work item details to the portal API.
  * Requires the user to be authenticated with Microsoft.
  */
 export async function SendWorkItemDetailsToPortal(
   payload: WorkItemDto,
-): Promise<{ success: true } | { success: false; error: string }> {
+): Promise<{ success: true; workItemId: string } | { success: false; error: string }> {
   const ms = MicrosoftAuthService.getInstance();
   const result = await ms.getToken();
 
   const body = JSON.stringify(payload);
 
   try {
-    await makePortalRequest(
+    const responseData = await makePortalRequest(
       "/desktopapp/post-task-record",
       {
         headers: {
@@ -104,6 +109,34 @@ export async function SendWorkItemDetailsToPortal(
       result.accessToken,
     );
 
+    const parsed = JSON.parse(responseData);
+    const validated = PostTaskRecordResponseSchema.parse(parsed);
+    return { success: true, workItemId: validated.workItemId } as const;
+  } catch (error) {
+    const message = formatErrorMessage(error);
+    return { success: false, error: message } as const;
+  }
+}
+
+export async function CancelWorkItemInPortal(
+  workItemId: string,
+): Promise<{ success: true } | { success: false; error: string }> {
+  const ms = MicrosoftAuthService.getInstance();
+  if (!(await ms.isAuthenticated())) {
+    return { success: false, error: "User is not authenticated with Microsoft" };
+  }
+  const result = await ms.getToken();
+
+  try {
+    await makePortalRequest(
+      `/desktopapp/work-items/${workItemId}:cancel`,
+      {
+        headers: {
+          "Content-Type": "application/json",
+        },
+      },
+      result.accessToken,
+    );
     return { success: true } as const;
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
@@ -169,7 +202,7 @@ export async function UploadScreenshotToPortal(
 
     return { success: true, url: validatedResponse.url };
   } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
+    const message = formatErrorMessage(error);
     return { success: false, error: message };
   }
 }

src/backend/types/index.ts

@@ -41,6 +41,7 @@ export enum ShaveStatus {
   Pending = "Pending",
   Processing = "Processing",
   Completed = "Completed",
+  Cancelled = "Cancelled",
   Failed = "Failed",
 }