Backend/role count (#34)

* tmp

* 配属人数指定のUI

* 複数役職のDB処理

* 複数役職のminの締め切り制限・希望役職数表示

* 超過時に警告（暫定的）

* check

* fix

---------

Co-authored-by: naka-12 <[email protected]>

Author: nakomochi

biome.jsonc

@@ -37,6 +37,7 @@
         "noDefaultExport": "off",
         "noNamespaceImport": "off",
         "useBlockStatements": "off",
+        "noParameterProperties": "off",
       },
       "complexity": {
         "noExcessiveCognitiveComplexity": "off",

service/db/schema.ts

@@ -8,6 +8,7 @@ export const participants = sqliteTable("participants", {
     .references(() => projects.id, { onDelete: "cascade" })
     .notNull(),
   is_admin: integer("is_admin").notNull(),
+  roles_count: integer("roles_count"),
 });
 
 export const accounts = sqliteTable("accounts", {
@@ -21,6 +22,7 @@ export const projects = sqliteTable("projects", {
   name: text().notNull(),
   description: text(),
   closed_at: text(),
+  multiple_roles: integer().notNull(),
 });
 
 export const roles = sqliteTable("roles", {

service/routes/projects/index.ts

@@ -15,6 +15,7 @@ import { json, param } from "service/validator/hono.ts";
 import { assignRoles } from "share/logic/min-flow.ts";
 import { ProjectSchema } from "share/schema.ts";
 import * as v from "valibot";
+import { multipleMatch } from "share/logic/multiple.ts";
 
 import { at } from "share/lib.ts";
 import preferenceRoutes from "./preferences.ts";
@@ -68,6 +69,7 @@ const route = new Hono<HonoOptions>()
           .select({
             id: participants.id,
             name: participants.name,
+            roles_count: participants.roles_count,
           })
           .from(participants)
           .where(
@@ -115,6 +117,7 @@ const route = new Hono<HonoOptions>()
             id: project_id,
             name: body.name,
             description: body.description,
+            multiple_roles: body.multipleRoles,
           },
         ])
         .returning()
@@ -194,59 +197,143 @@ const route = new Hono<HonoOptions>()
       return c.json({ message: "Unauthorized" }, 401);
     }
 
-    await db(c)
-      .update(projects)
-      .set({
-        closed_at: new Date().toISOString(),
-      })
-      .where(eq(projects.id, projectId));
+    const projectData = (
+      await db(c).select().from(projects).where(eq(projects.id, projectId))
+    )[0];
 
-    const participantsData = await db(c)
-      .select()
-      .from(ratings)
-      .where(eq(ratings.project_id, projectId))
-      .orderBy(ratings.participant_id, ratings.role_id);
+    if (!projectData) {
+      throw new HTTPException(404, { message: "Project not found" });
+    }
 
-    const ratingsByParticipant = Map.groupBy(
-      participantsData,
-      (item) => item.participant_id,
-    );
+    if (projectData.closed_at) {
+      throw new HTTPException(409, { message: "Project already finalized" });
+    }
 
-    const ratingsArray: number[][] = []; // TODO: 型付けをマシにする
-    const participantIndexIdMap: string[] = [];
+    if (projectData.multiple_roles) {
+      // multiple mode
+      const participantsWithPreferences = await db(c)
+        .select({
+          id: participants.id,
+          rolesCount: participants.roles_count,
+          score: ratings.score,
+          roleId: ratings.role_id,
+        })
+        .from(participants)
+        .innerJoin(
+          ratings,
+          and(
+            eq(participants.id, ratings.participant_id),
+            eq(participants.project_id, ratings.project_id),
+          ),
+        )
+        .where(eq(participants.project_id, projectId));
 
-    ratingsByParticipant.forEach((r) => {
-      ratingsArray.push(r.map((item) => item.score));
-      participantIndexIdMap.push(r[0]?.participant_id ?? "-");
-    });
+      const preferencesByParticipant = Map.groupBy(
+        participantsWithPreferences,
+        (p) => p.id,
+      );
 
-    const roleConstraints = await db(c)
-      .select()
-      .from(roles)
-      .where(eq(roles.project_id, projectId))
-      .orderBy(roles.id);
-    const minMaxConstraints = roleConstraints.map((role) => ({
-      min: role.min,
-      max: role.max,
-    }));
+      const participantInput = Array.from(
+        preferencesByParticipant.entries(),
+      ).map(([participantId, preferences]) => ({
+        id: participantId,
+        rolesCount: preferences[0]?.rolesCount ?? 0,
+        preferences: preferences.map((p) => ({
+          roleId: p.roleId,
+          score: p.score,
+        })),
+      }));
 
-    const result = assignRoles(
-      ratingsArray,
-      at(ratingsArray, 0).length,
-      minMaxConstraints,
-    );
+      const roleConstraints = await db(c)
+        .select()
+        .from(roles)
+        .where(eq(roles.project_id, projectId))
+        .orderBy(roles.id);
 
-    await db(c)
-      .insert(matches)
-      .values(
-        result.map((r) => ({
-          id: crypto.randomUUID(),
-          project_id: projectId,
-          role_id: roleConstraints[r.role]?.id ?? "-",
-          participant_id: participantIndexIdMap[r.participant] ?? "-",
-        })),
+      const roleInput = roleConstraints.map((role) => ({
+        id: role.id,
+        capacity: role.max, // multiple mode の場合、max と min は同一
+      }));
+
+      console.log(participantInput);
+      console.log(roleInput);
+
+      const matching = multipleMatch(participantInput, roleInput);
+      console.log(matching);
+
+      const result: {
+        id: string;
+        project_id: string;
+        role_id: string;
+        participant_id: string;
+      }[] = [];
+      matching.forEach((m) => {
+        m.roleIds.forEach((roleId) => {
+          result.push({
+            id: crypto.randomUUID(),
+            project_id: projectId,
+            role_id: roleId,
+            participant_id: m.participantId,
+          });
+        });
+      });
+
+      await db(c).insert(matches).values(result);
+    } else {
+      // default mode
+      const participantsData = await db(c)
+        .select()
+        .from(ratings)
+        .where(eq(ratings.project_id, projectId))
+        .orderBy(ratings.participant_id, ratings.role_id);
+
+      const ratingsByParticipant = Map.groupBy(
+        participantsData,
+        (item) => item.participant_id,
       );
 
+      const ratingsArray: number[][] = []; // TODO: 型付けをマシにする
+      const participantIndexIdMap: string[] = [];
+
+      ratingsByParticipant.forEach((r) => {
+        ratingsArray.push(r.map((item) => item.score));
+        participantIndexIdMap.push(r[0]?.participant_id ?? "-");
+      });
+
+      const roleConstraints = await db(c)
+        .select()
+        .from(roles)
+        .where(eq(roles.project_id, projectId))
+        .orderBy(roles.id);
+      const minMaxConstraints = roleConstraints.map((role) => ({
+        min: role.min,
+        max: role.max,
+      }));
+
+      const result = assignRoles(
+        ratingsArray,
+        at(ratingsArray, 0).length,
+        minMaxConstraints,
+      );
+
+      await db(c)
+        .insert(matches)
+        .values(
+          result.map((r) => ({
+            id: crypto.randomUUID(),
+            project_id: projectId,
+            role_id: roleConstraints[r.role]?.id ?? "-",
+            participant_id: participantIndexIdMap[r.participant] ?? "-",
+          })),
+        );
+    }
+    await db(c)
+      .update(projects)
+      .set({
+        closed_at: new Date().toISOString(),
+      })
+      .where(eq(projects.id, projectId));
+
     return c.json({}, 200);
   })
   .get("/:projectId/result", param({ projectId: v.string() }), async (c) => {

service/routes/projects/participants.ts

@@ -17,6 +17,7 @@ const route = new Hono<HonoOptions>().get(
         id: participants.id,
         name: participants.name,
         is_admin: participants.is_admin,
+        roles_count: participants.roles_count,
       })
       .from(participants)
       .where(

service/routes/projects/preferences.ts

@@ -45,6 +45,7 @@ const route = new Hono<HonoOptions>()
             browser_id: browser_id,
             project_id: projectId,
             is_admin: 0,
+            roles_count: body.rolesCount,
           })
           .returning()
       )[0];
@@ -83,6 +84,7 @@ const route = new Hono<HonoOptions>()
           .update(participants)
           .set({
             name: body.participantName,
+            roles_count: body.rolesCount || null,
           })
           .where(and(eq(participants.browser_id, browser_id)))
           .returning({ id: participants.id })