add task creation process

Author: benjamin-747

package-lock.json

@@ -17,6 +17,7 @@
     "test": "vitest"
   },
   "dependencies": {
+    "axios": "^1.7.9",
     "js-yaml": "4.1.0",
     "node-fetch": "^3.3.2",
     "pino": "^9.6.0",
@@ -36,4 +37,4 @@
     "node": ">= 18"
   },
   "type": "module"
-}
+}

package.json

@@ -0,0 +1,66 @@
+import axios, { AxiosResponse } from "axios";
+
+export interface Config {
+    repos: Repo[];
+    project: projectComment,
+    task: TaskComment,
+}
+
+interface projectComment {
+    noneProjectComment: string,
+    noneMaintainerComment: string,
+}
+
+interface TaskComment {
+    scoreUndefinedComment: string,
+    scoreInvalidComment: string,
+    insufficientScoreComment: string,
+    toomanyTask: string,
+}
+
+interface Repo {
+    name: string,
+    maintainers: string[]
+}
+
+
+interface ApiResponse<T> {
+    message: string;
+    data: T;
+}
+
+export const fetchData = async <T>(url: string): Promise<ApiResponse<T>> => {
+    try {
+        const response: AxiosResponse<ApiResponse<T>> = await axios.get(url, {
+            headers: {
+                'Content-Type': 'application/json',
+            },
+        });
+        console.log('External API response:', response.data);
+        return response.data;
+    } catch (error: any) {
+        console.error('Error fetching external API:', error);
+        return {
+            message: error.message || 'Unknown error occurred',
+            data: null,
+        } as ApiResponse<T>;
+    }
+};
+
+export const postData = async <T, U>(url: string, payload: U): Promise<ApiResponse<T>> => {
+    try {
+        const response: AxiosResponse<ApiResponse<T>> = await axios.post(url, payload, {
+            headers: {
+                'Content-Type': 'application/json',
+            },
+        });
+        console.log('External API response:', response.data);
+        return response.data;
+    } catch (error: any) {
+        console.error('Error posting external API:', error);
+        return {
+            message: error.message || 'Unknown error occurred',
+            data: null,
+        } as ApiResponse<T>;
+    }
+};

src/common.ts

@@ -1,67 +1,68 @@
 import { Context, Probot } from "probot";
 import yaml from "js-yaml";
-
-interface Config {
-  traceRepos: string[];
-  taskMaintainers: string[];
-  noneProjectComment: string,
-  noneAdminComment: string,
-}
+import * as Task from "./task.js";
+import { Config } from "./common.js";
 
 export default (app: Probot) => {
-  app.on("issues.opened", async (context) => {
-    const issueComment = context.issue({
-      body: "Thanks for opening this issue!",
-    });
-
-    context.log.info("This issue is about context");
-    app.log.info("This issue is about app");
-    await context.octokit.issues.createComment(issueComment);
-  });
+  app.log.info(`api endpoint: ${process.env.API_ENDPOINT}`);
 
   app.on(["issue_comment.created", "issue_comment.edited"], async (context) => {
     const comment = context.payload.comment;
-    const config = await loadConfig(context);
+    const config = await fetchConfig(context);
     if (comment.user.type === "Bot") {
       context.log.debug("This comment was posted by a bot!");
       return
     }
     const labels = context.payload.issue.labels;
-    const hasLabel = labels.some((label) => label.name === "r2cn");
+    const hasLabel = labels.some((label) => label.name.startsWith("r2cn"));
     const creator = context.payload.issue.user.login;
-    const full_name = context.payload.repository.full_name;
+    const repo_full_name = context.payload.repository.full_name;
 
     if (hasLabel && config !== null) {
-      if (!config.taskMaintainers.includes(creator)) {
-        context.log.debug("none admin")
+      const repo = config.repos.find((repo) => repo.name === repo_full_name);
+      if (!repo) {
         await context.octokit.issues.createComment(context.issue({
-          body: config.noneAdminComment,
+          body: config.project.noneProjectComment,
         }));
         return
       }
-      if (!config.traceRepos.includes(full_name)) {
-        context.log.debug("none project")
+
+      if (!repo.maintainers.includes(creator)) {
         await context.octokit.issues.createComment(context.issue({
-          body: config.noneProjectComment,
+          body: config.project.noneMaintainerComment,
         }));
         return
       }
-      // call api check task status and points.
-      await context.octokit.issues.createComment(context.issue({
-        body: "Task created successfully.",
-      }));
+      const task = await Task.getTask(context.payload.issue.id);
+      if (task == null) {
+        let checkRes: Task.CheckTaskResults = await Task.checkTask(context.payload.repository, context.payload.issue, config);
+        if (checkRes.result) {
+          let newTaskRes = await Task.newTask(context.payload.repository, context.payload.issue, checkRes.score);
+          if (newTaskRes) {
+            await context.octokit.issues.createComment(context.issue({
+              body: "Task created successfully."
+            }));
+          }
+        } else {
+          await context.octokit.issues.createComment(context.issue({
+            body: checkRes.message
+          }));
+        }
+      } else {
+        context.log.debug("Task exist, skipping...")
+      }
     } else {
-      context.log.info("didn't have r2cn label")
+      context.log.error("R2cn label not found or config parsing error")
     }
   });
 };
 
 
-async function loadConfig(context: Context) {
+async function fetchConfig(context: Context) {
   const response = await context.octokit.repos.getContent({
     owner: "r2cn-dev",
     repo: "organization",
-    path: ".github/config.yaml",
+    path: "organization.yaml",
   });
 
   if ("type" in response.data && response.data.type === "file") {

src/index.ts

@@ -0,0 +1,105 @@
+import { Issue, Repository } from "@octokit/webhooks-types";
+import { Config, fetchData, postData } from "./common.js";
+
+interface Task {
+    github_repo_id: number,
+    github_issue_id: number,
+    points?: number,
+    task_status: TaskStatus,
+    student_github_id?: number,
+    mentor_github_id: number,
+}
+
+enum TaskStatus {
+    Open,
+    Invalid,
+    RequestAssign,
+    Assigned,
+    RequestFinish,
+    Finished,
+}
+
+export async function getTask(issue_id: number) {
+    const apiUrl = `${process.env.API_ENDPOINT}/task/issue/${issue_id}`;
+    const res = await fetchData<Task>(apiUrl).then((res) => {
+        return res.data
+    });
+    return res
+}
+
+interface newTask {
+    github_repo_id: number,
+    github_issue_id: number,
+    score: number,
+    mentor_github_id: number,
+}
+
+export async function newTask(repo: Repository, issue: Issue, score: number) {
+    let req = {
+        github_repo_id: repo.id,
+        github_issue_id: issue.id,
+        score: score,
+        mentor_github_id: issue.user.id,
+    }
+    const apiUrl = `${process.env.API_ENDPOINT}/task/new`;
+    const res = await postData<Task[], SearchTaskReq>(apiUrl, req).then((res) => {
+        return res.data
+    });
+    if (res != undefined) {
+        return true
+    } else {
+        return false
+    }
+}
+
+export interface CheckTaskResults {
+    result: boolean,
+    message: string,
+    score: number,
+}
+
+interface SearchTaskReq {
+    github_repo_id: number
+}
+export async function checkTask(repo: Repository, issue: Issue, config: Config) {
+
+    const label = issue.labels?.find(label => label.name.startsWith("r2cn"));
+    var scoreStr = label?.name.split('-')[1];
+    var score = 0;
+    var fail_res = {
+        result: false,
+        message: "",
+        score: 0
+    };
+
+    if (scoreStr == undefined) {
+        fail_res.message = config.task.scoreUndefinedComment;
+        return fail_res
+    } else {
+        score = parseInt(scoreStr)
+    }
+
+    if (score > 50 || score < 2) {
+        fail_res.message = config.task.scoreInvalidComment;
+        return fail_res
+    }
+
+    const apiUrl = `${process.env.API_ENDPOINT}/task/search`;
+    let req = {
+        github_repo_id: repo.id
+    }
+    const tasks: Task[] = await postData<Task[], SearchTaskReq>(apiUrl, req).then((res) => {
+        return res.data
+    });
+
+    if (tasks.length >= 3) {
+        fail_res.message = config.task.toomanyTask;
+        return fail_res
+    }
+
+    return {
+        result: true,
+        message: "",
+        score: score
+    }
+}