Skip to content

armgit / kaneo

Public Imported from GitHub
0

⚡ Project management that doesn't become the project. Boards, Gantt charts, and GitHub integration. Self-host it or use Kaneo Cloud.

4.9 KB
Raw Blame
import { withIntegrationTask } from "../../github/services/integration-task-scope";
import { publishEvent } from "../../../events";
import {
  createExternalLink,
  findExternalLink,
} from "../../github/services/link-manager";
import { resolvePullRequestTask } from "../../github/services/resolve-pull-request-task";
import { updateTaskStatus } from "../../github/services/task-service";
import type { GiteaConfig } from "../config";
import {
  findAllIntegrationsByGiteaRepo,
  repoOwnerLogin,
} from "../services/integration-lookup";
import { resolveTargetStatus } from "../utils/resolve-column";
import { baseUrlFromRepositoryHtmlUrl } from "../utils/webhook-repo";

type PROpenedPayload = {
  action: string;
  pull_request: {
    number: number;
    title: string;
    body: string | null;
    html_url: string;
    state: string;
    draft?: boolean;
    merged?: boolean;
    head: {
      ref: string;
    };
    user: { login?: string; username?: string } | null;
  };
  repository: {
    owner: { login?: string; username?: string };
    name: string;
    html_url: string;
  };
};

export async function handleGiteaPullRequestOpened(
  payload: PROpenedPayload,
  integrationId?: string,
) {
  const { pull_request, repository } = payload;

  const baseUrl = baseUrlFromRepositoryHtmlUrl(repository.html_url);
  if (!baseUrl) return;

  const owner = repoOwnerLogin(repository);
  const integrations = await findAllIntegrationsByGiteaRepo(
    baseUrl,
    owner,
    repository.name,
    integrationId,
  );

  const candidates = [];
  for (const integration of integrations) {
    if (!integration.project) {
      continue;
    }

    let config: GiteaConfig;
    try {
      config = JSON.parse(integration.config) as GiteaConfig;
    } catch (error) {
      console.error("Invalid Gitea config for integration", {
        integrationId: integration.id,
        error,
      });
      continue;
    }
    const existingLink = await findExternalLink(
      integration.id,
      "pull_request",
      pull_request.number.toString(),
    );
    if (existingLink) return;

    const task = await resolvePullRequestTask({
      integrationId: integration.id,
      projectId: integration.projectId,
      projectSlug: integration.project.slug,
      config,
      repositoryUrl: repository.html_url,
      pullRequest: pull_request,
    });
    if (task) candidates.push({ integration, config, task });
  }

  const candidate = candidates[0];
  if (candidates.length !== 1 || !candidate) return;
  const { integration, config, task } = candidate;
  if (integrationId && integration.id !== integrationId) return;
  const branchName = pull_request.head.ref;

  await withIntegrationTask(
    task.id,
    integration,
    async (database, afterCommit) => {
      const currentTask = await resolvePullRequestTask({
        integrationId: integration.id,
        projectId: integration.projectId,
        projectSlug: integration.project.slug,
        config,
        repositoryUrl: repository.html_url,
        pullRequest: pull_request,
        database,
      });
      if (currentTask?.id !== task.id) return;
      if (
        await findExternalLink(
          integration.id,
          "pull_request",
          pull_request.number.toString(),
          database,
        )
      )
        return;
      await createExternalLink(
        {
          taskId: task.id,
          integrationId: integration.id,
          resourceType: "pull_request",
          externalId: pull_request.number.toString(),
          url: pull_request.html_url,
          title: pull_request.title,
          metadata: {
            state: pull_request.state,
            draft: pull_request.draft,
            merged: pull_request.merged,
            branch: branchName,
            author: pull_request.user?.login ?? pull_request.user?.username,
          },
        },
        database,
      );

      afterCommit(() =>
        publishEvent("task.updated", {
          projectId: integration.projectId,
          taskId: task.id,
        }),
      );

      const targetStatus = await resolveTargetStatus(
        integration.projectId,
        "pr_opened",
        config.statusTransitions?.onPROpen || "in-review",
        database,
      );

      if (currentTask.status !== targetStatus) {
        const statusResult = await updateTaskStatus(
          task.id,
          targetStatus,
          database,
        );
        if (
          statusResult.applied &&
          statusResult.before.status !== statusResult.after.status
        ) {
          afterCommit(() =>
            publishEvent("task.status_changed", {
              taskId: statusResult.after.id,
              projectId: statusResult.after.projectId,
              userId: null,
              oldStatus: statusResult.before.status,
              newStatus: statusResult.after.status,
              title: statusResult.after.title,
              assigneeId: statusResult.after.userId,
              type: "status_changed",
            }),
          );
        }
      }
    },
  );
}