DOMJUDGE食用指南

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

"""
CNB DOMjudge 工具（整合版）

功能概览
1) gen：从报名 Excel 生成 DOMjudge 导入用 TSV + 滚榜昵称映射
   - groups.tsv
   - teams.tsv       （DOMjudge 榜单显示：真名）
   - accounts.tsv
   - nicknames.tsv   （滚榜显示：昵称映射 teamid -> nickname）

2) patch：对 DOMjudge event-feed（NDJSON，每行一个 JSON 对象）替换队伍显示名
   - 输入：event-feed.json（NDJSON）
   - 输出：event-feed.nick.json（NDJSON）
   - 只替换 type == "teams" 的事件：data.name = nicknames.tsv 中的 nickname

===========================================================
依赖
  pip install pandas openpyxl

-----------------------------------------------------------
Windows (PowerShell) 推荐运行方式
  1) 生成 TSV：
     python .\cnb_domjudge_tool.py gen `
       --input "2025年菜鸟杯报名信息收集表（收集结果）.xlsx" `
       --outdir out `
       --year 2025

  2) 替换 event-feed 里的队伍名为昵称（用于 resolver 滚榜）：
     python .\cnb_domjudge_tool.py patch `
       --nick out\nicknames.tsv `
       --in event-feed.json `
       --out event-feed.nick.json

  注意：
  - PowerShell 分行必须用反引号 ` 续行；或者写在一行也可以。
  - 参数必须是两个短横线：--nick 不是 “—nick”（长横线会报错）。

-----------------------------------------------------------
Arch / Linux (bash) 推荐运行方式
  1) 建议虚拟环境：
     python -m venv .venv
     source .venv/bin/activate
     pip install -U pip
     pip install pandas openpyxl

  2) 生成 TSV：
     python cnb_domjudge_tool.py gen \
       --input "2025年菜鸟杯报名信息收集表（收集结果）.xlsx" \
       --outdir out \
       --year 2025

  3) 替换 event-feed：
     python cnb_domjudge_tool.py patch \
       --nick out/nicknames.tsv \
       --in event-feed.json \
       --out event-feed.nick.json

===========================================================
你要的业务规则（已实现）
- teams.tsv 的队伍名（DOMjudge 显示名）= “姓名（必填）”
- 滚榜时显示昵称：通过 nicknames.tsv + patch event-feed 实现
  （DOMjudge 内仍显示真名，不受影响）
"""

import argparse
import os
import secrets
import json
from typing import Any, Dict, List, Tuple

import pandas as pd


# ===================== 可根据需要修改的常量 =====================

CONTEST_YEAR = 2025

# 学号前四位在这个集合里的视为 Freshman
FRESHMAN_YEARS = {2025, 2026}

# groups.tsv 基础组别（可按需保留/修改）
GROUPS_BASE = [
    (2, "Self-Registered"),
    (3, "Participants"),
    (4, "Observers"),
]

FRESHMAN_GROUP_ID = 10
FRESHMAN_GROUP_NAME = "2025-2026 Freshman"

SENIOR_GROUP_ID = 11
SENIOR_GROUP_NAME = "2025-2026 Senior Player"

AFFILIATION_NAME = "Wuhan University of Science and Technology"
AFFILIATION_SHORT = "WUST"
COUNTRY_CODE = "CHN"

# teams.tsv 最后一列 extra（按你往年习惯）
EXTRA_FIELD_VALUE = "2"


# ===================== 报名表列名（必须和 Excel 表头完全一致） =====================

COL_NAME_REALNAME = "姓名（必填）"
COL_NAME_STUID = "学号（必填）"
COL_NAME_NICKNAME = (
    "希望展示在榜单上昵称（昵称不允许涉及敏感信息，只能使用汉子和ASCII字符，条件允许我们会使用昵称为大家滚榜）（必填）"
)


# ===================== 工具函数 =====================

def classify_group(student_id: str) -> int:
    """按学号前四位判断组别。"""
    if not student_id:
        return SENIOR_GROUP_ID
    s = str(student_id).strip()
    if len(s) < 4:
        return SENIOR_GROUP_ID
    try:
        year = int(s[:4])
    except ValueError:
        return SENIOR_GROUP_ID
    return FRESHMAN_GROUP_ID if year in FRESHMAN_YEARS else SENIOR_GROUP_ID


def sanitize_text(s: Any, max_len: int = 64) -> str:
    """
    清洗文本：
    - 去掉换行/制表符等控制字符
    - 去首尾空白
    - 限长（避免 DOMjudge/MySQL 的 name 字段过长）
    """
    if s is None:
        return ""
    s = str(s)
    for ch in ("\r", "\n", "\t"):
        s = s.replace(ch, " ")
    s = s.strip()
    if len(s) > max_len:
        s = s[:max_len]
    return s


def load_registration(input_path: str) -> pd.DataFrame:
    """读取报名表并做基础清洗：去空、按学号去重、排序。"""
    df = pd.read_excel(input_path)

    # 只保留有姓名和学号
    df = df.dropna(subset=[COL_NAME_REALNAME, COL_NAME_STUID])

    # 按学号去重（保留第一条）
    df = df.drop_duplicates(subset=[COL_NAME_STUID])

    # 按学号排序，teamid 稳定
    df = df.sort_values(by=[COL_NAME_STUID]).reset_index(drop=True)
    return df


def build_groups_rows() -> List[Tuple[int, str]]:
    rows = list(GROUPS_BASE)
    rows.append((FRESHMAN_GROUP_ID, FRESHMAN_GROUP_NAME))
    rows.append((SENIOR_GROUP_ID, SENIOR_GROUP_NAME))
    return rows


def build_teams_accounts_nicks(df: pd.DataFrame, contest_year: int):
    """
    从报名表生成：
      - teams.tsv 行：DOMjudge 队伍名 = 真名
      - accounts.tsv 行
      - nicknames.tsv 行：teamid -> nickname（滚榜用）
    """
    teams_rows: List[List[str]] = []
    accounts_rows: List[List[str]] = []
    nick_rows: List[List[str]] = []

    for idx, row in df.iterrows():
        seq = idx + 1
        teamid = f"{contest_year}{seq:03d}"     # e.g. 2025001
        externalid = f"CNB{teamid}"             # e.g. CNB2025001

        realname = sanitize_text(row[COL_NAME_REALNAME], max_len=64)
        student_id = sanitize_text(row[COL_NAME_STUID], max_len=64)
        nickname = sanitize_text(row.get(COL_NAME_NICKNAME, ""), max_len=64)

        # 昵称为空时回退真名（避免滚榜映射为空导致 name 变空）
        # 如果你坚持“昵称必填不允许回退”，改成 raise ValueError(...) 即可
        if not nickname or nickname.lower() == "nan":
            nickname = realname

        groupid = classify_group(student_id)

        # teams.tsv：name = 真名（DOMjudge 榜单/队伍名显示真名）
        teams_rows.append([
            teamid,
            externalid,
            str(groupid),
            realname,  # 关键：DOMjudge 显示真名
            AFFILIATION_NAME,
            AFFILIATION_SHORT,
            COUNTRY_CODE,
            EXTRA_FIELD_VALUE,
        ])

        # accounts.tsv
        username = f"team{teamid}"
        password = secrets.token_urlsafe(8)
        accounts_rows.append([
            "team",
            realname,
            username,
            password,
        ])

        # nicknames.tsv：滚榜显示昵称用
        nick_rows.append([
            teamid,
            nickname,
        ])

    return teams_rows, accounts_rows, nick_rows


def write_groups_tsv(path: str):
    rows = build_groups_rows()
    with open(path, "w", encoding="utf-8", newline="") as f:
        f.write("groups\t1\n")
        for gid, name in rows:
            f.write(f"{gid}\t{name}\n")


def write_teams_tsv(path: str, teams_rows: List[List[str]]):
    with open(path, "w", encoding="utf-8", newline="") as f:
        f.write("teams\t1\n")
        for cols in teams_rows:
            f.write("\t".join(map(str, cols)) + "\n")


def write_accounts_tsv(path: str, accounts_rows: List[List[str]]):
    with open(path, "w", encoding="utf-8", newline="") as f:
        f.write("accounts\t1\n")
        for cols in accounts_rows:
            f.write("\t".join(map(str, cols)) + "\n")


def write_nicknames_tsv(path: str, nick_rows: List[List[str]]):
    with open(path, "w", encoding="utf-8", newline="") as f:
        f.write("teamid\tnickname\n")
        for teamid, nickname in nick_rows:
            f.write(f"{teamid}\t{nickname}\n")


def read_nicknames_tsv(path: str) -> Dict[str, str]:
    """读取 nicknames.tsv -> dict(teamid -> nickname)。"""
    mapping: Dict[str, str] = {}
    with open(path, "r", encoding="utf-8") as f:
        first = True
        for line in f:
            line = line.rstrip("\n")
            if not line:
                continue
            if first:
                first = False
                if line.lower().startswith("teamid"):
                    continue
            parts = line.split("\t")
            if len(parts) < 2:
                continue
            teamid = parts[0].strip()
            nickname = "\t".join(parts[1:]).strip()
            if teamid:
                mapping[teamid] = nickname
    return mapping


# ===================== 子命令：gen =====================

def cmd_gen(args):
    os.makedirs(args.outdir, exist_ok=True)

    df = load_registration(args.input)
    teams_rows, accounts_rows, nick_rows = build_teams_accounts_nicks(df, args.year)

    groups_path = os.path.join(args.outdir, "groups.tsv")
    teams_path = os.path.join(args.outdir, "teams.tsv")
    accounts_path = os.path.join(args.outdir, "accounts.tsv")
    nicks_path = os.path.join(args.outdir, "nicknames.tsv")

    write_groups_tsv(groups_path)
    write_teams_tsv(teams_path, teams_rows)
    write_accounts_tsv(accounts_path, accounts_rows)
    write_nicknames_tsv(nicks_path, nick_rows)

    print(f"已生成：{groups_path}")
    print(f"已生成：{teams_path}（DOMjudge 队伍名=真名）")
    print(f"已生成：{accounts_path}")
    print(f"已生成：{nicks_path}（滚榜映射 teamid->昵称）")
    print(f"共生成 {len(teams_rows)} 个队伍 / 账号。")


# ===================== 子命令：patch（NDJSON event-feed） =====================

def cmd_patch(args):
    """
    读取 DOMjudge event-feed（NDJSON，每行一个 JSON 事件），把 teams 事件中的 data.name 改成昵称。
    输出仍然是 NDJSON，保证 resolver 可直接使用。
    """
    nick = read_nicknames_tsv(args.nick)
    replaced = 0
    total_lines = 0
    team_events = 0

    with open(args.infile, "r", encoding="utf-8") as fin, open(args.outfile, "w", encoding="utf-8") as fout:
        for line in fin:
            line = line.strip()
            if not line:
                continue

            total_lines += 1
            obj = json.loads(line)

            # DOMjudge event feed teams 事件结构示例：
            # {"type":"teams","op":"create","data":{"id":2025001,"name":"真名",...}}
            if isinstance(obj, dict) and obj.get("type") == "teams":
                team_events += 1
                d = obj.get("data")
                if isinstance(d, dict):
                    tid = d.get("id")
                    if tid is not None:
                        tid = str(tid)
                        if tid in nick:
                            d["name"] = nick[tid]
                            replaced += 1

            fout.write(json.dumps(obj, ensure_ascii=False) + "\n")

    print(f"已写出：{args.outfile}")
    print(f"输入事件行数：{total_lines}，其中 teams 事件：{team_events}")
    print(f"已替换队伍名数量：{replaced}")
    if team_events == 0:
        print("提示：输入文件中没有 type:'teams' 事件。请确认这是完整的 DOMjudge event-feed。")


# ===================== main =====================

def main():
    parser = argparse.ArgumentParser(description="CNB DOMjudge TSV 生成 + event-feed 昵称替换工具")
    sub = parser.add_subparsers(dest="cmd", required=True)

    p_gen = sub.add_parser("gen", help="从 Excel 生成 groups/teams/accounts/nicknames TSV")
    p_gen.add_argument("--input", required=True, help="报名信息 Excel 文件路径")
    p_gen.add_argument("--outdir", default=".", help="输出目录（默认当前目录）")
    p_gen.add_argument("--year", type=int, default=CONTEST_YEAR, help=f"比赛年份（默认 {CONTEST_YEAR}）")
    p_gen.set_defaults(func=cmd_gen)

    p_patch = sub.add_parser("patch", help="替换 DOMjudge event-feed（NDJSON）中 teams 的 name 为昵称")
    p_patch.add_argument("--nick", required=True, help="nicknames.tsv 路径（gen 输出）")
    p_patch.add_argument("--in", dest="infile", required=True, help="输入 event-feed.json（NDJSON）")
    p_patch.add_argument("--out", dest="outfile", required=True, help="输出 event-feed.nick.json（NDJSON）")
    p_patch.set_defaults(func=cmd_patch)

    args = parser.parse_args()
    args.func(args)


if __name__ == "__main__":
    main()

import os
import zipfile

# --- 配置区域 ---
# 忽略的文件夹（不打包这些）
IGNORE_DIRS = {
    ".git", 
    ".vscode", 
    ".idea", 
    "__pycache__"
}
# 忽略的文件后缀（不打包这些）
IGNORE_EXTENSIONS = {".zip", ".py", ".exe", ".DS_Store"}
# ----------------

def pack_folder(folder_name):
    """打包单个文件夹"""
    folder_path = os.path.join(".", folder_name)
    zip_filename = f"{folder_name}.zip"
    
    print(f"📦 正在打包: {folder_name} -> {zip_filename}")
    
    try:
        with zipfile.ZipFile(zip_filename, 'w', zipfile.ZIP_DEFLATED) as zipf:
            # 遍历题目文件夹内部
            for root, dirs, files in os.walk(folder_path):
                # 移除无需打包的子文件夹，避免遍历进去
                dirs[:] = [d for d in dirs if d not in IGNORE_DIRS]
                
                for file in files:
                    file_path = os.path.join(root, file)
                    
                    # 忽略特定后缀的文件
                    if file.startswith(".") or os.path.splitext(file)[1] in IGNORE_EXTENSIONS:
                        continue
                        
                    # 关键步骤：计算 ZIP 内的相对路径
                    # 作用：确保压缩包打开后直接是 data, submissions 等，而不是包了一层文件夹
                    arcname = os.path.relpath(file_path, folder_path)
                    
                    zipf.write(file_path, arcname)
        print(f"    ✅ 成功")
    except Exception as e:
        print(f"    ❌ 失败: {e}")

def main():
    root_dir = os.getcwd()
    print(f"📂 工作目录: {root_dir}")
    print("-" * 30)

    count = 0
    # 遍历当前目录下的所有项目
    for item in os.listdir(root_dir):
        item_path = os.path.join(root_dir, item)
        
        # 只处理文件夹，且不在黑名单里
        if os.path.isdir(item_path) and item not in IGNORE_DIRS:
            pack_folder(item)
            count += 1
            
    print("-" * 30)
    print(f"🎉 全部搞定！共打包 {count} 个题目。")

if __name__ == "__main__":
    main()