nexarch/web/workflow-tasks/lib/api.ts

// Duenner Client fuer die eigenen Backend-for-Frontend-Routen unter
// app/api — kein direkter Zugriff auf workflow/internal/taskapi vom Client
// aus, gleiches Muster wie web/routing-rules/web/workflow-cases.

import { apiFetch } from "./http";

export class ApiError extends Error {
  status: number;
  constructor(message: string, status: number) {
    super(message);
    this.status = status;
  }
}

export type TaskStatus = "open" | "in_progress" | "done";
export type Priority = "low" | "normal" | "high";

export interface Reference {
  ModuleName: string;
  ObjectType: string;
  ObjectID: string;
}

export interface Task {
  ID: string;
  Title: string;
  AssigneeType: "person" | "group";
  AssigneeID: string;
  Priority: Priority;
  References: Reference[] | null;
  DueDate: string | null;
  Status: TaskStatus;
}

async function handle<T>(res: Response): Promise<T> {
  const body = await res.json().catch(() => null);
  if (!res.ok) {
    const message =
      body && typeof body === "object" && "error" in body && typeof (body as { error: unknown }).error === "string"
        ? (body as { error: string }).error
        : "Anfrage fehlgeschlagen";
    throw new ApiError(message, res.status);
  }
  return body as T;
}

export async function listTasks(userId: string, tenantSlug: string): Promise<Task[]> {
  const res = await apiFetch(
    `/api/tasks?userId=${encodeURIComponent(userId)}&tenant=${encodeURIComponent(tenantSlug)}`,
    { cache: "no-store" }
  );
  return handle<Task[]>(res);
}

export async function setTaskStatus(
  userId: string,
  tenantSlug: string,
  id: string,
  status: TaskStatus
): Promise<void> {
  const res = await apiFetch(
    `/api/tasks/${encodeURIComponent(id)}/status?userId=${encodeURIComponent(userId)}&tenant=${encodeURIComponent(tenantSlug)}`,
    {
      method: "PATCH",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify({ status }),
    }
  );
  if (res.status !== 204) {
    await handle(res);
  }
}

// Ueberfaellig (Akzeptanzkriterium 1): eine offene/in Bearbeitung befindliche
// Aufgabe mit einer Faelligkeit in der Vergangenheit. Erledigte Aufgaben
// gelten nie als ueberfaellig.
export function isOverdue(task: Task, now: Date = new Date()): boolean {
  if (task.Status === "done" || !task.DueDate) {
    return false;
  }
  return new Date(task.DueDate).getTime() < now.getTime();
}