Teams App Developer

interface ApprovalRecord {
  id: string;
  title: string;
  description: string;
  requesterId: string;
  requesterName: string;
  status: "Pending" | "Approved" | "Rejected" | "Escalated";
  routingType: "single" | "sequential" | "parallel-any" | "parallel-all";
  approvers: ApproverEntry[];
  history: ApprovalHistoryEntry[];
  conversationId: string;
  cardActivityId: string;
  serviceUrl: string;
  createdAt: string;
  resolvedAt?: string;
}

interface ApproverEntry {
  userId: string;
  displayName: string;
  order: number; // For sequential routing
  decision?: "approved" | "rejected";
  decidedAt?: string;
}

interface ApprovalHistoryEntry {
  actor: string;
  action: string;
  comment?: string;
  timestamp: string;
}

function buildApprovalCard(record: ApprovalRecord, viewerUserId: string): object {
  const isApprover = record.approvers.some(
    (a) => a.userId === viewerUserId && !a.decision
  );
  const isPending = record.status === "Pending";

  return {
    type: "AdaptiveCard",
    version: "1.5",
    refresh: {
      action: {
        type: "Action.Execute",
        verb: "refreshApproval",
        data: { recordId: record.id },
      },
      userIds: record.approvers
        .filter((a) => !a.decision)
        .map((a) => a.userId),
    },
    body: [
      { type: "TextBlock", text: "Approval Request", weight: "Bolder", size: "Medium" },
      {
        type: "FactSet",
        facts: [
          { title: "From", value: record.requesterName },
          { title: "Status", value: record.status },
          { title: "Type", value: record.routingType },
          { title: "Created", value: new Date(record.createdAt).toLocaleString() },
        ],
      },
      { type: "TextBlock", text: record.description, wrap: true },
      // Approval history
      ...(record.history.length > 0
        ? [
            { type: "TextBlock", text: "History", weight: "Bolder", spacing: "Medium" },
            ...record.history.map((h) => ({
              type: "TextBlock",
              text: `${h.actor}: ${h.action}${h.comment ? ` - "${h.comment}"` : ""} (${new Date(h.timestamp).toLocaleString()})`,
              isSubtle: true,
              wrap: true,
              spacing: "None",
            })),
          ]
        : []),
      // Comment input (only for pending approvers)
      ...(isApprover && isPending
        ? [{
            type: "Input.Text",
            id: "comment",
            placeholder: "Optional comment...",
            isMultiline: false,
          }]
        : []),
    ],
    actions:
      isApprover && isPending
        ? [
            {
              type: "Action.Execute",
              title: "Approve",
              verb: "approve",
              data: { recordId: record.id },
              style: "positive",
            },
            {
              type: "Action.Execute",
              title: "Reject",
              verb: "reject",
              data: { recordId: record.id },
              style: "destructive",
            },
          ]
        : [],
  };
}

app.on("card.action", async (ctx) => {
  const { verb, recordId } = ctx.activity.value?.action?.data ?? {};
  const comment = ctx.activity.value?.action?.data?.comment;
  const actorId = ctx.activity.from?.aadObjectId!;
  const actorName = ctx.activity.from?.name ?? "Unknown";

  if (verb !== "approve" && verb !== "reject" && verb !== "refreshApproval") return;

  const record = await getApprovalRecord(recordId);
  if (!record) return { status: 200, body: { statusCode: 200, type: "application/vnd.microsoft.card.adaptive", value: {} } };

  if (verb === "refreshApproval") {
    return {
      status: 200,
      body: {
        statusCode: 200,
        type: "application/vnd.microsoft.card.adaptive",
        value: buildApprovalCard(record, actorId),
      },
    };
  }

  // Record the decision
  const approver = record.approvers.find((a) => a.userId === actorId && !a.decision);
  if (!approver) {
    return { status: 200, body: { statusCode: 200, type: "application/vnd.microsoft.card.adaptive", value: buildApprovalCard(record, actorId) } };
  }

  approver.decision = verb === "approve" ? "approved" : "rejected";
  approver.decidedAt = new Date().toISOString();
  record.history.push({
    actor: actorName,
    action: verb === "approve" ? "Approved" : "Rejected",
    comment,
    timestamp: new Date().toISOString(),
  });

  // Evaluate routing
  record.status = evaluateApprovalStatus(record);

  // If sequential and approved, notify next approver
  if (record.status === "Pending" && record.routingType === "sequential") {
    const nextApprover = record.approvers.find((a) => !a.decision);
    if (nextApprover) {
      // Proactive notify next approver
      await notifyApprover(nextApprover, record);
    }
  }

  // Persist
  await updateApprovalRecord(record);

  // Notify requester on resolution
  if (record.status === "Approved" || record.status === "Rejected") {
    record.resolvedAt = new Date().toISOString();
    await notifyRequester(record);
  }

  return {
    status: 200,
    body: {
      statusCode: 200,
      type: "application/vnd.microsoft.card.adaptive",
      value: buildApprovalCard(record, actorId),
    },
  };
});

function evaluateApprovalStatus(record: ApprovalRecord): ApprovalRecord["status"] {
  const decisions = record.approvers.filter((a) => a.decision);

  switch (record.routingType) {
    case "single":
      return decisions[0]?.decision === "approved" ? "Approved" : "Rejected";

    case "sequential":
      if (decisions.some((d) => d.decision === "rejected")) return "Rejected";
      if (decisions.length === record.approvers.length) return "Approved";
      return "Pending";

    case "parallel-any":
      if (decisions.some((d) => d.decision === "approved")) return "Approved";
      if (decisions.length === record.approvers.length) return "Rejected";
      return "Pending";

    case "parallel-all":
      if (decisions.some((d) => d.decision === "rejected")) return "Rejected";
      if (decisions.length === record.approvers.length) return "Approved";
      return "Pending";

    default:
      return "Pending";
  }
}

async function startEscalationTimer(record: ApprovalRecord, timeoutMs: number = 24 * 60 * 60 * 1000) {
  setTimeout(async () => {
    const current = await getApprovalRecord(record.id);
    if (current?.status !== "Pending") return; // Already resolved

    // Look up manager
    const pendingApprover = current.approvers.find((a) => !a.decision);
    if (!pendingApprover) return;

    const manager = await graphClient
      .api(`/users/${pendingApprover.userId}/manager`)
      .get();

    current.status = "Escalated";
    current.history.push({
      actor: "System",
      action: `Escalated to ${manager.displayName} (timeout after ${timeoutMs / 3600000}h)`,
      timestamp: new Date().toISOString(),
    });

    // Replace approver with manager
    pendingApprover.userId = manager.id;
    pendingApprover.displayName = manager.displayName;
    current.status = "Pending"; // Reset to pending for new approver

    await updateApprovalRecord(current);
    await updateRecordCardInThread(adapter, current);
  }, timeoutMs);
}