feat: add survey view with voting functionality and admin panel

- Implemented SurveyView.vue for displaying and managing polls, including voting, comments, and results. - Added new database tables for vote polls, votes, and comments in migration script. - Created unique lottery logic for handling unique item rewards based on voting. - Developed unit tests for unique lottery functionality to ensure deterministic behavior and correct counting of occupied unique items.
2026-02-03 18:25:26 +00:00
parent d3277f204a
commit b0a8f768e9
15 changed files with 2531 additions and 22 deletions
@@ -22,6 +22,7 @@ import { diplomacyRouter } from './router/diplomacy/index.js';
 import { yearbookRouter } from './router/yearbook/index.js';
 import { rankingRouter } from './router/ranking/index.js';
 import { dynastyRouter } from './router/dynasty/index.js';
+import { voteRouter } from './router/vote/index.js';

 export const appRouter = router({
    health: healthRouter,
@@ -46,6 +47,7 @@ export const appRouter = router({
    yearbook: yearbookRouter,
    ranking: rankingRouter,
    dynasty: dynastyRouter,
+    vote: voteRouter,
 });

 export type AppRouter = typeof appRouter;
@@ -0,0 +1,675 @@
+import { TRPCError } from '@trpc/server';
+import { z } from 'zod';
+
+import { asRecord, LiteHashDRBG, RandUtil } from '@sammo-ts/common';
+import { GamePrisma } from '@sammo-ts/infra';
+import {
+    ITEM_KEYS,
+    buildVoteUniqueSeed,
+    countOccupiedUniqueItems,
+    createItemModuleRegistry,
+    loadItemModules,
+    resolveUniqueConfig,
+    rollUniqueLottery,
+    type GeneralItemSlots,
+    type ItemModule,
+} from '@sammo-ts/logic';
+
+import { authedProcedure, router } from '../../trpc.js';
+import { getMyGeneral } from '../shared/general.js';
+
+const hasAdminRole = (roles: string[], profileName: string): boolean => {
+    if (roles.includes('superuser') || roles.includes('admin') || roles.includes('admin.superuser')) {
+        return true;
+    }
+    return roles.some((role) => role === 'admin.survey' || role === `admin.survey:${profileName}`);
+};
+
+const adminProcedure = authedProcedure.use(({ ctx, next }) => {
+    const roles = ctx.auth?.user.roles ?? [];
+    if (!hasAdminRole(roles, ctx.profile.name)) {
+        throw new TRPCError({ code: 'FORBIDDEN', message: 'Admin permission is required.' });
+    }
+    return next();
+});
+
+let itemRegistryPromise: Promise<Map<string, ItemModule>> | null = null;
+
+const getItemRegistry = async (): Promise<Map<string, ItemModule>> => {
+    if (!itemRegistryPromise) {
+        itemRegistryPromise = loadItemModules([...ITEM_KEYS]).then((modules) => createItemModuleRegistry(modules));
+    }
+    return itemRegistryPromise;
+};
+
+const resolveNumber = (source: Record<string, unknown>, keys: string[], fallback: number): number => {
+    for (const key of keys) {
+        const value = source[key];
+        if (typeof value === 'number' && Number.isFinite(value)) {
+            return value;
+        }
+        if (typeof value === 'string') {
+            const parsed = Number(value);
+            if (Number.isFinite(parsed)) {
+                return parsed;
+            }
+        }
+    }
+    return fallback;
+};
+
+const normalizeCode = (value: string | null | undefined): string | null => {
+    if (!value || value === 'None') {
+        return null;
+    }
+    return value;
+};
+
+const normalizeOptions = (options: string[]): string[] =>
+    options
+        .map((option) => option.trim())
+        .filter((option) => option.length > 0);
+
+const readMetaNumber = (meta: Record<string, unknown>, key: string, fallback: number): number => {
+    const value = meta[key];
+    if (typeof value === 'number' && Number.isFinite(value)) {
+        return Math.floor(value);
+    }
+    if (typeof value === 'string') {
+        const parsed = Number(value);
+        if (Number.isFinite(parsed)) {
+            return Math.floor(parsed);
+        }
+    }
+    return fallback;
+};
+
+const parseOptions = (value: unknown): string[] => {
+    if (Array.isArray(value)) {
+        return value.filter((entry): entry is string => typeof entry === 'string');
+    }
+    if (typeof value === 'string') {
+        try {
+            const parsed = JSON.parse(value);
+            if (Array.isArray(parsed)) {
+                return parsed.filter((entry): entry is string => typeof entry === 'string');
+            }
+        } catch {
+            return [];
+        }
+    }
+    return [];
+};
+
+const parseSelection = (value: unknown): number[] => {
+    if (Array.isArray(value)) {
+        return value.map((entry) => Number(entry)).filter((entry) => Number.isFinite(entry));
+    }
+    if (typeof value === 'string') {
+        try {
+            const parsed = JSON.parse(value);
+            if (Array.isArray(parsed)) {
+                return parsed.map((entry) => Number(entry)).filter((entry) => Number.isFinite(entry));
+            }
+        } catch {
+            return [];
+        }
+    }
+    return [];
+};
+
+type VotePollRow = {
+    id: number;
+    title: string;
+    body: string;
+    options: unknown;
+    multiple_options: number;
+    reveal_mode: string;
+    opener_general_id: number;
+    opener_name: string;
+    start_at: Date;
+    end_at: Date | null;
+    closed_at: Date | null;
+};
+
+type VoteListRow = {
+    id: number;
+    title: string;
+    start_at: Date;
+    end_at: Date | null;
+    closed_at: Date | null;
+    reveal_mode: string;
+    multiple_options: number;
+    options_count: number;
+};
+
+type VoteCommentRow = {
+    id: number;
+    vote_id: number;
+    general_id: number;
+    nation_id: number;
+    general_name: string;
+    nation_name: string;
+    text: string;
+    created_at: Date;
+};
+
+type VoteResultRow = {
+    selection: unknown;
+    cnt: number | bigint;
+};
+
+const zRevealMode = z.enum(['after_vote', 'after_end']);
+
+export const voteRouter = router({
+    getVoteList: authedProcedure.query(async ({ ctx }) => {
+        const worldState = await ctx.db.worldState.findFirst();
+        const config = asRecord(worldState?.config ?? {});
+        const constValues = asRecord(config.const);
+        const develCost = resolveNumber(constValues, ['develCost', 'develcost', 'develrate'], 0);
+        const voteReward = develCost * 5;
+
+        const rows = await ctx.db.$queryRaw<VoteListRow[]>(GamePrisma.sql`
+            SELECT
+                id,
+                title,
+                start_at,
+                end_at,
+                closed_at,
+                reveal_mode,
+                multiple_options,
+                jsonb_array_length(options) AS options_count
+            FROM vote_poll
+            ORDER BY id DESC
+        `);
+
+        const polls = rows.map((row) => ({
+            id: row.id,
+            title: row.title,
+            startAt: row.start_at.toISOString(),
+            endAt: row.end_at ? row.end_at.toISOString() : null,
+            closedAt: row.closed_at ? row.closed_at.toISOString() : null,
+            revealMode: row.reveal_mode as 'after_vote' | 'after_end',
+            optionsCount: Number(row.options_count ?? 0),
+            multipleOptions: row.multiple_options,
+        }));
+
+        return { polls, voteReward };
+    }),
+    getVoteDetail: authedProcedure
+        .input(z.object({ voteId: z.number().int().positive() }))
+        .query(async ({ ctx, input }) => {
+            const rows = await ctx.db.$queryRaw<VotePollRow[]>(GamePrisma.sql`
+                SELECT
+                    id,
+                    title,
+                    body,
+                    options,
+                    multiple_options,
+                    reveal_mode,
+                    opener_general_id,
+                    opener_name,
+                    start_at,
+                    end_at,
+                    closed_at
+                FROM vote_poll
+                WHERE id = ${input.voteId}
+                LIMIT 1
+            `);
+            const row = rows[0];
+            if (!row) {
+                throw new TRPCError({ code: 'NOT_FOUND', message: '설문조사가 없습니다.' });
+            }
+
+            const options = parseOptions(row.options);
+            const pollEnded = Boolean(row.closed_at) || (row.end_at ? row.end_at <= new Date() : false);
+
+            const userId = ctx.auth?.user.id;
+            const general = userId
+                ? await ctx.db.general.findFirst({ where: { userId }, select: { id: true } })
+                : null;
+
+            const [comments, userCnt, myVoteRow] = await Promise.all([
+                ctx.db.$queryRaw<VoteCommentRow[]>(GamePrisma.sql`
+                    SELECT
+                        id,
+                        vote_id,
+                        general_id,
+                        nation_id,
+                        general_name,
+                        nation_name,
+                        text,
+                        created_at
+                    FROM vote_comment
+                    WHERE vote_id = ${input.voteId}
+                    ORDER BY created_at ASC
+                `),
+                ctx.db.general.count({ where: { npcState: { lt: 2 } } }),
+                general
+                    ? ctx.db.$queryRaw<Array<{ selection: unknown }>>(GamePrisma.sql`
+                          SELECT selection
+                          FROM vote
+                          WHERE vote_id = ${input.voteId} AND general_id = ${general.id}
+                          LIMIT 1
+                      `)
+                    : Promise.resolve([]),
+            ]);
+
+            const myVote = myVoteRow[0]?.selection ? parseSelection(myVoteRow[0].selection) : null;
+
+            const canReveal = row.reveal_mode === 'after_vote'
+                ? Boolean(myVote) || pollEnded
+                : pollEnded;
+
+            const voteResults = canReveal
+                ? await ctx.db.$queryRaw<VoteResultRow[]>(GamePrisma.sql`
+                      SELECT selection, count(*) as cnt
+                      FROM vote
+                      WHERE vote_id = ${input.voteId}
+                      GROUP BY selection
+                  `)
+                : [];
+
+            const votes = voteResults.map((entry) => ({
+                selection: parseSelection(entry.selection),
+                count: Number(entry.cnt),
+            }));
+
+            return {
+                voteInfo: {
+                    id: row.id,
+                    title: row.title,
+                    body: row.body,
+                    options,
+                    multipleOptions: row.multiple_options,
+                    revealMode: row.reveal_mode as 'after_vote' | 'after_end',
+                    openerGeneralId: row.opener_general_id,
+                    openerName: row.opener_name,
+                    startAt: row.start_at.toISOString(),
+                    endAt: row.end_at ? row.end_at.toISOString() : null,
+                    closedAt: row.closed_at ? row.closed_at.toISOString() : null,
+                },
+                votes,
+                comments: comments.map((comment) => ({
+                    id: comment.id,
+                    voteId: comment.vote_id,
+                    generalId: comment.general_id,
+                    nationId: comment.nation_id,
+                    generalName: comment.general_name,
+                    nationName: comment.nation_name,
+                    text: comment.text,
+                    createdAt: comment.created_at.toISOString(),
+                })),
+                myVote,
+                userCnt,
+            };
+        }),
+    submitVote: authedProcedure
+        .input(
+            z.object({
+                voteId: z.number().int().positive(),
+                selection: z.array(z.number().int()),
+            })
+        )
+        .mutation(async ({ ctx, input }) => {
+            const selection = input.selection;
+            if (!selection || selection.length === 0) {
+                throw new TRPCError({ code: 'BAD_REQUEST', message: '선택한 항목이 없습니다.' });
+            }
+
+            const pollRows = await ctx.db.$queryRaw<VotePollRow[]>(GamePrisma.sql`
+                SELECT
+                    id,
+                    title,
+                    body,
+                    options,
+                    multiple_options,
+                    reveal_mode,
+                    opener_general_id,
+                    opener_name,
+                    start_at,
+                    end_at,
+                    closed_at
+                FROM vote_poll
+                WHERE id = ${input.voteId}
+                LIMIT 1
+            `);
+            const poll = pollRows[0];
+            if (!poll) {
+                throw new TRPCError({ code: 'NOT_FOUND', message: '설문조사가 없습니다.' });
+            }
+            if (poll.closed_at || (poll.end_at && poll.end_at < new Date())) {
+                throw new TRPCError({ code: 'BAD_REQUEST', message: '설문조사가 종료되었습니다.' });
+            }
+
+            const options = parseOptions(poll.options);
+            if (poll.multiple_options >= 1 && selection.length > poll.multiple_options) {
+                throw new TRPCError({ code: 'BAD_REQUEST', message: '선택한 항목이 너무 많습니다.' });
+            }
+
+            const optionCount = options.length;
+            for (const value of selection) {
+                if (!Number.isFinite(value) || value < 0 || value >= optionCount) {
+                    throw new TRPCError({ code: 'BAD_REQUEST', message: '선택한 항목이 없습니다.' });
+                }
+            }
+
+            const sortedSelection = [...selection].sort((a, b) => a - b);
+            const general = await getMyGeneral(ctx);
+
+            const rows = await ctx.db.$queryRaw<Array<{ id: number }>>(GamePrisma.sql`
+                INSERT INTO vote (vote_id, general_id, nation_id, selection)
+                VALUES (
+                    ${input.voteId},
+                    ${general.id},
+                    ${general.nationId},
+                    CAST(${JSON.stringify(sortedSelection)} AS jsonb)
+                )
+                ON CONFLICT (vote_id, general_id) DO NOTHING
+                RETURNING id
+            `);
+
+            if (!rows[0]?.id) {
+                throw new TRPCError({ code: 'BAD_REQUEST', message: '이미 설문조사를 완료하였습니다.' });
+            }
+
+            const worldState = await ctx.db.worldState.findFirst();
+            if (!worldState) {
+                throw new TRPCError({ code: 'PRECONDITION_FAILED', message: 'World state is not initialized.' });
+            }
+
+            const config = asRecord(worldState.config);
+            const constValues = asRecord(config.const);
+            const develCost = resolveNumber(constValues, ['develCost', 'develcost', 'develrate'], 0);
+            const voteReward = develCost * 5;
+
+            const worldMeta = asRecord(worldState.meta);
+            const scenarioMeta = asRecord(worldMeta.scenarioMeta);
+            const startYear = readMetaNumber(scenarioMeta, 'startYear', worldState.currentYear);
+            const initYear = readMetaNumber(worldMeta, 'initYear', startYear);
+            const initMonth = readMetaNumber(worldMeta, 'initMonth', 1);
+            const scenarioId = readMetaNumber(worldMeta, 'scenarioId', 0);
+            const hiddenSeed = worldMeta.hiddenSeed ?? worldMeta.seed ?? worldState.id;
+
+            const itemRegistry = await getItemRegistry();
+            const uniqueConfig = resolveUniqueConfig(constValues);
+
+            const generalRows = await ctx.db.general.findMany({
+                select: {
+                    horseCode: true,
+                    weaponCode: true,
+                    bookCode: true,
+                    itemCode: true,
+                },
+            });
+            const generalItems: GeneralItemSlots[] = generalRows.map((row) => ({
+                horse: normalizeCode(row.horseCode),
+                weapon: normalizeCode(row.weaponCode),
+                book: normalizeCode(row.bookCode),
+                item: normalizeCode(row.itemCode),
+            }));
+
+            const occupiedUniqueCounts = countOccupiedUniqueItems(generalItems, itemRegistry);
+            const userCount = await ctx.db.general.count({ where: { npcState: { lt: 2 } } });
+
+            const rngSeed = buildVoteUniqueSeed(
+                typeof hiddenSeed === 'string' || typeof hiddenSeed === 'number' ? hiddenSeed : String(hiddenSeed),
+                input.voteId,
+                general.id
+            );
+            const rng = new RandUtil(LiteHashDRBG.build(rngSeed));
+            const itemKey = rollUniqueLottery({
+                rng,
+                config: uniqueConfig,
+                itemRegistry,
+                generalItems: {
+                    horse: normalizeCode(general.horseCode),
+                    weapon: normalizeCode(general.weaponCode),
+                    book: normalizeCode(general.bookCode),
+                    item: normalizeCode(general.itemCode),
+                },
+                occupiedUniqueCounts,
+                scenarioId,
+                userCount,
+                currentYear: worldState.currentYear,
+                currentMonth: worldState.currentMonth,
+                startYear,
+                initYear,
+                initMonth,
+                acquireType: '설문조사',
+            });
+
+            const rewardResult = await ctx.turnDaemon.requestCommand({
+                type: 'voteReward',
+                voteId: input.voteId,
+                generalId: general.id,
+                goldReward: voteReward,
+                unique: {
+                    expected: Boolean(itemKey),
+                    itemKey: itemKey ?? null,
+                },
+            });
+
+            if (!rewardResult || rewardResult.type !== 'voteReward') {
+                throw new TRPCError({ code: 'INTERNAL_SERVER_ERROR', message: 'Unexpected response' });
+            }
+            if (!rewardResult.ok) {
+                throw new TRPCError({ code: 'BAD_REQUEST', message: rewardResult.reason });
+            }
+
+            return { ok: true, wonLottery: rewardResult.awardedUnique };
+        }),
+    addComment: authedProcedure
+        .input(
+            z.object({
+                voteId: z.number().int().positive(),
+                text: z.string().trim().max(200),
+            })
+        )
+        .mutation(async ({ ctx, input }) => {
+            if (!input.text) {
+                throw new TRPCError({ code: 'BAD_REQUEST', message: '내용이 필요합니다.' });
+            }
+
+            const pollRows = await ctx.db.$queryRaw<Array<{ id: number }>>(GamePrisma.sql`
+                SELECT id
+                FROM vote_poll
+                WHERE id = ${input.voteId}
+                LIMIT 1
+            `);
+            if (!pollRows[0]?.id) {
+                throw new TRPCError({ code: 'NOT_FOUND', message: '설문조사가 없습니다.' });
+            }
+
+            const general = await getMyGeneral(ctx);
+            const nation = general.nationId
+                ? await ctx.db.nation.findFirst({ where: { id: general.nationId }, select: { name: true } })
+                : null;
+            const nationName = nation?.name ?? '재야';
+
+            await ctx.db.$queryRaw(GamePrisma.sql`
+                INSERT INTO vote_comment (vote_id, general_id, nation_id, general_name, nation_name, text)
+                VALUES (${input.voteId}, ${general.id}, ${general.nationId}, ${general.name}, ${nationName}, ${input.text})
+            `);
+
+            return { ok: true };
+        }),
+    createPoll: adminProcedure
+        .input(
+            z.object({
+                title: z.string().trim().min(1).max(200),
+                body: z.string().trim().max(5000).optional().default(''),
+                options: z.array(z.string()).default([]),
+                multipleOptions: z.number().int().optional().default(1),
+                endAt: z.string().optional(),
+                revealMode: zRevealMode,
+                closePrevious: z.boolean().optional().default(true),
+            })
+        )
+        .mutation(async ({ ctx, input }) => {
+            const general = await getMyGeneral(ctx);
+            const options = normalizeOptions(input.options);
+            if (options.length === 0) {
+                throw new TRPCError({ code: 'BAD_REQUEST', message: '항목이 없습니다.' });
+            }
+
+            const endAt = input.endAt ? new Date(input.endAt) : null;
+            if (endAt && Number.isNaN(endAt.getTime())) {
+                throw new TRPCError({ code: 'BAD_REQUEST', message: '종료일이 잘못되었습니다.' });
+            }
+            if (endAt && endAt < new Date()) {
+                throw new TRPCError({ code: 'BAD_REQUEST', message: '종료일이 이미 지났습니다.' });
+            }
+
+            let multipleOptions = input.multipleOptions;
+            if (multipleOptions < 0) {
+                multipleOptions = 0;
+            }
+            if (multipleOptions > options.length) {
+                multipleOptions = options.length;
+            }
+
+            if (input.closePrevious) {
+                await ctx.db.$queryRaw(GamePrisma.sql`
+                    UPDATE vote_poll
+                    SET closed_at = NOW(), updated_at = NOW()
+                    WHERE closed_at IS NULL
+                `);
+            }
+
+            await ctx.db.$queryRaw(GamePrisma.sql`
+                INSERT INTO vote_poll (
+                    title,
+                    body,
+                    options,
+                    multiple_options,
+                    reveal_mode,
+                    opener_general_id,
+                    opener_name,
+                    start_at,
+                    end_at
+                )
+                VALUES (
+                    ${input.title},
+                    ${input.body ?? ''},
+                    CAST(${JSON.stringify(options)} AS jsonb),
+                    ${multipleOptions},
+                    ${input.revealMode},
+                    ${general.id},
+                    ${general.name},
+                    NOW(),
+                    ${endAt}
+                )
+            `);
+
+            return { ok: true };
+        }),
+    updatePoll: adminProcedure
+        .input(
+            z.object({
+                voteId: z.number().int().positive(),
+                title: z.string().trim().min(1).max(200).optional(),
+                body: z.string().trim().max(5000).optional(),
+                appendOptions: z.array(z.string()).optional(),
+                multipleOptions: z.number().int().optional(),
+                endAt: z.string().optional(),
+                revealMode: zRevealMode.optional(),
+            })
+        )
+        .mutation(async ({ ctx, input }) => {
+            const pollRows = await ctx.db.$queryRaw<VotePollRow[]>(GamePrisma.sql`
+                SELECT
+                    id,
+                    title,
+                    body,
+                    options,
+                    multiple_options,
+                    reveal_mode,
+                    opener_general_id,
+                    opener_name,
+                    start_at,
+                    end_at,
+                    closed_at
+                FROM vote_poll
+                WHERE id = ${input.voteId}
+                LIMIT 1
+            `);
+            const poll = pollRows[0];
+            if (!poll) {
+                throw new TRPCError({ code: 'NOT_FOUND', message: '설문조사가 없습니다.' });
+            }
+
+            const voteCountRow = await ctx.db.$queryRaw<Array<{ cnt: number }>>(GamePrisma.sql`
+                SELECT count(*) as cnt
+                FROM vote
+                WHERE vote_id = ${input.voteId}
+            `);
+            const voteCount = Number(voteCountRow[0]?.cnt ?? 0);
+            if (voteCount > 0) {
+                throw new TRPCError({ code: 'BAD_REQUEST', message: '이미 설문조사가 진행중입니다.' });
+            }
+
+            const existingOptions = parseOptions(poll.options);
+            const appendedOptions = normalizeOptions(input.appendOptions ?? []);
+            const nextOptions = appendedOptions.length > 0 ? [...existingOptions, ...appendedOptions] : existingOptions;
+
+            let nextMultipleOptions = input.multipleOptions;
+            if (nextMultipleOptions !== undefined) {
+                if (nextMultipleOptions < 0) {
+                    nextMultipleOptions = 0;
+                }
+                if (nextMultipleOptions > nextOptions.length) {
+                    nextMultipleOptions = nextOptions.length;
+                }
+            }
+
+            const endAt = input.endAt ? new Date(input.endAt) : undefined;
+            if (endAt && Number.isNaN(endAt.getTime())) {
+                throw new TRPCError({ code: 'BAD_REQUEST', message: '종료일이 잘못되었습니다.' });
+            }
+            if (endAt && endAt < new Date()) {
+                throw new TRPCError({ code: 'BAD_REQUEST', message: '종료일이 이미 지났습니다.' });
+            }
+
+            if (
+                input.title === undefined &&
+                input.body === undefined &&
+                appendedOptions.length === 0 &&
+                nextMultipleOptions === undefined &&
+                endAt === undefined &&
+                input.revealMode === undefined
+            ) {
+                throw new TRPCError({ code: 'BAD_REQUEST', message: '변경할 항목이 없습니다.' });
+            }
+
+            await ctx.db.$queryRaw(GamePrisma.sql`
+                UPDATE vote_poll
+                SET
+                    title = COALESCE(${input.title}, title),
+                    body = COALESCE(${input.body}, body),
+                    options = ${appendedOptions.length > 0 ? GamePrisma.sql`CAST(${JSON.stringify(nextOptions)} AS jsonb)` : GamePrisma.sql`options`},
+                    multiple_options = COALESCE(${nextMultipleOptions}, multiple_options),
+                    reveal_mode = COALESCE(${input.revealMode}, reveal_mode),
+                    end_at = ${endAt ?? poll.end_at},
+                    updated_at = NOW()
+                WHERE id = ${input.voteId}
+            `);
+
+            return { ok: true };
+        }),
+    closePoll: adminProcedure
+        .input(z.object({ voteId: z.number().int().positive() }))
+        .mutation(async ({ ctx, input }) => {
+            const rows = await ctx.db.$queryRaw<Array<{ id: number }>>(GamePrisma.sql`
+                UPDATE vote_poll
+                SET closed_at = NOW(), updated_at = NOW()
+                WHERE id = ${input.voteId}
+                RETURNING id
+            `);
+            if (!rows[0]?.id) {
+                throw new TRPCError({ code: 'NOT_FOUND', message: '설문조사가 없습니다.' });
+            }
+            return { ok: true };
+        }),
+    getAdminStatus: adminProcedure.query(async () => ({ ok: true })),
+});