From 830a4dbdb753fde08e5d2e4efca4407c9496bf8f Mon Sep 17 00:00:00 2001 From: AskaEth Date: Mon, 14 Sep 2026 03:52:34 +0800 Subject: [PATCH] =?UTF-8?q?feat(joint-team):=20=E8=81=94=E9=98=9F=20+=20?= =?UTF-8?q?=E4=BB=BD=E9=A2=9D=E5=88=86=E6=88=90=20=E2=80=94=E2=80=94=20?= =?UTF-8?q?=E8=BF=81=E7=A7=BB=200024=E3=80=81=E5=BC=95=E6=93=8E=E6=8C=89?= =?UTF-8?q?=E4=BB=BD=E9=A2=9D=E6=8B=86=E3=80=81=E5=AF=BC=E5=87=BA=20/=20?= =?UTF-8?q?=E5=A4=A7=E5=B1=8F=20/=20=E5=BD=95=E5=85=A5=E4=B8=89=E8=B7=AF?= =?UTF-8?q?=E6=89=93=E9=80=9A=EF=BC=9B=E7=89=88=E6=9C=AC=20dev=5F0.5.3?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit ## 需求 现场 6 项球类比赛里，有两个单位因参赛人数不足**合并成一个单位参赛**。 做法不是新建「联队单位」（那样榜单会多出第 8 个单位，且分和奖牌分不到原单位头上）， 而是**一条报名挂多个单位、按份额拆**。 ## 拍板口径 - 份额**可配、默认均分** - 积分**平均拆、接受 .5**（团体第 1 名 15 分 → 两个单位各 7.5 分） - 奖牌**各记一枚**（两个单位各 1 枚完整金牌，不是各 0.5 枚） - 显示上把联队名字写全（形如 `第一分公司+第二分公司联队`），成员单位的 logo 都放 - 导入表里单位编码写 `A+B` ## 一、核心层（数据模型 + 引擎 + 存储 + 报名写入 + 导入解析） - 迁移 `0024_entry_team_shares.sql`：新建 `entry_team_shares(entry_id, team_id, points_share, medal_share, sort_order)`。**两个口径分开表达**是刻意的——积分要拆成小数（7.5）、奖牌要整枚 各记，用一个数表达就会把「7.5 分」和「半枚金牌」绑在一起，奖牌榜立刻错。 `entries.team_id` 保留为**主单位**；老数据 `INSERT OR IGNORE` 回填成「主单位独占 100%」。 - 引擎：`ResolveShares`（引擎与读侧共用）、`splitSharePoints`（按权重归一、**末位吞余数**， 各份之和恒等于原来那一份）、`TeamShare.Medal`（缺省整枚）。积分按权重拆，奖牌每个份额各记整枚。 - 报名写入：`PUT /api/entries/{id}/team-shares`（recorder 及以上，保存后当场重算该小项组别并推榜）。 - 导入：`team_code` 支持 `A+B`（主单位 = 加号左边，均分，奖牌各整枚）；非法形态 （`A+` / `+B` / `A++B` / `A+A` / 成员 >5 / 单位不存在）**行级拦下、不落库**，给人话报错。 ## 二、导出与导入模板 - 11 份导出件：联队写全成员单位（`第一分公司+第二分公司联队`），并注明**分拆给了哪几家、各多少** （份额占比 + 各单位实得积分，取自按份额拆完的流水）。 - 单位奖牌明细：奖牌格写「金牌（联队 …，各单位各记 1 枚）」；含联队时副标题说明 「各单位奖牌数之和会大于实际颁发数」——这是口径 3 的必然结果，**不是 bug**。 - 按单位筛选导出把成员单位一起算上（否则 B 单位导自己的名单会看不到自己参加的那场联队比赛）。 - 分工作表模板：`A+B` 写法挂在「单位编码」表头的**单元格批注 + 输入提示**（中英各一份）； **表头文字、列序、12 列、工作表命名一个字未动**（动了模板就导不回去）。 ## 三、前端与大屏 - 录入页 / 复核页「单位」列：联队显示 `联队 第一分公司 67%（权重 2） 第二分公司 33%`， 点该格打开「成员单位与份额」弹窗（加/删成员、改权重、主单位徽标、实时比例预览）。 **普通报名（单单位）的文案、元素、类名一字未动**，只多了一个 `@click` 入口与悬停提示。 - 大屏：分项成绩 / 实时赛况单位列显示联队全名并**放上两个单位的 logo**（单位列宽按该行的 logo 数留位）；底栏同理。 ## 四、验证（都留了证据） - **老数据逐字节不变**（改算分引擎的硬门槛）：引擎层 golden `a2aa1c97…`、接口层 golden `aa6cea37…`，两个哈希由主会话**在修前树上亲手重跑确认**；导出层另有 11 份导出件逐行对拍， 差异 **0 处**。 - 前端 773 → **809 例**全绿（旧用例一行未改）；服务端 14 包两轮全绿；Console 68 例全绿。 - 真机联调：录入页份额弹窗、大屏两个 logo、奖牌榜 A/B 各 1 金、写路径（移除成员 → 保存 → 200）。 ## 五、版本 `dev_0.5.2` → **`dev_0.5.3`**（本批含数据迁移 0024 + 新功能，必须与上一包区分开）； 安装器素材重生成（版本号烙在位图里，实测只有 `brand.bmp` 的 1x/2x 两张变化，其余 92 张逐字节未变）。 --- VERSION | 2 +- console/installer/art/1x/brand.bmp | Bin 316854 -> 316854 bytes console/installer/art/2x/brand.bmp | Bin 1267254 -> 1267254 bytes console/installer/art/version.txt | 2 +- console/package.json | 2 +- docs/使用手册.md | 61 +++ docs/升级说明.md | 92 +++- docs/报名名单导入规范.md | 64 ++- server/internal/domain/helpers_test.go | 4 +- server/internal/domain/joint_team_test.go | 377 ++++++++++++++++ .../domain/legacy_forms_golden_test.go | 240 ++++++++++ server/internal/domain/scoring.go | 122 ++++- server/internal/domain/standings.go | 8 +- server/internal/domain/types.go | 26 +- server/internal/export/athletes.go | 19 +- server/internal/export/entries.go | 36 +- server/internal/export/joint_team.go | 260 +++++++++++ .../internal/export/joint_team_export_test.go | 408 +++++++++++++++++ server/internal/export/joint_team_test.go | 37 ++ server/internal/export/load.go | 104 ++++- server/internal/export/medals.go | 50 ++- server/internal/export/style.go | 3 + server/internal/export/team_all.go | 8 +- server/internal/httpapi/dto.go | 18 + .../httpapi/entries_sheet_template.go | 106 ++++- server/internal/httpapi/entry_shares.go | 421 ++++++++++++++++++ server/internal/httpapi/entry_shares_test.go | 396 ++++++++++++++++ server/internal/httpapi/handlers_config.go | 22 +- .../httpapi/joint_team_template_test.go | 101 +++++ .../httpapi/legacy_forms_golden_test.go | 150 +++++++ server/internal/httpapi/payload.go | 8 + server/internal/httpapi/repo_events.go | 13 +- server/internal/httpapi/repo_import.go | 17 +- server/internal/httpapi/repo_misc.go | 21 +- server/internal/httpapi/scoring.go | 16 +- server/internal/httpapi/server.go | 3 + server/internal/realtime/snapshot.go | 57 ++- .../realtime/snapshot_joint_team_test.go | 48 ++ .../event/0024_entry_team_shares.sql | 37 ++ .../migrations/event/migration_0024_test.go | 176 ++++++++ web/src/admin/api/scoring.ts | 75 +++- .../components/baseData/ImportSection.vue | 16 + web/src/admin/pages/EntryPage.vue | 406 ++++++++++++++++- web/src/admin/pages/ReviewPage.vue | 53 ++- web/src/admin/pages/entryShares.ts | 292 ++++++++++++ web/src/admin/tests/entry-shares.test.ts | 279 ++++++++++++ web/src/admin/tests/scoring-shares.test.ts | 181 ++++++++ web/src/display/components/TickerBar.vue | 16 +- .../components/pages/EventResultsPage.vue | 21 +- web/src/display/components/pages/LivePage.vue | 41 +- web/src/display/fitFont.ts | 33 +- web/src/display/jointTeams.ts | 109 +++++ web/src/display/tests/joint-teams.test.ts | 195 ++++++++ web/src/display/tests/live-page.test.ts | 12 +- web/src/display/tests/team-logo.test.ts | 53 ++- web/src/display/useScoreboard.ts | 91 ++++ web/src/shared/api.ts | 23 + web/src/shared/index.ts | 11 + web/src/shared/jointTeams.ts | 153 +++++++ web/src/shared/tests/joint-teams.test.ts | 154 +++++++ web/src/shared/types.ts | 21 + 61 files changed, 5649 insertions(+), 121 deletions(-) create mode 100644 server/internal/domain/joint_team_test.go create mode 100644 server/internal/domain/legacy_forms_golden_test.go create mode 100644 server/internal/export/joint_team.go create mode 100644 server/internal/export/joint_team_export_test.go create mode 100644 server/internal/export/joint_team_test.go create mode 100644 server/internal/httpapi/entry_shares.go create mode 100644 server/internal/httpapi/entry_shares_test.go create mode 100644 server/internal/httpapi/joint_team_template_test.go create mode 100644 server/internal/httpapi/legacy_forms_golden_test.go create mode 100644 server/internal/realtime/snapshot_joint_team_test.go create mode 100644 server/migrations/event/0024_entry_team_shares.sql create mode 100644 server/migrations/event/migration_0024_test.go create mode 100644 web/src/admin/pages/entryShares.ts create mode 100644 web/src/admin/tests/entry-shares.test.ts create mode 100644 web/src/admin/tests/scoring-shares.test.ts create mode 100644 web/src/display/jointTeams.ts create mode 100644 web/src/display/tests/joint-teams.test.ts create mode 100644 web/src/shared/jointTeams.ts create mode 100644 web/src/shared/tests/joint-teams.test.ts diff --git a/VERSION b/VERSION index 8dc2039..d87c9ea 100644 --- a/VERSION +++ b/VERSION @@ -1 +1 @@ -dev_0.5.2 +dev_0.5.3 diff --git a/console/installer/art/1x/brand.bmp b/console/installer/art/1x/brand.bmp index dfbec47038371ba4b84df2ab5b6b66942ca1ce1d..48b05ff70b3736e8f623a197374e4f9f5e89b547 100644 GIT binary patch delta 389 zcmdnCT6o)P;SCZwoPOE@K;*9@u-TE(kZE#IUYDqs2Ct_&4^Y%si{Dd?+g*jzN0WE+ z!(MHs$ufo0_`TG5fGELMDceIg!c=mzVHHr~P4Pt8?0|{+AwUhi*#VRCL)ufl=GP?V z`xtnsae<8YVpL+9yr*n}e3XT3gqd`Ju27b{j*ljvvjS_nizZMhP?4_|pa16U^6gBL zKnV|3E^iH9CwZ0_OS$>ANr8GoVCmIOYD|+8Yo-VRmBd;rlmwdf=L8n`8F{I5ZC>64 zbc#{^WFepfGhDT%7DoV4fUY1=<7Rh8pd3@vWRUxTj&zh`Zisd2NcGyhq-h@$$gnsY z#Xvn_dl|-xFsn%gp+Ipxrpb%i`^2>cfa+_a?57llwWWB@t4U0CR`*iphS*lrH9-^- tPO(<?7cOU=& delta 378 zcmdnCT6o)P;SCZwn=Kfvm?j71bxC-t^8k^r7QeR!F9i8$@&eIj7e)=H$ufo0M1gW4 zhGIYzVJa1FA^}AHIs%*B8C97kzbT%mkP|R5Kg3gwdv-2-B}f}n;jYTm?rDjPZI?yhe-7229*Yx zyQ^@3tn>o8ovCRuKhQFWfrb7iy;=U7mo)8T0@^14v>Qm;%P=;@yL6`e0L6jkEo$!* z2Zuvbg6o95V4(P%s`yw-Id2V~&C8pB&M4}dAnK#Z2Q)O^Mls7>C)hv)CE4yny#4Q?#tc5DjS=x*b zIa5F zlMp(?SXo-TMHEC;no^T30^gV+@K>sDo~?N>=zlWW{_y(QJ6+CzwaB6o(ZDC-Vd>ZR zB#o$ChfkzOq1&+c_^aDJFQ>cj_ccwm+vbDytG5ELXD?2))`avLH0L8xkt}!w6OtVHGIZcw+j6B< z>5**)Ek-Z&x~*Dq$jP`_y7f6+0?S+`yZP`TK)<_04oAyF&5i;DD8>|&1izp}`7aZD z_(BI?xe{KM`n@*#V~6-yD*Z+@ySXANh=Lr*A8Rpf+#R^uSjlUrzjp}Qu5E*wj8^r< zNuDxAhcOQ^uFv<+b~@~NQcS1YJ7hQ_4GeU0mn5%@bs)sGnchb?S_76s$OQ>maJDKA+?q9^P~Q1N1==sFwA5`5==uC7EBK{9fdFqux}pEyprUnF4MsZ{wXbTmX@vVxbJ_gEZnd;LN&hy1%}0IeHTr zInjc|$M4-eb`;|cq$4iG0FxKY`Tv#eP2tMW9@6`rdN8iIk03g{!C72xsCY3I#8q@2 z*atIVd6>4Ij#%U#y%N_hG}rfRqH}rB|9GSgdpyq>7K0*2M#(RN>vSrcix5tsqqRyi z+H6G8bccPQp~7`gZqACOGa5t~4~_i6Vq;K8TQtH&+a}?@6+27kikVWv|MoHU?6|Is l0rmjgJ_3jYqJU^11`q(TfDjM?VjvEX08${H>dItH${!YbA`}1s delta 969 zcmZ8g-A__s9NznOKm`OrOw+Is0YQaIbitNuD+2@sQ6$AMwfxAh)ck0zWvxub`E}Z` z+G?xTT)9@Eo`0Z=uH0HzU3Jq{-FT7KMQc6BW7^uD=j`1%&-43we`jskx3=sXTOqc0 zIaP&e|D!0)zYT8IMC%!D={+$JBSc=4+^v_m4N}0Rm+ZhGsT5$8`poh~h__U&lU!o8 z=Rz1dmO0xKoa?Qb@2kBx5N7-97A}VXmPZ|4o-NDvno^N55upKw`}UD&iM77GA}^`h zlK${&G%-K?aN1x;C63W%aO4Mp zQn^7)M1{ndR=70#>CHCu+gzT4V;zIn20?|lQPW; zWbm5hC~|qKuhEfPX_WE-er^%m=TRBek$kuT=mcyBlT5aI-_8wnRG8fc$)4eZk~bh1 zuxmpDE(2d8Z#eUhp^@RPWYTP6h7@gZ+)>vSK%Ik{un1kQ;)ym77C6@78wivJEGh)%|B;wT;ml6~gg?T`U+*uH zk%-b7hMO;;$4Pv_L{&SxQN!G|*(taW 需要先「存草稿」再动这些入口：修改 / 作废 / 退回会重算并整表刷新，未保存的编辑会被刷新覆盖，页面会拦下并提示。 +### 4.11 联队（两个单位合并参赛） + +有些项目**两个单位因参赛人数不足，合并成一个单位参赛**。这种情况**不要新建一个「联队单位」**——那样榜单会多出一个单位，联队拿到的分与奖牌也分不到原单位头上。正确做法是**一条报名挂多个单位、按份额分成**：榜单仍然是原来的单位数，分数与奖牌按份额记给各单位，联队的名字在大屏与导出件上写全。 + +**三个口径（赛会已定，录之前先知道）** + +| 口径 | 怎么写 | +| --- | --- | +| 份额 | **可配、默认均分**：两个单位各占一半（50% / 50%）；要改成别的比例（例如 2:1）就填权重 | +| 积分 | **平均拆，接受 .5**：团体第 1 名 15 分 → 两个单位**各 7.5 分**（榜单上就写 7.5） | +| 奖牌 | **每个成员单位各记一枚整枚**：联队的金牌，两个单位**各记 1 枚**（不是各 0.5 枚） | + +> ⚠️ 由此产生一个**必须知道**的结果：**各单位的奖牌数之和会大于实际颁发的奖牌数**。A、B 联队拿 1 枚金牌，奖牌榜上 A 记 1 金、B 记 1 金，而场上只颁发了 1 枚。**这是定稿口径，不是数据错了**；拿奖牌数去和实际颁发的奖牌核对时请记住这一点。导出件的「总表 / 单位奖牌明细」副标题里也写着这句话。 + +**怎么配（两个入口）** + +1. **导入报名表时**：把「单位编码」那一格写成 `A+B`（例如 `F1+F2`）——**加号左边那个是主单位**（名次与榜单的归属主体），全角 `＋` 与两侧空格都认。默认均分；一个联队最多 5 个单位。写法与报错见[报名名单导入规范 · 第三节](./报名名单导入规范.md)； +2. **导入之后在界面上改**：到「成绩录入」页**点那一行的「单位」格**（复核页只读，改份额在录入页），打开「成员单位与份额」弹窗。要改成非均分（例如 2:1）**只能在弹窗里改，导入表里写不了**。 + +**「成员单位与份额」弹窗怎么用** + +1. 弹窗里每个成员单位一行：**编码 / 单位全称 / 「主单位」徽标 / 权重输入框 / 移除**； +2. 权重是**相对权重**：都留空（或填 0）就是**均分**（各 50%），填 `2` 与 `1` 就是 **67% 与 33%**； +3. 底部「**添加成员单位…**」下拉里选一个单位再点「添加」——下拉里列的是还没在成员里的单位（**已停用**的单位也可以加，会标注「已停用」；被「彻底删除」的单位不出现）； +4. 弹窗下方实时显示 `当前比例：第一分公司 50% · 第二分公司 50%`，两个以上成员时旁边还会给出联队名预览（`第一分公司+第二分公司联队`）； +5. **主单位不能去掉**（它的「移除」是灰的）：报名挂在它名下，要换主单位只能重新建报名； +6. 点 **「保存成员单位」** 提交——服务端**当场重算该小项该组别**的名次与积分并刷新大屏榜单，提示「成员单位已保存」。**没改动时保存按钮是灰的**，点「关闭」不会发出任何请求。 + +**要注意的** + +- **权限**：读得到成绩的人都能看见这一格；**能改的是录入员及以上**（与录成绩同档）。访客只读时输入框置灰，并写明「当前为访客只读视图」或「服务端未连接」；示例数据模式下不能保存； +- **普通报名完全不受影响**：只有一个单位的报名，这一格的文案、元素与以前一样，**不改动就不会发出任何请求**； +- **分数怎么分、牌怎么记**：保存后这条成绩的分按份额拆给各成员单位（榜单上各处都已经是拆后的数），奖牌**每个成员单位各记一枚**（见上面的口径表与那句提醒）； +- **按单位导出名单时，成员单位也看得到这条报名**：用 B 单位筛「报名名单」，能看到主单位是 A、成员里有 B 的联队报名——否则 B 导出自己的名单会发现「没派人上场」； +- ⚠️ **个人积分总明细里，联队里的同一个人会出现两行**（引擎按份额给两个成员单位各留一行流水）。导出侧只在「来源」列写清这两行为什么出现（`成绩（联队分拆：…）`）：**看两行加起来才是这个人的总数**，他的总分没有被算两遍； +- ⚠️ **团体名次（见 4.9）要录在「主单位」那一行**：联队的名次录在主单位上，系统才会按份额拆给各成员单位；**不要再给成员单位单独录一份名次**，那会让成员单位再拿一份分（重复计分）。 +- ⚠️ **「按队内平均」这类聚合通道的项目，联队不拆份额**：这类通道的名次不对应任何一条报名，分仍记在主单位头上（本轮如此）。要保证联队一起算，请用不聚合的口径（或按 4.9 在主单位上录名次）。 +- 一件事只做一次：**同一个小项同一个组别里，两个单位联合参赛就写一条 `A+B` 的报名**。`A+B` 与 `B+A` 是**两条不同的报名**（主单位不同），不要两种写法都填。 + --- ## 5. 成绩审核 @@ -280,6 +321,9 @@ 1. 左侧「待审草稿」按「小项 + 组别」分组，显示每组草稿条数，可搜索小项 / 组别 / 单位； 2. 点选一组后，右侧显示该组成绩明细（单位、运动员 / 队、成绩、名次、状态、积分）； + + > 「单位」这一列与录入页同一口径：普通报名显示单位简称；**联队**（一条报名挂多个单位）会多一个「联队」小标，并把成员单位与份额逐条列出（`第一分公司 50%` / `第二分公司 50%`），悬停能看到联队全名——复核时一眼就看出这一条其实是几个单位合并报的。本页只读，改份额请到「成绩录入」页点那一行的「单位」格（见 4.11）。 + 3. 用「整组对比 / 逐条对比」切换，查看发布后各单位积分的变化； 4. 「发布影响」列出受影响单位与分值变化； 5. 操作： @@ -387,6 +431,7 @@ ### 8.2 单位奖牌榜 / 个人积分榜 - 单位奖牌榜显示金、银、铜与合计； +- ⚠️ **有联队（两个单位合并参赛）时，各单位的奖牌数加起来会大于实际颁发的奖牌数**——联队的每一枚奖牌**每个成员单位各记一枚整枚**（A、B 联队拿 1 枚金牌，榜上 A 记 1 金、B 记 1 金，场上只颁发了 1 枚）。**这是定稿口径，不是数据错了**；拿榜单去和实际颁发的奖牌核对时请记住这一点。联队本身怎么配见 4.11； - **单位奖牌榜有自己的名次与顺序：金牌多的在前，其次比银牌、铜牌，最后按单位编码排**——它不看总分，所以「金牌多但总分低」的单位在这里排在前面，在单位总分榜上却靠后，这是口径不同，不是数据错了； - 个人积分榜显示运动员、单位、个人总分与奖牌数； - 单位奖牌榜那一列的「明细」展开的是**同一个单位积分明细面板**（见 8.1），不是奖牌专属明细；但这份榜单本身有专属的逐枚奖牌导出（见 8.3）； @@ -399,6 +444,11 @@ - **导出奖牌明细**（单位奖牌榜卡片头）：导出 `单位奖牌明细.xlsx`——第一张总表逐枚奖牌列出「单位 / 大项 / 小项 / 组别 / 名次 / 奖牌 / 运动员、队」，`奖牌` 列是 `金牌` / `银牌` / `铜牌`；其后每个**有奖牌**的单位一张分表（列同上、去掉「单位」，末尾一行小计 `金 X / 银 Y / 铜 Z`），没有奖牌的单位不出分表。口径与「单位奖牌榜」一致：同一个报名项在「个人+团体」这类双计通道下只记一枚奖牌，不会重复计数； - **导出个人明细**（个人积分榜卡片头）：导出 `个人积分总明细.xlsx`——第一张总表逐条列出「单位 / 运动员 / 大项 / 小项 / 组别 / 名次 / 成绩 / 得分 / 来源」；其后每个**有得分**的单位一张分表（按单位分，不按人分），没有得分流水的人不出现在表里。`得分` 是记到个人的原始分，**与「个人积分榜」逐个数字一致，且不乘榜单口径里的个人项目得分折算系数**（那个系数只作用于单位总分）； - **导出该单位明细**（右侧单位明细面板头部）：先展开某个单位再点，导出 `单位积分明细.xlsx`（列：序号、大项、小项、组别、运动员、名次、成绩、来源、积分、备注，末行是「合计」）。**备注列会写下修订痕迹**：被改过的成绩写「已修订 ×N；最后一次 <时间> <原因>」，没改过的行留空——与屏幕上那个角标是同一句话，事后拿表格对账不会对不上。单位奖牌榜展开的也是这个单位积分明细面板，所以想按单位逐条看时同样用它； +- **联队（一条报名挂多个单位）在这几份导出件里怎么体现**（见 4.11）： + - **单位积分明细 / 单位积分总明细的「备注」列**：这一条是从联队分来的，会写清分给了哪些单位、各拿多少分（多少 %），例如 `联队分拆：第一分公司 5 分（50%）、第二分公司 5 分（50%）`；「积分」列写的是**本单位实得的那一份**（上例是 5 分，不是联队拿到的 10 分）； + - **个人积分总明细的「来源」列**：这一条是联队分来的写成 `成绩（联队分拆：第一分公司 5 分（50%）、第二分公司 5 分（50%））`。⚠️ 这张表里**联队成员会出现两行**（引擎按份额给两个成员单位各留一行流水）——**看两行加起来才是这个人的总数**，他不是被算了两遍； + - **单位奖牌明细的「奖牌」列**：联队那一枚写成 `金牌（联队 第一分公司+第二分公司，各单位各记 1 枚）`（非联队行仍然只有「金牌」两个字）。为了让这句话写得下，这一列**加宽并允许换行**，格子里的值本身没变； + - **总表 / 单位奖牌明细的副标题**：赛事里有联队时，会追加一句 `· 注：本赛事含联队，奖牌按「每个成员单位各记 1 枚」统计，各单位奖牌数之和会大于实际颁发数`——**各单位奖牌数加起来比实际颁发的多，是定稿口径，不是数据错了**（A、B 联队拿 1 枚金牌，两边榜上各 1 枚）； - 这些导出都是只读下载（访客也能用），不需要写权限；导出过程中按钮会变成「导出中…」并禁用，避免重复下载。 ### 8.4 推送明细到大屏 @@ -660,6 +710,8 @@ 报名有两种方式，都在本页完成：**从已有名单勾选**适合零散补报，**表格导入**适合批量录入。 +> 两个单位因参赛人数不足**合并成一个队参赛**时，不要建一个「联队单位」——**在导入表的「单位编码」列写 `F1+F2`**，或导入后到「成绩录入」页点那一行的「单位」格配成员单位与份额（见 4.11）。榜单仍是原来的单位数，分数与奖牌按份额记给各单位。 + > 本页的「从已有名单勾选」在**成绩录入页的工具栏里也有一个入口**（按钮叫 **「补报名」**），打开的是同一套勾选界面，只是预选了你正在录的那个小项与组别——在录入界面把某人移出报名之后，就地补回来即可（见 4.8）。 **从已有名单勾选** @@ -687,7 +739,9 @@ - 「**中文表头 / 英文表头**」＝**单表模板**（`entries-template-zh.csv` / `entries-template-en.csv`）：一份表装全部报名，每行都要填「项目编码」与「组别」两列； - 「**分工作表 · 中文表头 / 分工作表 · 英文表头**」＝**分工作表模板**（`.xlsx`）：按当前赛事已配好的**小项 × 组别各建一张工作表**，表名是「**小项名称@组别名称**」（例如 `100 米跑@男子组 30岁以下`），范围由表名承担，数据区只填人和单位。小项组别多时用它更不容易抄串； - 两种模板的表头与列顺序完全一样，只有「范围从哪来」不同（详细规范见 [报名名单导入规范 · 第八节](./报名名单导入规范.md)）； + - **两个单位联合参赛（联队）**：把「单位编码」那一格写成 `F1+F2`（加号左边是主单位，默认均分，见 4.11）。**分工作表模板**里，「单位编码」表头那一格挂了一条**单元格批注**（鼠标停上去就弹出来）、这一列还有**输入提示**（点中该列的格子就弹出来），中英各一份，写的正是这套写法——表头文字、列顺序与工作表名一个字都没动，**老表格照常导入**； 2. 表头共 12 列：`event_code`、`category`、`team_code`、`athlete_name`、`id_card`、`gender`、`age`、`bib`、`seed`、`heat`、`status`、`member_names`（大小写不敏感）。其中 `id_card`（证件号）、`gender`（性别）、`age`（年龄）、`heat`（批次）为可选列，缺失不影响导入，其余列必须包含； + - `team_code`（单位编码）有两种填法：**一个单位**填它的编码（`F1`）；**两个单位联合参赛**填 `F1+F2`（加号左边是主单位，默认均分；非均分要到录入页改，见 4.11）； - 用**分工作表模板**时，`event_code`、`category` 两列也可以整列不要或整列留空（范围由工作表名决定）；一旦填了就必须与工作表名一致，不一致的那一行会报错并跳过； - 工作表名必须是「小项名称@组别名称」；工作簿里只要有**一张**表名带 `@`，整份文件就按分工作表模板处理，别的表名不合规会**整份拒绝并点名是哪张表**（不让数据无声消失）； - 小项名与组别名里**不允许出现 `@`**（它是表名里的分隔符）：新建 / 编辑小项与组别时界面会当场拦下并说明原因；**已经带 `@` 的历史名字不影响报名与成绩**，但下载分工作表模板时会被点名要求先改名； @@ -757,6 +811,11 @@ | 个人积分总明细 | **在「积分榜 → 个人积分榜」页操作**：逐条列出单位 / 运动员 / 大项 / 小项 / 组别 / 名次 / 成绩 / 得分 / 来源，每个有得分的单位一张分表 | `个人积分总明细.xlsx` | - 「分项成绩表」需先选择小项，「单位积分明细」需先选择单位；「报名名单」的四个筛选（小项 / 组别 / 单位 / 批次）**都可以留空**，留空就是不筛这一维度（全导）； +- **联队（一条报名挂多个单位）在这几份导出件里的写法**（见 4.11）： + - **「分项成绩表」「全部」「全部（单页）」的「单位」列**：写成联队全名 `第一分公司+第二分公司联队`（成员单位名写全，与导入表的 `F1+F2` 同构）；**「备注」列**写清这条分给了谁、各多少，例如 `联队分拆：第一分公司 5 分（50%）、第二分公司 5 分（50%）`——「积分」列写的是**联队拿到的总分**（上例 10 分），每家的那一份看备注； + - **「报名名单」**：「单位编码」列回写成 `F1+F2`（**导出的名单可以直接拿去重导**，不用手工改回单个单位）、「单位名」列写联队全名、「备注」列写 `联队分拆：第一分公司 50%、第二分公司 50%`（这张表没有积分列，所以只写份额比例）； + - **按单位筛选导出时，成员单位也看得到这条报名**：「报名名单」按 F2 筛选，能导出「主单位是 F1、成员里含 F2」的联队报名（否则 F2 导出自己的名单会发现「没派人上场」）； + - 「单位积分明细 / 单位积分总明细」「个人积分总明细」「单位奖牌明细」里联队的写法见 8.3；**没有联队的赛事，这些列与升级前逐字一致**。 - **三种「还没出结果」的行也照样占一行**（「分项成绩表」「全部」「全部（单页）」都是，逐格口径完全一致）： - **录了但还没发布**：成绩列写 **`分数未录入`**、名次与积分列写 `—`、状态列写「草稿」； - **完全没有录成绩**（连草稿都没有）：名次 / 成绩 / 积分三列都写 `—`（不是空、也不是 `0`）、状态列写「未录入」； @@ -992,6 +1051,8 @@ > 单位 logo 取自「基础数据 → 参赛单位」里上传的图片（见 10.1），按行内文字大小显示，不会撑开行高；没传 logo 的单位不占位，图片临时加载不出来时保留占位、刷新后恢复，队名不会跳动。 +> **联队（两个单位合并参赛）在大屏上怎么写**（见 4.11）：「分项成绩」与「实时赛况」的**单位列写联队全名**——`第一分公司+第二分公司联队`，并且**把两个单位的 logo 都放上**（单位列宽会为该行实际要画的 logo 数留位置，第二个 logo 不会把名字挤成省略号）；底栏「最新完成项目」那一行同样写联队全名。**单位奖牌榜、总积分榜本来就是逐单位一行，服务端已按份额拆好**（例：A、B 各 1 枚金、各 7.5 分），屏上不需要另做处理。**没有联队的赛事，大屏画面与升级前逐像素一致**。 + > 大屏的标题字体与正文字体取自「系统设置 → 赛事信息 → 字体」（见 14.3）：可选四款内置字体，也可以上传自己的字体；上传字体加载失败时自动回落到默认字体，画面不会出现方块或空白。 > 除了 Console 开出来的本机大屏窗口，**局域网设备（另一台电脑、电视浏览器）打开 `http://<主机IP>:19540/display` 也能当大屏用**。这个地址不用手敲：管理端「大屏控制 → 局域网大屏」卡片里有**可复制的完整链接与二维码**（见第 9 节）。这类设备会出现在管理端「大屏控制 → 在线大屏」列表里（标记为「局域网浏览器」），也能被单独切页，用法见第 9 节；它们不受 Console 的 kiosk、防熄屏控制（另见常见问题 Q29）。 diff --git a/docs/升级说明.md b/docs/升级说明.md index 3ac80db..38f290e 100644 --- a/docs/升级说明.md +++ b/docs/升级说明.md @@ -6,7 +6,97 @@ --- -## dev_0.5.2（当前版本） +## dev_0.5.3（当前版本） + +### 一句话 + +**有一条数据迁移（`0024`），但升级后不用重配任何东西、老数据一个数字都不变**：一条报名现在可以挂**多个单位、按份额分成**——两个单位因参赛人数不足合并成一个联队参赛时，分数按份额拆给各单位（默认均分，允许出现 7.5 这种小数），奖牌**每个成员单位各记一枚整枚**。升级前就有的赛事，榜单、名次、积分、奖牌、导出件与升级前一模一样——**联队能力只有在真的把某条报名配成联队之后才会体现**。不用重新导入规则包。 + +### ① 数据迁移：一条（`0024`） + +- **它做什么**：新建一张 `entry_team_shares` 表，记「这条报名归哪些单位、各占多少」（积分份额 + 奖牌是否记给本单位），并把**已有的每一条报名回填成「主单位独占 100%」**。`entries.team_id` 保留为**主单位**（联队时就是加号左边那个），既有的查询、唯一键、榜单、导入都还认它。 +- **只加一张表 + 回填**：不改任何既有字段、不删任何数据；回填用的是「已经有份额就不动」的写法，重复执行（或迁移被重放）**不会覆盖已经配好的联队份额**。 +- **怎么看它跑过**：启动一次 Console，在运行日志或 `logs\operations\` 当天文件里能看到 `已应用迁移 … name=0024_entry_team_shares.sql`。 + +### ② 老数据零变化（有对拍证据） + +- **无联队的老数据在引擎层、接口层、导出层三层都做过签名 / 逐行对拍，差异 0 处**，签名取自**联队实现之前**的代码，实现之后必须一字不差： + - 引擎层：`server/internal/domain/legacy_forms_golden_test.go`（`TestLegacyFormsScoringUnchanged`，签名 `a2aa1c97…`）； + - 接口层：`server/internal/httpapi/legacy_forms_golden_test.go`（`TestLegacyFormsAPISnapshotUnchanged`，签名 `aa6cea37…`）； + - 导出层：`server/internal/export/joint_team_export_test.go` 的 `TestSingleUnitExportsHaveNoJointTeamText`（只有一条独占份额时，各份导出件一个字都不能多）。 +- 所以：**升级后单位总分榜、单位奖牌榜、个人积分榜的每一个数字、每一条名次、每一枚奖牌、每一份导出件都与升级前一模一样**。本事只在真的把某条报名配成联队之后才生效。 + +### ③ 不用重新导入规则包 + +- 本版**没有改规则包格式、没有改计分口径、没有改任何计分通道配置**：随包规则包与现场那份都不用动，也不需要重算。 +- （对照：dev_0.5.1 那次是建议重新导入的，本版不是。） + +### ④ 新增能力：联队 + 份额分成（口径已定稿） + +| 口径 | 定稿写法 | +| --- | --- | +| 份额 | **可配、默认均分**（权重都留空 = 各 50%；填 2 与 1 = 67% 与 33%） | +| 积分 | **平均拆，接受 .5**：团体第 1 名 15 分 → 两个单位各 **7.5 分**（榜单上就写 7.5） | +| 奖牌 | **每个成员单位各记一枚整枚**：联队的金牌，两个单位**各记 1 枚**（不是各 0.5 枚） | +| 显示 | 联队的名字**都写出来**：`第一分公司+第二分公司联队` | +| 导入 | 报名表的**单位编码**列写 `A+B`（加号左边那个是**主单位**；全角 `＋` 与两侧空格等价） | + +怎么用： + +- **配联队的两个入口**： + 1. **导入报名表**时把单位编码写成 `A+B`（默认均分；最多 5 个单位；`A+`、`+B`、`A++B`、`A+A` 这些写法会被**逐行拦下**并说清是第几行、错在哪，**其余行照常导入**）；报名模板（分工作表 xlsx）的「单位编码」表头挂了一条**单元格批注**、该列还有**输入提示**，中英各一份，内容就是这套写法——**表头文字、列序、12 列、工作表命名一个字都没动**，老表格照常导入； + 2. 导入后到**「成绩录入」页点那一行的「单位」格**，打开「**成员单位与份额**」弹窗改（加成员单位、填权重、去掉成员）。⚠️ **非均分（例如 2:1）不能在导入表里写**，只能在弹窗里改。 +- **谁能改**：份额编辑与录成绩同档，**录入员及以上**；访客只读时输入框置灰并写明原因。 +- **改完当场生效**：保存立即重算该小项该组别并推送大屏。 +- **录入与复核页看得到**：联队的单位格显示成 `联队 第一分公司 50% 第二分公司 50%`（非均分时带 `（权重 2）`）。**普通报名（只有一个单位）的格子文案、元素一个字没动**，只是多了一个可点的入口和一行悬停提示。 +- **大屏**：分项成绩表与实时赛况的「单位」列写 `第一分公司+第二分公司联队`，并**把两个单位的 logo 都放上**（单位列宽会为该行的 logo 数留位）；底栏「最新完成项目」同样写联队全名；单位奖牌榜与总积分榜本来就是逐单位一行，服务端已按份额拆好（例：A、B 各 1 枚金、各 7.5 分）。 + +### ⑤ 导出件里现在写成什么样 + +| 位置 | 现在写成 | +| --- | --- | +| 分项成绩表 / 全部成绩（单页）「单位」列 | `第一分公司+第二分公司联队` | +| 同上「备注」列 | `联队分拆：第一分公司 5 分（50%）、第二分公司 5 分（50%）` | +| 报名名单「单位编码 / 单位名 / 备注」 | `T1+T2` / `第一分公司+第二分公司联队` / `联队分拆：第一分公司 50%、第二分公司 50%` | +| 单位积分明细 / 总明细「备注」列 | `联队分拆：… 各多少分（各多少 %）` | +| 个人积分总明细「来源」列 | `成绩（联队分拆：…）` | +| 单位奖牌明细「奖牌」列 | `金牌（联队 第一分公司+第二分公司，各单位各记 1 枚）` | +| 总表 / 单位奖牌明细的副标题 | 追加 `· 注：本赛事含联队，奖牌按「每个成员单位各记 1 枚」统计，各单位奖牌数之和会大于实际颁发数` | + +- **按单位筛选导出**：成员单位的名单里也能看到**主单位是另一个单位的联队报名**（否则 B 导出自己的名单会发现「没派人上场」）； +- 导出件的**值只在真的有联队时才变**：没有联队的赛事，导出件与升级前逐字一致。 + +### ⑥ 两条要主动告知的口径后果 + +1. **各单位的奖牌数之和会大于实际颁发的奖牌数**——因为联队的每一枚奖牌**每个成员单位各记 1 枚**。例：A、B 联队拿 1 枚金牌，奖牌榜上 A 记 1 金、B 记 1 金，而场上只颁发了 1 枚。**这是定稿口径，不是数据错了**；含联队的「总表 / 单位奖牌明细」副标题会写这句话，奖牌明细里联队那一格也写着「各单位各记 1 枚」。**拿奖牌数去和实际颁发的奖牌核对时请记住这一点。** +2. **个人积分总明细里，联队里的同一个人会出现两行**——引擎按份额给两个成员单位各留了一行流水，导出侧只在「来源」列写清这两行为什么出现（`成绩（联队分拆：…）`）。**看两行加起来才是这个人的总数**；这不是重复计分（他的总分没有被算两遍），是按份额拆开的结果。 + +### ⑦ 顺带：单位奖牌明细的「奖牌」列加宽并允许换行 + +- 导出件「单位奖牌明细」的「奖牌」列原来是**宽 8、居中**，写不下 `金牌（联队 第一分公司+第二分公司，各单位各记 1 枚）` 那句（会被右边的「运动员/队」裁掉），现在**加宽到 26 并允许换行**。 +- **列里的值没变**：没有联队时这一格仍然只是「金牌」「银牌」「铜牌」三个字。 + +### ⑧ 升级后 5 分钟核对 + +1. 启动一次 Console，看运行日志 / `logs\operations\` 当天文件：应能看到 `0024` 这条迁移记录，没有别的报错； +2. 刷新管理端「积分榜」与大屏：**单位总分榜、单位奖牌榜、个人积分榜的每一个数字与升级前一致**（本版不改任何计分口径；只有你之后自己配了联队的地方才会变）； +3. 打开「成绩录入」页：普通报名的**「单位」那一格与升级前长得一样**（只是鼠标移上去变成手型、有一行悬停提示，点一下会打开「成员单位与份额」弹窗，什么都不改直接关掉等于没动过）； +4. 打开「基础数据 → 报名导入」，下载一份「**分工作表 · 中文表头**」，把鼠标停在表头「**单位编码**」那一格上：应弹出「单位编码怎么写」的批注（内容含 `A+B`）；点中该列任一格应弹出同样的输入提示； +5. 真要用联队的：按 ④ 把那条报名配好（导入写 `A+B`，或点单位格改份额），确认榜单上两个单位**各拿到一半分、各记一枚牌**、大屏上两个单位的 logo 都在； +6. 用《上线检查清单》过一遍。 + +### ⑨ 详细说明在哪 + +| 想了解 | 看 | +| --- | --- | +| 联队怎么录、份额怎么改、分成后长什么样 | 《使用手册》4.11 | +| 导入表里联队怎么写、写错了报什么错 | 《报名名单导入规范》第三节的「单位编码」、第六节 | +| 大屏与导出件上联队写成什么 | 《使用手册》17.1、8.3、11.1 | +| 迁移与份额表结构 | `server/migrations/event/0024_entry_team_shares.sql` | + +--- + +## dev_0.5.2 ### 一句话 diff --git a/docs/报名名单导入规范.md b/docs/报名名单导入规范.md index ee02e4a..d8072a7 100644 --- a/docs/报名名单导入规范.md +++ b/docs/报名名单导入规范.md @@ -54,7 +54,7 @@ |---|---|---|---| | `event_code`（项目编码） | **必须** | 小项编码，抄系统里配好的 | `M100` | | `category`（组别） | **必须** | 组别**名称**（中文，要跟系统里一字不差） | `男子30岁以下` | -| `team_code`（单位编码） | **必须** | 参赛单位编码，抄系统里配好的 | `F1` | +| `team_code`（单位编码） | **必须** | 参赛单位编码，抄系统里配好的。**两个单位联合参赛（联队）就写 `A+B`**，见第三节 | `F1`；联队写 `F1+F2` | | `athlete_name`（姓名） | **必须** | 运动员姓名。**团体项目这一列留空** | `张伟` | | `id_card`（证件号） | 可选 | 证件号（身份证号）。**系统的第一认人依据**；一个证件号只能属于一个人 | `110101199001011234` | | `gender`（性别） | 可选 | 性别，只写「男」或「女」 | `男` | @@ -88,6 +88,39 @@ 在系统「基础数据 → 参赛单位」里给每个大单位配的**编码**，比如 `F1`、`F2`。系统里没有的会提示「单位 XXX 不存在」。 被「彻底删除」的单位，导入时若再次用到它的编码，它会**重新出现（复活）**，这一行照常导入——单位编码是唯一的，系统按编码复用原来那条记录，它以前的报名、成绩与积分都还在。 +**两个单位联合参赛（联队）怎么写** + +同一小项组别里，两个单位合起来出一支队参赛时，**这一格写两个编码、中间用 `+` 连起来**： + +``` +F1+F2 +``` + +- **加号左边那个是「主单位」**：名次与榜单的归属主体就是它。`F1+F2` 与 `F2+F1` 是**两条不同的报名**（主单位不同），同一组别里只写一条即可； +- **全角 `＋` 与两侧空格都认**：`F1＋F2`、`F1 + F2` 与 `F1+F2` 是同一个意思（中文输入法下打出来的常是全角）； +- **默认均分**：两个单位各占一半（50% / 50%）。团体第 1 名 15 分 → 两个单位**各 7.5 分**；奖牌**两边各记一枚整枚**（联队的金牌，F1、F2 各记 1 枚）； +- ⚠️ **想改成非均分（例如 2:1）不能在表里写**：导入表只表达「是哪几个单位」。份额要等导入完到「成绩录入」页**点那一行的「单位」格**，在「成员单位与份额」弹窗里改（见[使用手册 · 4.11](./使用手册.md#411-联队两个单位合并参赛)）； +- **一个联队最多 5 个单位**；成员单位一个都不能写错——写错的那一行会被拦下，其余行照常导入； +- **加号两边都必须有编码**，而且同一个单位不能写两遍。 + +**怎么写会被拦下（逐行报错，其余行照常导入）** + +| 写成 | 报错 | +|---|---| +| `F1+` / `+F2` / `F1++F2` | `第 N 行：单位编码 F1+ 里有一段是空的：联队要写成两个单位编码用 + 连起来（例如 A+B）` | +| `F1+F1` | `第 N 行：单位编码 F1+F1 里同一个单位出现了两次：联队的每个单位只能写一次` | +| `F1+F2+F3+F4+F5+F6` | `第 N 行：单位编码 F1+F2+F3+F4+F5+F6 里写了 6 个单位：一个联队最多 5 个单位` | +| `F1+ZZ`（`ZZ` 不存在） | `第 N 行：单位 ZZ 不存在（来自联队编码 F1+ZZ）` | +| `ZZ`（单个单位，写法没变） | `第 N 行：单位 ZZ 不存在` | + +> 报错都写在**行号**上，并把你那一格**原样打出来**——照那句话改那一行即可，不用重传整张表。 + +**导入之后长什么样** + +- 联队仍是一条报名，但**分与奖牌都按份额记给各成员单位**：单位总分榜、单位奖牌榜上 A、B 各有一份； +- 大屏和导出件里写的是**联队的名字**：`第一分公司+第二分公司联队`，报名名单导出的「单位编码」列也回写成 `F1+F2`（**导出的名单可以直接拿去重导**，不用手工改回单个单位）； +- 用成员单位筛「报名名单」导出时，**也能看到这条联队报名**（否则 B 导出自己的名单会以为没派人上场）。 + ### `athlete_name` 运动员姓名 - **个人项目**：填姓名，必填。 - **团体项目**：**这一列留空**，表示"这是某个单位的一条团体报名"，队员写在 `member_names` 里。 @@ -163,7 +196,7 @@ --- -## 四、三个完整例子 +## 四、四个完整例子 ### 例 1：个人项目（七单位 × 若干人） @@ -195,6 +228,24 @@ 这类项目（比如团体引体向上）**按个人报名填**：每人一行、填姓名和单位。系统会自己算两份成绩——个人的名次分记在个人身上，团体分按各队成员的**平均成绩**排名后算给单位。**不需要**再单独写团体行。 +### 例 4：两个单位联合参赛（联队） + +本届运动会 6 项球类比赛里，**F2 与 F5 因参赛人数不足，合并出一个队参赛**。`BALL` 是篮球、`男子组`： + +| event_code | category | team_code | athlete_name | id_card | gender | age | bib | seed | heat | status | member_names | +|---|---|---|---|---|---|---|---|---|---|---|---| +| BALL | 男子组 | F1 | | | | | | | | registered | 张三/李四 | +| BALL | 男子组 | F2+F5 | | | | | | | | registered | 王五/赵六/钱七 | +| BALL | 男子组 | F3 | | | | | | | | registered | 孙八 | + +要点： + +- **写一条 `F2+F5` 的报名就够了**，不要 F2、F5 各写一条（那会变成两队人上场）；也不要新建一个叫「F2F5」的单位； +- `F2` 在**加号左边**，所以 **F2 是主单位**：这一条的名次与榜单以它为主体。写成 `F5+F2` 是另一条报名（主单位变成 F5），同一组别里只写一种； +- 默认**均分**：这条成绩拿到的分，F2 与 F5 **各一半**（团体第 1 名 15 分 → 各 7.5 分）；奖牌**两边各记一枚整枚**（一块金牌，F2 榜上 1 枚、F5 榜上 1 枚）； +- 要改成 **2:1** 这类非均分：**不能在这张表里写**，导入后到「成绩录入」页点那一行的「单位」格改（见[使用手册 · 4.11](./使用手册.md#411-联队两个单位合并参赛)）； +- 大屏与导出件里写的是 `第二分公司+第五分公司联队`，报名名单导出的「单位编码」列回写成 `F2+F5`（可以直接拿去重导）。 + --- ## 五、导入前请先检查（自检清单） @@ -210,6 +261,7 @@ - [ ] 每个证件号在系统里只属于一个人，别和别人的档案重号 - [ ] `status` 只用那 4 个英文词（大小写都行）或第三节列的中文别名，不写别的词；拿不准就留空 - [ ] `heat` 要么留空，要么是 1–999 的整数（不参与算分，只是录入分组） +- [ ] **联队**（两个单位联合参赛）写的是 `F1+F2` 这种形状：加号两边都有编码、**同一个单位没写两遍**、成员不超过 5 个；**加号左边那个是主单位**（见第三节） - [ ] 全表没有因为"怕麻烦"把某些列删掉——**表头 8 个必须列一个都不能少**（哪怕整列是空的） - [ ] 用的是**分工作表模板**时：每张工作表的名字都是「小项名称@组别名称」、没有多余的工作表；「项目编码 / 组别」两列要么整列留空、要么与表名一字不差（见第八节） @@ -228,6 +280,10 @@ | 无法解析 CSV：表格里多半有没配对的双引号 | 格子里**手工**写了双引号，或只有一个引号没配对 | 让 Excel 重新另存一次（引号由 Excel 按规则加，别手工写）；确实需要引号的，写成 `""` 转义 | | 第 N 行：小项 XXX 不存在 | `event_code` 写错，或该小项还没在系统里配 | 到「基础数据 → 大项 / 小项」核对编码；没配的先配 | | 第 N 行：单位 XX 不存在 | `team_code` 写错，或该单位还没配 | 到「基础数据 → 参赛单位」核对 | +| 第 N 行：单位 ZZ 不存在（来自联队编码 F1+ZZ） | 这一格写的是**联队** `F1+ZZ`，其中 `ZZ` 没配 | 核对加号右边那个编码（括号里把**整格**原样打出来了，一眼看出是哪一段没对上）；不改联队写法的话，就照单单位的办法核对编码 | +| 第 N 行：单位编码 F1+ 里有一段是空的：联队要写成两个单位编码用 + 连起来（例如 A+B） | **加号有一边是空的**（`F1+`、`+F2`、`F1++F2` 都是这一条）。多半是填一半或多了个加号 | 补上缺的那个编码，或删掉多余的加号；联队至少两个单位 | +| 第 N 行：单位编码 F1+F1 里同一个单位出现了两次：联队的每个单位只能写一次 | 同一个单位在联队里写了两遍（`F1+F1`） | 一个单位只写一次；两个单位联合参赛就是 `F1+F2` | +| 第 N 行：单位编码 … 里写了 6 个单位：一个联队最多 5 个单位 | 加号太多、成员超过 5 个 | **一个联队最多 5 个单位**；现场最多见过三个单位合并，超过 5 个多半是这一格填错了东西（例如整格都是加号） | | 第 N 行：组别 XXX 不存在 | 组别名和系统里不一致，或该小项还没有这个组别 | 到「基础数据 → 组别」核对名称（注意别多字少字） | | 第 N 行：小项 XXX 没有组别 | 该小项一个组别都没配 | 先在「组别」里配好，再导入 | | 第 N 行：填写了 athlete_name 就必须填 id_card 或 bib | 个人行缺两项标识 | 补证件号或号码布；确实都没有的，请先在「运动员」里登记 | @@ -292,6 +348,7 @@ - **「项目编码」「组别」两列可以整列留空**——表名已经说明了是哪个小项、哪个组别； 一旦填了，就**必须与表名一致**，不一致的那一行会报错并跳过（系统不猜、也不会挑一个用）； - 其余列与单表模板完全一样（第三节逐列说明照样适用）； +- **下载下来的模板自带「联队怎么写」的说明**：分工作表模板里，「单位编码」**表头那一格有单元格批注**（鼠标停上去弹出，右边带一个小红三角），**该列每一格还有输入提示**（点中格子就弹出来）；中文表头、英文表头各一份，内容就是 `A+B` 这套写法（加号左边是主单位、积分平均分、奖牌两边各记一枚）。**说明只挂在批注与输入提示上，不占任何一格数据、也不改表头与列序**——填好的表原样传回来照样导入； - **只填了表头、没填人的那张表**会被跳过并给一条提示（= 这个组别没人报名），其余表照常导入； - 不要在工作簿里加「说明」之类的工作表：**只要工作簿里有一张表名带 `@`**，整份文件就按分工作表模板处理， 其它表名（例如 `Sheet1`、`备注`）必须也是「小项名称@组别名称」的形状，否则**整份拒绝**并点名是哪张表—— @@ -337,6 +394,7 @@ Excel 对工作表名有硬限制：**最长 31 个字符**，同一份工作簿 > 7. 表里**不要合并单元格**、不要加标题行、不要插图； > 8. 填完先对着第五节的清单自查一遍，再发给收表人； > 9. **批次（`heat`）**可以不填；要分批比赛就填 1–999 的整数，它只影响录入时怎么分组找人，**不影响成绩与名次**； -> 10. **存成什么格式**：Excel →「另存为」→「**CSV UTF-8 (逗号分隔) (*.csv)**」最稳；中文 Excel 默认的「CSV (逗号分隔)」也能用。**别用「Unicode 文本」（UTF-16）**，**别手工改名或把两个文件拼起来**，也别在格子里手写双引号（让 Excel 自己加）。 +> 10. **两个单位联合参赛（联队）**：`team_code` 那一格写 `F1+F2`（加号左边是主单位，默认均分，最多 5 个单位），**不要**新建一个「联队单位」、也不要两个单位各写一行；非均分（例如 2:1）要在导入后到「成绩录入」页点那一行的「单位」格改； +> 11. **存成什么格式**：Excel →「另存为」→「**CSV UTF-8 (逗号分隔) (*.csv)**」最稳；中文 Excel 默认的「CSV (逗号分隔)」也能用。**别用「Unicode 文本」（UTF-16）**，**别手工改名或把两个文件拼起来**，也别在格子里手写双引号（让 Excel 自己加）。 > > 一句话：**下载模板 → 只往下面粘数据 → 另存为 CSV UTF-8 → 上传**。中间任何一个"顺手改一下"都可能让整份表被拦下。 diff --git a/server/internal/domain/helpers_test.go b/server/internal/domain/helpers_test.go index b7710f0..27b9c27 100644 --- a/server/internal/domain/helpers_test.go +++ b/server/internal/domain/helpers_test.go @@ -82,6 +82,8 @@ type participant struct { status ResultStatus entryStatus EntryStatus state ResultState + // shares 是联队份额（多个单位共享一条成绩）；留空 = 主单位独占 100%。 + shares []TeamShare } func fixture(ps []participant) ([]Entry, []Result) { @@ -91,7 +93,7 @@ func fixture(ps []participant) ([]Entry, []Result) { entries = append(entries, Entry{ ID: p.entryID, EventID: 1, CategoryID: 1, TeamID: p.teamID, AthleteID: p.athleteID, AthleteName: p.name, - Status: p.entryStatus, + Status: p.entryStatus, TeamShares: p.shares, }) state := p.state if state == "" { diff --git a/server/internal/domain/joint_team_test.go b/server/internal/domain/joint_team_test.go new file mode 100644 index 0000000..c6422d7 --- /dev/null +++ b/server/internal/domain/joint_team_test.go @@ -0,0 +1,377 @@ +package domain + +import ( + "testing" +) + +// 本文件钉住「联队 + 份额分成」的算分口径（devdocs/19 第三节的五条拍板）。 +// +// 两个口径必须分开表达，测试也分成两组： +// - 积分按份额拆：团体第 1 名 15 分 → 联队的两个单位各 7.5 分（允许出现小数）； +// - 奖牌整枚各记：同一个金牌 → 两个单位**各记 1 枚**（不是各 0.5 枚）。 +// +// 另外单钉一处最容易错的口径：份额与 count_to_team / count_to_medals 两个通道开关叠加。 +// 单位总分公式是 `Σ仅记单位的流水 + 全局系数 × Σ(记到个人且 count_to_team=1 的流水)`， +// 份额只改「这一份分记在哪个单位头上」，两个开关仍然按通道整体决定这条流水算不算数。 + +// jointShares 构造联队份额：两个单位均分（默认口径），奖牌各记整枚。 +func jointShares(teamIDs ...int64) []TeamShare { + out := make([]TeamShare, 0, len(teamIDs)) + for _, id := range teamIDs { + out = append(out, TeamShare{TeamID: id}) + } + return out +} + +// weightedShares 构造按给定权重拆分的份额（奖牌缺省 = 整枚各记）。 +func weightedShares(pairs ...any) []TeamShare { + out := make([]TeamShare, 0, len(pairs)/2) + for i := 0; i+1 < len(pairs); i += 2 { + out = append(out, TeamShare{TeamID: pairs[i].(int64), Weight: pairs[i+1].(float64)}) + } + return out +} + +// medalOf 取单位奖牌榜上某单位的金银铜。 +func medalOf(rows []MedalRow, teamID int64) (gold, silver, bronze int) { + for _, r := range rows { + if r.TeamID == teamID { + return r.Gold, r.Silver, r.Bronze + } + } + return 0, 0, 0 +} + +// teamMedalRows 用一份「引擎产出」直接算单位奖牌榜。 +func teamMedalRows(t *testing.T, ledger []LedgerEntry, ranked []RankedResult, teamIDs ...int64) []MedalRow { + t.Helper() + return BuildMedalStandings(StandingsInput{ + Teams: testTeams(teamIDs...), + Ledger: ledger, + Ranked: ranked, + }) +} + +// scoreTeamManualWithEntries 用团体手工名次通道跑一次计分：名次按单位录（联队录在主单位上）， +// 报名项由调用方给（联队的名次想按份额拆，库里得先有那条联队报名）。 +func scoreTeamManualWithEntries(t *testing.T, entries []Entry, ranks ...TeamManualRank) EventScore { + t.Helper() + return mustScore(t, EventScoreInput{ + Event: teamEvent(1), Category: testCategory(), + Channels: []ScoreChannel{teamManualChannel(9)}, + Profiles: map[int64]ScoringProfile{9: teamTop6()}, + Entries: entries, + TeamRanks: ranks, + }) +} + +// 口径 2：团体第 1 名 15 分，联队的两个单位各 7.5 分（奇数分平均拆，允许 .5）。 +func TestJointTeamSplitsPointsEvenly(t *testing.T) { + // 团体报名项（athlete_id=0）+ 份额 [A,B]，名次录在主单位 A 上。 + entries, _ := fixture([]participant{{entryID: 1, teamID: 1, shares: jointShares(1, 2)}}) + es := scoreTeamManualWithEntries(t, entries, TeamManualRank{TeamID: 1, Rank: 1}) + + pts := pointsByTeam(es.Ledger) + if !nearlyEqual(pts[1], 7.5) || !nearlyEqual(pts[2], 7.5) { + t.Fatalf("联队第 1 名应各得 7.5 分，得到 A=%v B=%v（流水：%+v）", pts[1], pts[2], es.Ledger) + } + // 拆出来的份数之和必须正好等于原来那一份，否则「一个单位改成联队」会悄悄改变总分。 + if !nearlyEqual(pts[1]+pts[2], 15) { + t.Fatalf("两份之和应等于 15，得到 %v", pts[1]+pts[2]) + } + // 每一条份额各是一条流水（各有 team_id），名次本身只有一条。 + if len(es.Ledger) != 2 { + t.Fatalf("应产出 2 条流水（A、B 各一条），得到 %d 条：%+v", len(es.Ledger), es.Ledger) + } + for _, l := range es.Ledger { + if l.AthleteID != 0 { + t.Fatalf("团体通道的流水不该挂个人：%+v", l) + } + } + if len(es.Ranked) != 1 || len(es.Ranked[0].Shares) != 2 { + t.Fatalf("名次明细应只有一条、带两份份额：%+v", es.Ranked) + } +} + +// 名次直接录在联队报名项上（成绩录入页填名次，不走按单位录的团体名次）也必须按份额拆。 +func TestJointTeamSplitsPointsFromEntryRank(t *testing.T) { + entries, results := fixture([]participant{{ + entryID: 1, teamID: 1, shares: jointShares(1, 2), rank: 1, noValue: true, + }}) + es := mustScore(t, EventScoreInput{ + Event: teamEvent(1), Category: testCategory(), + Channels: []ScoreChannel{teamManualChannel(9)}, + Profiles: map[int64]ScoringProfile{9: teamTop6()}, + Entries: entries, Results: results, + }) + pts := pointsByTeam(es.Ledger) + if !nearlyEqual(pts[1], 7.5) || !nearlyEqual(pts[2], 7.5) { + t.Fatalf("联队报名项上的第 1 名应各得 7.5 分，得到 A=%v B=%v", pts[1], pts[2]) + } +} + +// 口径 3：奖牌整枚各记——联队拿到的金牌，两个单位各记 1 枚完整金牌。 +func TestJointTeamMedalsAreWholeForEachMember(t *testing.T) { + entries, _ := fixture([]participant{{entryID: 1, teamID: 1, shares: jointShares(1, 2)}}) + es := scoreTeamManualWithEntries(t, entries, TeamManualRank{TeamID: 1, Rank: 1}) + + rows := teamMedalRows(t, es.Ledger, es.Ranked, 1, 2, 3) + if gold, _, _ := medalOf(rows, 1); gold != 1 { + t.Fatalf("主单位 A 应记 1 枚金牌，得到 %d 枚（%+v）", gold, rows) + } + if gold, _, _ := medalOf(rows, 2); gold != 1 { + t.Fatalf("成员单位 B 应记 1 枚金牌（不是 0.5 枚），得到 %d 枚（%+v）", gold, rows) + } + if gold, _, _ := medalOf(rows, 3); gold != 0 { + t.Fatalf("没参赛的单位不该有奖牌，得到 %d 枚", gold) + } +} + +// 可配权重：2:1 时积分按 2:1 拆，奖牌仍是各 1 枚（两个口径互不影响）。 +func TestJointTeamWeightsAreConfigurable(t *testing.T) { + entries, _ := fixture([]participant{{ + entryID: 1, teamID: 1, shares: weightedShares(int64(1), 2.0, int64(2), 1.0), + }}) + es := scoreTeamManualWithEntries(t, entries, TeamManualRank{TeamID: 1, Rank: 1}) + + pts := pointsByTeam(es.Ledger) + if !nearlyEqual(pts[1], 10) || !nearlyEqual(pts[2], 5) { + t.Fatalf("2:1 的权重应拆成 10 / 5，得到 A=%v B=%v（流水：%+v）", pts[1], pts[2], es.Ledger) + } + if !nearlyEqual(pts[1]+pts[2], 15) { + t.Fatalf("2:1 拆分后两份之和应仍是 15，得到 %v", pts[1]+pts[2]) + } + rows := teamMedalRows(t, es.Ledger, es.Ranked, 1, 2) + if gold, _, _ := medalOf(rows, 2); gold != 1 { + t.Fatalf("权重只影响积分，奖牌仍是整枚各记：B 应 1 枚金牌，得到 %d 枚", gold) + } +} + +// 份额上的 medal 开关：显式关掉时该单位不记这枚奖牌（积分不受影响）。 +func TestJointTeamMedalCanBeTurnedOffPerMember(t *testing.T) { + noMedal := false + shares := []TeamShare{{TeamID: 1, Medal: &noMedal}, {TeamID: 2}} + entries, _ := fixture([]participant{{entryID: 1, teamID: 1, shares: shares}}) + es := scoreTeamManualWithEntries(t, entries, TeamManualRank{TeamID: 1, Rank: 1}) + + rows := teamMedalRows(t, es.Ledger, es.Ranked, 1, 2) + if gold, _, _ := medalOf(rows, 1); gold != 0 { + t.Fatalf("显式关掉奖牌的成员单位不该记牌，得到 %d 枚", gold) + } + if gold, _, _ := medalOf(rows, 2); gold != 1 { + t.Fatalf("没关掉的那个单位仍记 1 枚，得到 %d 枚", gold) + } + pts := pointsByTeam(es.Ledger) + if !nearlyEqual(pts[1], 7.5) || !nearlyEqual(pts[2], 7.5) { + t.Fatalf("奖牌开关不该影响积分分配，得到 A=%v B=%v", pts[1], pts[2]) + } +} + +// 份额 × 通道开关（count_to_team / count_to_medals）的叠加矩阵。 +// +// 这一处最容易错：份额只改「这一份记在哪个单位头上」，两个开关仍然按通道整体决定 +// 这条流水/名次算不算数。四种组合都必须能单独说清。 +func TestJointTeamSharesWithChannelSwitches(t *testing.T) { + countToTeam := func(v bool) *bool { return &v } + + t.Run("团体通道 + count_to_team=1：两份都进单位总分", func(t *testing.T) { + entries, _ := fixture([]participant{{entryID: 1, teamID: 1, shares: jointShares(1, 2)}}) + es := scoreTeamManualWithEntries(t, entries, TeamManualRank{TeamID: 1, Rank: 1}) + sums := SumByTeam(es.Ledger, 1) + if !nearlyEqual(sums[1].Total, 7.5) || !nearlyEqual(sums[2].Total, 7.5) { + t.Fatalf("两个单位各应得 7.5 分（仅记单位通道），得到 A=%+v B=%+v", sums[1], sums[2]) + } + if !nearlyEqual(sums[1].TeamOnly, 7.5) { + t.Fatalf("团体通道的流水应记在「仅记单位」一栏，得到 %+v", sums[1]) + } + }) + + t.Run("团体通道 + count_to_team=0：流水照记，但不进任何单位的总分", func(t *testing.T) { + ch := teamManualChannel(9) + ch.CountToTeam = countToTeam(false) + entries, _ := fixture([]participant{{entryID: 1, teamID: 1, shares: jointShares(1, 2)}}) + es := mustScore(t, EventScoreInput{ + Event: teamEvent(1), Category: testCategory(), + Channels: []ScoreChannel{ch}, Profiles: map[int64]ScoringProfile{9: teamTop6()}, + Entries: entries, TeamRanks: []TeamManualRank{{TeamID: 1, Rank: 1}}, + }) + if len(es.Ledger) != 2 { + t.Fatalf("流水要照记（每条份额一条），得到 %d 条", len(es.Ledger)) + } + for _, l := range es.Ledger { + if l.CountToTeam { + t.Fatalf("通道关掉计入单位总分后，流水上的 count_to_team 应为 false：%+v", l) + } + } + if sums := SumByTeam(es.Ledger, 1); len(sums) != 0 { + t.Fatalf("关掉 count_to_team 后不该有任何单位分，得到 %+v", sums) + } + }) + + t.Run("个人通道 + count_to_team=1：两份都按个人分进各自单位（乘系数）", func(t *testing.T) { + entries, results := fixture([]participant{{ + entryID: 1, athleteID: 101, teamID: 1, shares: jointShares(1, 2), value: 10, + }}) + es := mustScore(t, EventScoreInput{ + Event: individualEvent(1), Category: testCategory(), + Channels: []ScoreChannel{athleteResultChannel(9)}, Profiles: map[int64]ScoringProfile{9: individualTop6()}, + Entries: entries, Results: results, + }) + sums := SumByTeam(es.Ledger, 1) + if !nearlyEqual(sums[1].Individual, 5) || !nearlyEqual(sums[2].Individual, 5) { + t.Fatalf("个人通道的两份应各进各自单位的个人分（各 5），得到 A=%+v B=%+v", sums[1], sums[2]) + } + // 系数只乘一次：单位总分 = 系数 × 个人分，联队不会把这条成绩算两遍。 + if sums := SumByTeam(es.Ledger, 0.5); !nearlyEqual(sums[1].Total, 2.5) { + t.Fatalf("系数 0.5 下 A 的总分应为 2.5，得到 %v", sums[1].Total) + } + // 个人榜不受份额影响：这两条流水加起来还是原来那 10 分。 + if ath := SumByAthlete(es.Ledger); !nearlyEqual(ath[101], 10) { + t.Fatalf("个人榜上该运动员应仍是 10 分，得到 %v", ath[101]) + } + }) + + t.Run("个人通道 + count_to_team=0：只记个人榜，不进任何单位总分", func(t *testing.T) { + ch := athleteResultChannel(9) + ch.CountToTeam = countToTeam(false) + entries, results := fixture([]participant{{ + entryID: 1, athleteID: 101, teamID: 1, shares: jointShares(1, 2), value: 10, + }}) + es := mustScore(t, EventScoreInput{ + Event: individualEvent(1), Category: testCategory(), + Channels: []ScoreChannel{ch}, Profiles: map[int64]ScoringProfile{9: individualTop6()}, + Entries: entries, Results: results, + }) + if sums := SumByTeam(es.Ledger, 1); len(sums) != 0 { + t.Fatalf("count_to_team=0 的个人通道不该进单位总分，得到 %+v", sums) + } + if ath := SumByAthlete(es.Ledger); !nearlyEqual(ath[101], 10) { + t.Fatalf("个人榜照旧记 10 分，得到 %v", ath[101]) + } + }) + + t.Run("count_to_medals=0：不发奖牌（积分照发）", func(t *testing.T) { + ch := teamManualChannel(9) + no := false + ch.CountToMedals = &no + entries, _ := fixture([]participant{{entryID: 1, teamID: 1, shares: jointShares(1, 2)}}) + es := mustScore(t, EventScoreInput{ + Event: teamEvent(1), Category: testCategory(), + Channels: []ScoreChannel{ch}, Profiles: map[int64]ScoringProfile{9: teamTop6()}, + Entries: entries, TeamRanks: []TeamManualRank{{TeamID: 1, Rank: 1}}, + }) + rows := teamMedalRows(t, es.Ledger, es.Ranked, 1, 2) + if gold, _, _ := medalOf(rows, 1); gold != 0 { + t.Fatalf("关掉奖牌通道后 A 不该有金牌，得到 %d 枚", gold) + } + if gold, _, _ := medalOf(rows, 2); gold != 0 { + t.Fatalf("关掉奖牌通道后 B 不该有金牌，得到 %d 枚", gold) + } + if pts := pointsByTeam(es.Ledger); !nearlyEqual(pts[1], 7.5) { + t.Fatalf("奖牌开关不影响积分：A 应仍是 7.5，得到 %v", pts[1]) + } + }) + + t.Run("个人通道 + count_to_team_medals=0：个人榜有牌、单位榜没有", func(t *testing.T) { + ch := athleteResultChannel(9) + no := false + ch.CountToTeamMedals = &no + entries, results := fixture([]participant{{ + entryID: 1, athleteID: 101, teamID: 1, shares: jointShares(1, 2), value: 10, + }}) + es := mustScore(t, EventScoreInput{ + Event: individualEvent(1), Category: testCategory(), + Channels: []ScoreChannel{ch}, Profiles: map[int64]ScoringProfile{9: individualTop6()}, + Entries: entries, Results: results, + }) + rows := teamMedalRows(t, es.Ledger, es.Ranked, 1, 2) + if gold, _, _ := medalOf(rows, 1); gold != 0 { + t.Fatalf("个人奖牌不并入单位榜时 A 不该有金牌，得到 %d 枚", gold) + } + ath := BuildAthleteStandings(StandingsInput{ + Athletes: []Athlete{{ID: 101, Name: "选手A", TeamID: 1}}, + Ledger: es.Ledger, Ranked: es.Ranked, + }) + if len(ath) != 1 || ath[0].Gold != 1 { + t.Fatalf("个人榜上该运动员仍应有 1 枚金牌，得到 %+v", ath) + } + }) +} + +// 联队报名不影响普通报名项：同一个小项里既有联队又有单单位时，两边各按自己的份额落分。 +func TestJointTeamCoexistsWithSingleTeamEntries(t *testing.T) { + // 项目按成绩升序排名（individualEvent 的 compare=asc），联队跑得更好，拿第 1 名。 + entries, results := fixture([]participant{ + {entryID: 1, teamID: 1, shares: jointShares(1, 2), value: 80}, + {entryID: 2, teamID: 3, value: 90}, + }) + ev := teamEvent(1) + es := mustScore(t, EventScoreInput{ + Event: ev, Category: testCategory(), + Channels: []ScoreChannel{{ID: 4, EventID: 1, Scope: ScopeTeam, Basis: BasisResult, ProfileID: 9}}, + Profiles: map[int64]ScoringProfile{9: teamTop6()}, + Entries: entries, Results: results, + }) + pts := pointsByTeam(es.Ledger) + if !nearlyEqual(pts[1], 7.5) || !nearlyEqual(pts[2], 7.5) { + t.Fatalf("联队第 1 名应各得 7.5，得到 A=%v B=%v", pts[1], pts[2]) + } + if !nearlyEqual(pts[3], 10) { + t.Fatalf("单独报名的第 2 名应独得 10 分，得到 %v", pts[3]) + } +} + +// 没有配份额（老数据、普通报名）时引擎的产出必须与升级前逐位一致： +// 一条流水、整份分、整枚牌，且拆分的浮点计算不能引入零头。 +func TestWholeShareStaysExact(t *testing.T) { + entries, _ := fixture([]participant{{entryID: 1, teamID: 7}}) + es := scoreTeamManualWithEntries(t, entries, TeamManualRank{TeamID: 7, Rank: 1}) + if len(es.Ledger) != 1 { + t.Fatalf("独占 100%% 只该产出一条流水，得到 %d 条：%+v", len(es.Ledger), es.Ledger) + } + if got := es.Ledger[0].Points; got != 15 { + t.Fatalf("独占时的积分应逐位等于 15，得到 %v", got) + } + if got := es.Ranked[0].Shares; len(got) != 1 || got[0].TeamID != 7 || got[0].Weight != 1 || got[0].Medal != nil { + t.Fatalf("独占时的份额应与升级前完全一致（TeamID=7 Weight=1 Medal=nil），得到 %+v", got) + } + rows := teamMedalRows(t, es.Ledger, es.Ranked, 7, 8) + if gold, _, _ := medalOf(rows, 7); gold != 1 { + t.Fatalf("独占时该单位应记 1 枚金牌，得到 %d 枚", gold) + } +} + +// splitSharePoints 的边界：权重非法（0 / 负数）按 1 处理，拆分之和恒等于总分。 +func TestSplitSharePointsKeepsTotal(t *testing.T) { + cases := []struct { + name string + total float64 + shares []TeamShare + want []float64 + }{ + {"独占", 15, []TeamShare{{TeamID: 1, Weight: 1}}, []float64{15}}, + {"均分（奇数分）", 15, []TeamShare{{TeamID: 1}, {TeamID: 2}}, []float64{7.5, 7.5}}, + {"2:1（除不尽）", 15, weightedShares(int64(1), 2.0, int64(2), 1.0), []float64{10, 5}}, + {"三单位均分", 15, []TeamShare{{TeamID: 1}, {TeamID: 2}, {TeamID: 3}}, []float64{5, 5, 5}}, + {"三点均分", 10, []TeamShare{{TeamID: 1}, {TeamID: 2}, {TeamID: 3}}, []float64{10.0 / 3, 10.0 / 3, 10.0 - 2*(10.0/3)}}, + {"零权重按 1 处理", 15, weightedShares(int64(1), 0.0, int64(2), 1.0), []float64{7.5, 7.5}}, + } + for _, tc := range cases { + t.Run(tc.name, func(t *testing.T) { + got := splitSharePoints(tc.total, tc.shares) + if len(got) != len(tc.want) { + t.Fatalf("份数 = %d，期望 %d（%v）", len(got), len(tc.want), got) + } + sum := 0.0 + for i := range tc.want { + if !nearlyEqual(got[i], tc.want[i]) { + t.Errorf("第 %d 份 = %v，期望 %v（完整 %v）", i+1, got[i], tc.want[i], got) + } + sum += got[i] + } + if !nearlyEqual(sum, tc.total) { + t.Errorf("拆分之和 = %v，期望 %v（零头会让榜单印出 9.999999999999998）", sum, tc.total) + } + }) + } +} diff --git a/server/internal/domain/legacy_forms_golden_test.go b/server/internal/domain/legacy_forms_golden_test.go new file mode 100644 index 0000000..5acbeb2 --- /dev/null +++ b/server/internal/domain/legacy_forms_golden_test.go @@ -0,0 +1,240 @@ +package domain + +import ( + "crypto/sha256" + "encoding/hex" + "fmt" + "strings" + "testing" +) + +// 本文件是「无联队的老数据在积分、奖牌、榜单上逐字节不变」的硬门槛回归（devdocs/19 §五）。 +// +// 覆盖四种形态： +// - 普通个人：个人成绩通道； +// - 纯团体：按单位录名次的团体手工通道（球类项目走的就是它）； +// - 双计：individual_team 的个人通道（不计入单位总分）+ 团体聚合通道； +// - 团体报名项双通道：团体报名项（athlete_id=0）+ 个人成绩通道 + 团体手工通道， +// 并单独覆盖「团体报名项没有名次、名次来自按单位录入的覆盖值」这一支 +// （联队改动正好动了这里：有联队报名才按份额拆，没有就还是单位独占）。 +// +// 签名取自**联队实现之前**的代码（在 git archive HEAD 的修前副本上跑出来的），实现之后必须一字不差。 +// 签名文本只写「积分 / 名次 / 归属单位 / 榜单」这些事实，不写结构体形状： +// 份额按 `单位ID:权重` 打印，于是给 TeamShare 加字段（奖牌整枚开关）不会把这份签名带跑偏。 +const legacyFormsGoldenSHA256 = "a2aa1c977f68b0943eade20ac4c54de51cde157c495c9104c80b0bbfca5d65ff" + +// TestLegacyFormsScoringUnchanged 是本次改动的硬门槛：老数据（没有联队）四形态逐字节不变。 +func TestLegacyFormsScoringUnchanged(t *testing.T) { + dump := legacyFormsDump(t) + + // 防空转：四种形态都必须真的留下痕迹，否则签名只是一份空文本。 + for _, marker := range []string{"individual ", "team-manual ", "individual-team ", "team-entry ", + "team-entry-override ", "team-entry-override-only ", "aggregate-valid ", "aggregate-all "} { + if !strings.Contains(dump, marker) { + t.Fatalf("签名里缺少形态 %q，对拍没有覆盖到它：\n%s", marker, dump) + } + } + + sum := sha256.Sum256([]byte(dump)) + got := hex.EncodeToString(sum[:]) + if got != legacyFormsGoldenSHA256 { + t.Fatalf("无联队的老数据在积分 / 奖牌 / 榜单上变了：\n签名 = %s\n期望 = %s\n\n%s", + got, legacyFormsGoldenSHA256, dump) + } +} + +// legacyFormsDump 把四种形态的引擎产出与榜单拼成一份稳定文本。 +// +// 稳定性来源：流水与名次按切片顺序打印（引擎的输出顺序本身就是确定的）， +// 排行榜的行顺序是领域函数排序的结果（末位都有 ID 兜底，是全序），不依赖 map 遍历顺序。 +func legacyFormsDump(t *testing.T) string { + t.Helper() + var lines []string + + // 个人榜的运动员信息由引擎产出反推（与读侧从库里查同一批人等价）， + // 这样签名里不会混进测试自己编的单位归属。 + athletesOf := func(es EventScore) []Athlete { + seen := make(map[int64]bool) + var out []Athlete + for _, r := range es.Ranked { + if r.AthleteID == 0 || seen[r.AthleteID] { + continue + } + seen[r.AthleteID] = true + out = append(out, Athlete{ID: r.AthleteID, Name: r.AthleteName, TeamID: r.TeamID}) + } + return out + } + + appendScore := func(name string, es EventScore, teams []Team, athletes []Athlete) { + athletes = athletesOf(es) + for _, l := range es.Ledger { + lines = append(lines, fmt.Sprintf( + "%s ledger team=%d athlete=%d entry=%d result=%d source=%s/%d points=%v countToTeam=%v voided=%v", + name, l.TeamID, l.AthleteID, l.EntryID, l.ResultID, l.SourceType, l.SourceID, + l.Points, l.CountToTeam, l.Voided)) + } + for _, r := range es.Ranked { + lines = append(lines, fmt.Sprintf( + "%s ranked key=%s scope=%s basis=%s team=%d athlete=%d rank=%d points=%v shares=%s medals=%v/%v/%v", + name, r.SubjectKey, r.Scope, r.Basis, r.TeamID, r.AthleteID, r.Rank, r.Points, + formatShares(r.Shares), r.AwardMedals, r.CountToMedals, r.CountToTeamMedals)) + } + for _, weight := range []float64{1, 0.5} { + for _, exclude := range []bool{false, true} { + in := StandingsInput{ + Teams: teams, Athletes: athletes, Ledger: es.Ledger, Ranked: es.Ranked, + IndividualToTeamWeight: weight, ExcludeTeamEventMedals: exclude, + } + for _, row := range BuildTeamStandings(in) { + lines = append(lines, fmt.Sprintf( + "%s standings w=%v ex=%v rank=%d team=%d pts=%v only=%v indiv=%v %d/%d/%d medals=%d", + name, weight, exclude, row.Rank, row.TeamID, row.Points, row.TeamOnlyPoints, + row.IndividualPoints, row.Gold, row.Silver, row.Bronze, row.Medals)) + } + for _, row := range BuildMedalStandings(in) { + lines = append(lines, fmt.Sprintf( + "%s medalboard w=%v ex=%v rank=%d team=%d pts=%v %d/%d/%d total=%d", + name, weight, exclude, row.Rank, row.TeamID, row.Points, + row.Gold, row.Silver, row.Bronze, row.Total)) + } + for _, row := range BuildAthleteStandings(in) { + lines = append(lines, fmt.Sprintf( + "%s athleteboard w=%v ex=%v rank=%d athlete=%d team=%d pts=%v %d/%d/%d medals=%d", + name, weight, exclude, row.Rank, row.AthleteID, row.TeamID, row.Points, + row.Gold, row.Silver, row.Bronze, row.Medals)) + } + } + } + } + + // 形态 1 · 普通个人：一个单位一个人，个人成绩通道（含并列）。 + { + teams := testTeams(1001, 1002, 1003, 1004, 1005, 1006) + entries, results := fixture([]participant{ + {entryID: 1, athleteID: 101, teamID: 1001, name: "选手A", value: 11.2}, + {entryID: 2, athleteID: 102, teamID: 1002, name: "选手B", value: 11.5}, + {entryID: 3, athleteID: 103, teamID: 1003, name: "选手C", value: 11.5}, + {entryID: 4, athleteID: 104, teamID: 1004, name: "选手D", value: 12.0}, + {entryID: 5, athleteID: 105, teamID: 1005, name: "选手E", value: 12.4}, + {entryID: 6, athleteID: 106, teamID: 1006, name: "选手F", value: 13.1}, + }) + es := mustScore(t, EventScoreInput{ + Event: individualEvent(1), Category: testCategory(), + Channels: []ScoreChannel{athleteResultChannel(9)}, + Profiles: map[int64]ScoringProfile{9: individualTop6()}, + Entries: entries, Results: results, + }) + appendScore("individual", es, teams, nil) + } + + // 形态 2 · 纯团体：按单位录的团体手工名次（含并列与顺延录入）。 + { + teams := testTeams(1001, 1002, 1003, 1004, 1005) + es := mustScore(t, EventScoreInput{ + Event: teamEvent(1), Category: testCategory(), + Channels: []ScoreChannel{teamManualChannel(11)}, + Profiles: map[int64]ScoringProfile{11: teamTop6()}, + TeamRanks: []TeamManualRank{ + {TeamID: 1001, Rank: 1}, {TeamID: 1002, Rank: 2}, {TeamID: 1003, Rank: 2}, + {TeamID: 1004, Rank: 4}, {TeamID: 1005, Rank: 5}, + }, + }) + appendScore("team-manual", es, teams, nil) + } + + // 形态 3 · 双计（individual_team）：个人通道只记个人，单位总分按成员成绩平均排名。 + { + teams := testTeams(1001, 1002, 1003) + personal := athleteResultChannel(9) + no := false + personal.CountToTeam = &no + entries, results := fixture([]participant{ + {entryID: 1, athleteID: 101, teamID: 1001, name: "一司1", value: 12}, + {entryID: 2, athleteID: 102, teamID: 1001, name: "一司2", value: 14}, + {entryID: 3, athleteID: 103, teamID: 1002, name: "二司1", value: 13}, + {entryID: 4, athleteID: 104, teamID: 1002, name: "二司2", value: 15}, + {entryID: 5, athleteID: 105, teamID: 1003, name: "三司1", value: 16}, + {entryID: 6, athleteID: 106, teamID: 1003, name: "三司2", value: 16}, + }) + es := mustScore(t, EventScoreInput{ + Event: teamEvent(1), Category: testCategory(), + Channels: []ScoreChannel{personal, teamAggregateChannel(11)}, + Profiles: map[int64]ScoringProfile{9: individualTop6(), 11: teamTop6()}, + Entries: entries, Results: results, + }) + appendScore("individual-team", es, teams, nil) + } + + // 形态 4 · 团体报名项双通道（团体报名项 athlete_id=0 + 个人成绩通道 + 团体手工通道）。 + { + teams := testTeams(1001, 1002, 1003) + entries, results := fixture([]participant{ + {entryID: 1, teamID: 1001, value: 90, rank: 1}, + {entryID: 2, teamID: 1002, value: 80, rank: 2}, + {entryID: 3, teamID: 1003, value: 70, rank: 3}, + }) + in := EventScoreInput{ + Event: teamEvent(1), Category: testCategory(), + Channels: []ScoreChannel{athleteResultChannel(9), teamManualChannel(11)}, + Profiles: map[int64]ScoringProfile{9: individualTop6(), 11: teamTop6()}, + Entries: entries, Results: results, + } + // 4a：名次只来自团体报名项自己的 results.rank。 + appendScore("team-entry", mustScore(t, in), teams, nil) + + // 4b：名次来自「按单位录入的团体名次」（覆盖值优先于报名项自己的名次）。 + withOverride := in + withOverride.TeamRanks = []TeamManualRank{{TeamID: 1001, Rank: 2}, {TeamID: 1002, Rank: 1}} + appendScore("team-entry-override", mustScore(t, withOverride), teams, nil) + + // 4c：团体报名项没有名次，名次只有按单位录入的覆盖值（合成名次那一支）。 + blank, blankResults := fixture([]participant{ + {entryID: 1, teamID: 1001, value: 90}, + {entryID: 2, teamID: 1002, value: 80}, + {entryID: 3, teamID: 1003, value: 70}, + }) + onlyOverride := in + onlyOverride.Entries = blank + onlyOverride.Results = blankResults + onlyOverride.TeamRanks = []TeamManualRank{{TeamID: 1001, Rank: 3}, {TeamID: 1002, Rank: 1}, {TeamID: 1003, Rank: 2}} + appendScore("team-entry-override-only", mustScore(t, onlyOverride), teams, nil) + } + + // 形态 5 · 无并列的团体聚合（avg / all 两种分母口径），补上聚合通道的另一半覆盖面。 + { + teams := testTeams(1001, 1002) + for _, mode := range []AvgMode{AvgModeValid, AvgModeAll} { + ev := teamEvent(1) + ev.AvgMode = mode + entries, results := fixture([]participant{ + {entryID: 1, athleteID: 101, teamID: 1001, name: "一司1", value: 10}, + {entryID: 2, athleteID: 102, teamID: 1001, name: "一司2", value: 14}, + {entryID: 3, athleteID: 103, teamID: 1002, name: "二司1", value: 12, noValue: true}, + {entryID: 4, athleteID: 104, teamID: 1002, name: "二司2", value: 16}, + }) + es := mustScore(t, EventScoreInput{ + Event: ev, Category: testCategory(), + Channels: []ScoreChannel{teamAggregateChannel(11)}, + Profiles: map[int64]ScoringProfile{11: teamTop6()}, + Entries: entries, Results: results, + }) + appendScore("aggregate-"+string(mode), es, teams, nil) + } + } + + return strings.Join(lines, "\n") + "\n" +} + +// formatShares 把归属份额打印成 `单位ID:权重` 列表。 +// 刻意只取这两个字段：签名要盯的是「分给了谁」，不是结构体里后来又加了什么开关。 +func formatShares(shares []TeamShare) string { + if len(shares) == 0 { + return "-" + } + parts := make([]string, 0, len(shares)) + for _, s := range shares { + parts = append(parts, fmt.Sprintf("%d:%v", s.TeamID, s.Weight)) + } + return "[" + strings.Join(parts, ",") + "]" +} diff --git a/server/internal/domain/scoring.go b/server/internal/domain/scoring.go index 5ec8dff..5d187a7 100644 --- a/server/internal/domain/scoring.go +++ b/server/internal/domain/scoring.go @@ -39,8 +39,11 @@ type EventScore struct { // RankedResult 记录「某条报名项在某通道下拿到的名次与原始积分」。 // Points 尚未乘个人→单位系数，因此可直接用于奖牌判定与分项成绩表。 -// Shares 是该名次的归属单位；当前只有「整体归主单位」一种口径（联队未实现）， -// 保留份额结构是因为导出 / 实时快照等消费方按份额遍历。 +// +// Shares 是该名次的归属单位份额：报名项配了联队就是多条（如 A、B 各半），否则是主单位独占 +// 一条；积分按 Weight 拆、奖牌按 CountsMedal 整枚各记（见 TeamShare）。名次本身只有一条， +// 分数与奖牌的下发（拆成几份、记给谁）全部由 Shares 决定——流水侧在 ledgerFromRanked 拆成多行， +// 奖牌侧在 standings.teamMedals 逐份额记牌。 type RankedResult struct { EntryID int64 ResultID int64 @@ -295,6 +298,13 @@ func collectTeamManualCandidates(in EventScoreInput, ch ScoreChannel) []candidat if taken[or.teamID] { continue } + // 联队：该主单位在本组别报了联队（团体行 + 多单位份额）时，这条按单位录的名次就是 + // 联队的名次，份额取自那条报名——否则 A+B 拿到的名次会整份记在 A 头上，B 一分没有。 + // 没有联队报名（老数据、普通报名）时仍走下面的合成报名项，名次主体照样是单位。 + if joint, ok := jointTeamEntry(in, or.teamID); ok { + out = append(out, candidate{entry: joint, rankIn: or.rank}) + continue + } // 合成报名项：ID=0 表示「不对应任何一条报名项」，团体名次的主体是单位。 out = append(out, candidate{ entry: Entry{TeamID: or.teamID}, @@ -304,6 +314,48 @@ func collectTeamManualCandidates(in EventScoreInput, ch ScoreChannel) []candidat return out } +// jointTeamEntry 找「主单位 teamID 在本组别的联队报名」：团体行（athlete_id=0）+ 配了多个单位的份额。 +// +// 团体名次是按单位录的（channel_manual_ranks 的主体只有单位），联队份额只能挂在报名上， +// 所以录名次时得回头找这条报名。找不到（含只配了一个单位的普通报名）就返回 false， +// 调用方退回「主单位独占 100%」的合成报名项。 +// +// 为什么把「只有一个单位」也排除：那样与独占 100% 等价，却会把名次的身份从单位（subject_key +// `t:`）换成报名项（`e:`），channel_ranks 的既有行会跟着变——老数据必须逐字节不变。 +// +// 同一个组别同一主单位最多只有一条团体行（entries 的唯一索引兜着），真出现多条且份额不一致时 +// 退回独占：宁可少拆，也不能随便挑一条把分拆错。 +func jointTeamEntry(in EventScoreInput, teamID int64) (Entry, bool) { + var found Entry + ok := false + for _, e := range in.Entries { + if e.AthleteID != 0 || e.TeamID != teamID || !entryMatches(in, e) || !e.Status.rankable() { + continue + } + if len(e.TeamShares) < 2 { + continue + } + if ok && !sameShares(found.TeamShares, e.TeamShares) { + return Entry{}, false + } + found, ok = e, true + } + return found, ok +} + +// sameShares 判断两组份额是否一致（单位集合与各自权重、奖牌开关都比）。 +func sameShares(a, b []TeamShare) bool { + if len(a) != len(b) { + return false + } + for i := range a { + if a[i].TeamID != b[i].TeamID || !nearlyEqual(a[i].Weight, b[i].Weight) || a[i].CountsMedal() != b[i].CountsMedal() { + return false + } + } + return true +} + func scoreByResult(in EventScoreInput, ch ScoreChannel, profile ScoringProfile) ([]RankedResult, error) { cands, err := collectCandidates(in, ch) if err != nil { @@ -449,7 +501,7 @@ func rankedResult(in EventScoreInput, ch ScoreChannel, c candidate, rank int, po AthleteID: c.entry.AthleteID, AthleteName: c.entry.AthleteName, TeamID: c.entry.primaryTeamID(), - Shares: wholeShare(c.entry.primaryTeamID()), + Shares: ResolveShares(c.entry.TeamShares, c.entry.primaryTeamID()), Rank: rank, Points: points, Status: c.result.Status, @@ -573,6 +625,10 @@ func scoreByAggregate(in EventScoreInput, ch ScoreChannel, profile ScoringProfil Rank: g.startRank, Points: pts, } + // 聚合名次不对应任何一条报名项（EntryID=0，主体是单位或运动员），读取侧 + // （channel_ranks → buildRanked）没有报名项可以回查份额，只能按主体单位独占； + // 引擎必须同口径，否则「流水按份额拆了、奖牌榜还按单位独占」，两处对不上。 + // 因此联队 + 聚合通道不拆份额（已记进 devdocs/19 的未决项：聚合按主单位分桶）。 if ch.Scope == ScopeTeam { rr.TeamID = c.subject rr.Shares = wholeShare(c.subject) @@ -649,9 +705,9 @@ func ledgerFromRanked(in EventScoreInput, ch ScoreChannel, ranked []RankedResult if sourceID == 0 { sourceID = ch.ID } - for _, s := range rr.Shares { - pts := rr.Points * s.Weight - if pts == 0 { + split := splitSharePoints(rr.Points, rr.Shares) + for i, s := range rr.Shares { + if split[i] == 0 { continue } out = append(out, LedgerEntry{ @@ -664,7 +720,7 @@ func ledgerFromRanked(in EventScoreInput, ch ScoreChannel, ranked []RankedResult ChannelID: ch.ID, SourceType: SourceResult, SourceID: sourceID, - Points: pts, + Points: split[i], CountToTeam: ch.countToTeam(), }) } @@ -688,10 +744,60 @@ func subjectKeyOf(rr RankedResult) string { } } -// wholeShare 构造「主单位独占 100%」的归属份额。联队拆分未实现，这里只产出这一种口径。 +// ResolveShares 把「报名项配的份额」解析成最终归属份额：配了（联队）就用配置， +// 没配就是主单位独占 100%，与升级前逐字段一致。读侧（channel_ranks → RankedResult） +// 与引擎共用它，避免两边各写一份「没有份额时怎么办」。 +func ResolveShares(configured []TeamShare, teamID int64) []TeamShare { + if len(configured) > 0 { + return configured + } + return wholeShare(teamID) +} + +// wholeShare 构造「主单位独占 100%」的归属份额：没有联队配置时的唯一口径。 func wholeShare(teamID int64) []TeamShare { if teamID == 0 { return nil } return []TeamShare{{TeamID: teamID, Weight: 1}} } + +// splitSharePoints 把一条成绩的积分按份额拆给各成员单位，返回值与 shares 一一对应。 +// +// 权重是相对值（默认各 1 = 均分），先按权重之和归一：联队的两个单位各 1 份时总分照旧， +// 2:1 时也拆成两单位之和等于原来那一份分——**份额只改「分记在谁头上」，不改变总分**。 +// 没有配份额（老数据、普通报名）时是单条独占：total·1/1，结果与升级前逐位相同。 +// +// 最后一份取「总分减去前面各份」的余数，而不是再算一次乘法：2:1 这种除不尽的权重 +// 各份直接算会剩下 1e-15 级零头，榜单上就会印出 9.999999999999998 这种数。 +// +// 权重 <= 0 按 1 处理：库里有 CHECK(points_share > 0) 兜着，这里是引擎侧的兜底， +// 与其它地方的「零值按 1」口径（multiplier / effectiveWeight）一致。 +func splitSharePoints(total float64, shares []TeamShare) []float64 { + out := make([]float64, len(shares)) + if len(shares) == 0 { + return out + } + sum := 0.0 + for _, s := range shares { + sum += shareWeight(s) + } + acc := 0.0 + for i, s := range shares { + if i == len(shares)-1 { + out[i] = total - acc + break + } + out[i] = total * shareWeight(s) / sum + acc += out[i] + } + return out +} + +// shareWeight 取份额的积分权重，零值与负值按 1 处理（见 splitSharePoints）。 +func shareWeight(s TeamShare) float64 { + if s.Weight <= 0 { + return 1 + } + return s.Weight +} diff --git a/server/internal/domain/standings.go b/server/internal/domain/standings.go index 37b8e6a..799b8c5 100644 --- a/server/internal/domain/standings.go +++ b/server/internal/domain/standings.go @@ -328,8 +328,9 @@ func pickMedalChannels(ranked []RankedResult, excludeTeam bool) []RankedResult { return out } -// teamMedals 统计单位奖牌榜。按 Shares 逐份额记牌：当前只有「主单位独占 100%」一种口径， -// 将来若支持联队拆分，每个成员单位都会各记一枚。 +// teamMedals 统计单位奖牌榜。按 Shares 逐份额记牌：每个份额各记**一枚整牌**， +// 联队拿到的金牌因此两个成员单位各记 1 枚（不是各 0.5 枚，口径见 TeamShare.Medal）。 +// 份额里的 Medal 显式关掉时该单位不记这枚牌（积分份额 Weight 不参与奖牌计算）。 // // 两层开关（devdocs 17 §4.5）： // - 粗粒度总闸 StandingsInput.ExcludeTeamEventMedals：为 true 时团体项目的奖牌一律不进单位榜； @@ -347,6 +348,9 @@ func teamMedals(in StandingsInput) map[int64]medalTally { continue } for _, s := range rr.Shares { + if !s.CountsMedal() { + continue + } t := out[s.TeamID] switch medal { case 1: diff --git a/server/internal/domain/types.go b/server/internal/domain/types.go index 61a77d5..6d58aa0 100644 --- a/server/internal/domain/types.go +++ b/server/internal/domain/types.go @@ -288,14 +288,31 @@ type ScoringProfile struct { Rules []ScoringRule `json:"rules"` } -// TeamShare 是一条成绩的归属单位份额。联队拆分未实现，引擎只产出「主单位独占 100%」； -// 保留结构是因为导出 / 实时快照等消费方按份额遍历 RankedResult.Shares。 +// TeamShare 是一条成绩的归属单位份额：两个单位合并成联队参赛时，一条成绩由多个单位共享。 +// +// 积分与奖牌是两套口径，必须分开表达（devdocs/19 第三节的拍板结果）： +// - Weight 只决定**积分**怎么拆，是相对权重（按权重之和归一，1+1 就是各一半；缺省值 1）； +// 奇数分允许出现 0.5 这样的小数，榜单上就写 7.5； +// - Medal 只决定这枚**奖牌**是否整枚记给本单位。联队拿到的金牌两个单位各记 1 枚， +// 不按 Weight 拆成半枚——奖牌榜数的是整数枚，跟着权重拆会立刻错。 +// +// 普通报名（没有联队）与联队用同一个结构表达：一条 {主单位, Weight:1}，也就是「主单位独占 100%」， +// 与升级前 wholeShare 的产出逐字段一致。 type TeamShare struct { TeamID int64 `json:"teamId"` Weight float64 `json:"weight"` + // Medal 为 nil 表示按缺省处理（整枚记给本单位），与通道开关 CountToTeam 的 *bool 写法同源： + // 零值必须落在「老数据的行为」那一侧，否则既有调用方构造的 {TeamID, Weight} 会突然丢掉奖牌。 + Medal *bool `json:"medal,omitempty"` } -// Entry 报名项：某单位派某人/某队参加某小项。 +// CountsMedal 判断这枚奖牌是否整枚记给本单位；未配置时按整枚处理。 +func (s TeamShare) CountsMedal() bool { + return s.Medal == nil || *s.Medal +} + +// Entry 报名项：某单位派某人/某队参加某小项。TeamID 是**主单位**（联队时也保留它， +// 报名项的唯一键、榜单兜底、导入去重都还认这一个），联队的其余成员单位在 TeamShares 里。 type Entry struct { ID int64 `json:"id"` EventID int64 `json:"eventId"` @@ -308,6 +325,9 @@ type Entry struct { Seed string `json:"seed,omitempty"` Status EntryStatus `json:"status"` Remark string `json:"remark,omitempty"` + // TeamShares 是这条报名的归属份额配置：空 = 主单位独占 100%（老数据、普通报名）， + // 多条 = 联队。引擎只读不改，取分的唯一入口是 ResolveShares。 + TeamShares []TeamShare `json:"teamShares,omitempty"` } // Result 成绩；一条报名项一条成绩。 diff --git a/server/internal/export/athletes.go b/server/internal/export/athletes.go index ffb7cb2..64ee401 100644 --- a/server/internal/export/athletes.go +++ b/server/internal/export/athletes.go @@ -156,7 +156,11 @@ func LoadAthleteDetailWorkbook(db *sql.DB, opts Options) (AthleteDetailWorkbook, if err != nil { return AthleteDetailWorkbook{}, err } - rows, err := loadAthleteDetailRows(db) + joints, err := loadJointTeams(db) + if err != nil { + return AthleteDetailWorkbook{}, err + } + rows, err := loadAthleteDetailRows(db, joints) if err != nil { return AthleteDetailWorkbook{}, err } @@ -208,7 +212,7 @@ const athleteDetailRankExpr = `COALESCE(( ORDER BY CASE WHEN ch.scope = 'athlete' THEN 0 ELSE 1 END, ch.sort_order, ch.id, cr.id LIMIT 1), COALESCE(r.rank, 0))` -func loadAthleteDetailRows(db *sql.DB) ([]AthleteDetailRow, error) { +func loadAthleteDetailRows(db *sql.DB, joints map[int64]jointTeam) ([]AthleteDetailRow, error) { // 聚合流水的组别回推与单位明细同一条思路：某个运动员在本小项只参加了一个组别时，那个组别就是答案； // 多个组别时回推不出来，宁可留空也不猜（回推只对 entry_id / result_id 都为空的聚合流水生效）。 rows, err := db.Query(` @@ -217,7 +221,7 @@ func loadAthleteDetailRows(db *sql.DB) ([]AthleteDetailRow, error) { ` + athleteDetailRankExpr + `, COALESCE(r.result_text, ''), COALESCE(r.unit, ''), l.points, l.source_type, COALESCE(s.sort_order, 0), COALESCE(e.sort_order, 0), COALESCE(c.sort_order, ca.sort_order, 0), - COALESCE(l.event_id, 0), COALESCE(c.id, ca.id, 0), l.id + COALESCE(l.event_id, 0), COALESCE(c.id, ca.id, 0), l.id, COALESCE(l.entry_id, 0) FROM score_ledger l LEFT JOIN athletes a ON a.id = l.athlete_id LEFT JOIN events e ON e.id = l.event_id @@ -247,16 +251,23 @@ func loadAthleteDetailRows(db *sql.DB) ([]AthleteDetailRow, error) { source string resultText string unit string + entryID int64 ) if err := rows.Scan(&row.teamID, &row.AthleteName, &row.SportName, &row.EventName, &row.Category, &row.Rank, &resultText, &unit, &row.Points, &source, &row.sportSort, &row.eventSort, &row.catSort, - &row.eventID, &row.categoryID, &row.ledgerID); err != nil { + &row.eventID, &row.categoryID, &row.ledgerID, &entryID); err != nil { return nil, fmt.Errorf("export: 扫描个人得分明细: %w", err) } row.ResultText = displayResult(resultText, unit) row.Source = sourceLabel(source) + // 联队说明挂在「来源」列：这张表没有备注列，而「来源」写的正是这一分是从哪来的 + //（成绩 / 破纪录加分 / 人工调整）。联队的一条成绩会给每个成员单位各留一行流水， + // 不写这一句，读表的人只会看到同一个人在同一小项出现了两次、每次半份分。 + if joint, ok := joints[entryID]; ok { + row.Source += "（" + joint.shareNote() + "）" + } out = append(out, row) } if err := rows.Err(); err != nil { diff --git a/server/internal/export/entries.go b/server/internal/export/entries.go index 855f46a..a47208e 100644 --- a/server/internal/export/entries.go +++ b/server/internal/export/entries.go @@ -123,13 +123,18 @@ func LoadEntriesWorkbook(db *sql.DB, filter EntriesFilter, opts Options) (Entrie if err != nil { return EntriesWorkbook{}, err } + // 联队配置：导出名单里的单位编码回写成导入表的 A+B 写法，单位名写全成员，备注里写清份额。 + joints, err := loadJointTeams(db) + if err != nil { + return EntriesWorkbook{}, err + } query := ` SELECT COALESCE(ev.code, ''), COALESCE(ev.name, ''), COALESCE(c.name, ''), COALESCE(t.code, ''), COALESCE(t.name, ''), COALESCE(a.name, ''), COALESCE(en.member_names, ''), COALESCE(a.id_card, ''), COALESCE(en.bib, ''), en.heat, - COALESCE(a.gender, ''), a.age, en.status, COALESCE(en.remark, '') + COALESCE(a.gender, ''), a.age, en.status, COALESCE(en.remark, ''), en.id FROM entries en JOIN events ev ON ev.id = en.event_id JOIN teams t ON t.id = en.team_id @@ -145,7 +150,6 @@ func LoadEntriesWorkbook(db *sql.DB, filter EntriesFilter, opts Options) (Entrie }{ {"en.event_id", filter.EventID}, {"en.category_id", filter.CategoryID}, - {"en.team_id", filter.TeamID}, {"en.heat", filter.Heat}, } { if f.value != 0 { @@ -153,6 +157,24 @@ func LoadEntriesWorkbook(db *sql.DB, filter EntriesFilter, opts Options) (Entrie args = append(args, f.value) } } + // 单位筛选要连「联队里的成员单位」一起算：entries.team_id 只是主单位（加号左边那个）， + // 但成员单位同样在这条报名上拿分拿牌——按 B 导出时看不到它，B 就不知道自己派了谁上场。 + // 主单位那一半条件照旧留着：份额行缺失的报名（手工造的老数据）不能因此从筛选结果里掉出去。 + // 份额表不在（库还没跑到 0024）时不加这段：那种库里根本没有联队。 + if filter.TeamID != 0 { + teamCond := "en.team_id = ?" + args = append(args, filter.TeamID) + ready, err := entrySharesReady(db) + if err != nil { + return EntriesWorkbook{}, err + } + if ready { + teamCond += ` OR EXISTS (SELECT 1 FROM entry_team_shares s + WHERE s.entry_id = en.id AND s.team_id = ?)` + args = append(args, filter.TeamID) + } + conds = append(conds, "("+teamCond+")") + } if len(conds) > 0 { query += " WHERE " + strings.Join(conds, " AND ") } @@ -176,10 +198,11 @@ func LoadEntriesWorkbook(db *sql.DB, filter EntriesFilter, opts Options) (Entrie heat sql.NullInt64 age sql.NullInt64 athleteName string + entryID int64 ) if err := rows.Scan(&row.EventCode, &row.EventName, &row.Category, &row.TeamCode, &row.TeamName, &athleteName, &memberJSON, &row.IDCard, &row.Bib, &heat, - &row.Gender, &age, &row.Status, &row.Remark); err != nil { + &row.Gender, &age, &row.Status, &row.Remark, &entryID); err != nil { return EntriesWorkbook{}, fmt.Errorf("export: 扫描报名名单: %w", err) } row.Name = participantName(athleteName, memberJSON) @@ -192,6 +215,13 @@ func LoadEntriesWorkbook(db *sql.DB, filter EntriesFilter, opts Options) (Entrie row.Age = "" } row.Status = entryExportStatusLabel(row.Status) + // 联队：单位编码回写成 A+B（这份名单能直接拿去重导），单位名写全成员， + // 备注里写清这条分拆给了哪几个单位、各占多少。报名名单没有积分列，只写份额比例。 + if joint, ok := joints[entryID]; ok { + row.TeamCode = joint.Code() + row.TeamName = joint.Name() + row.Remark = appendNote(row.Remark, joint.shareRatioNote()) + } out = append(out, row) } if err := rows.Err(); err != nil { diff --git a/server/internal/export/joint_team.go b/server/internal/export/joint_team.go new file mode 100644 index 0000000..9b75e68 --- /dev/null +++ b/server/internal/export/joint_team.go @@ -0,0 +1,260 @@ +package export + +import ( + "database/sql" + "fmt" + "math" + "strconv" + "strings" +) + +// 本文件是「联队 + 份额分成」（devdocs/19）在导出侧的读法。 +// +// 一条报名配了多个成员单位时（现场有两个单位因人数不足合并参赛），导出件要做两件事： +// - 把联队的名字写出来，**成员单位名写全**，形如「第一分公司+第二分公司联队」； +// - 讲清这条分拆给了哪几个单位、各多少（份额比例 + 各单位实得积分）。 +// +// 两个口径必须分开（已拍板，见 domain.TeamShare）：积分按份额拆（允许 0.5 分）， +// 奖牌**每个成员单位各记一枚整枚**。后者会让「各单位的奖牌数加起来」大于实际颁发的奖牌数， +// 那是定稿口径、不是 bug，所以联队奖牌那一格自己要把「各单位各记 1 枚」写出来， +// 含联队的榜单类导出件另在副标题里写一句口径说明（见 jointMedalNote）。 + +// jointMedalNote 是含联队的榜单类导出件（总表 / 单位奖牌明细）副标题上的口径说明。 +// 奖牌数之和会大于实际颁发数是定稿口径（每个成员单位各记一整枚）， +// 不说这一句，拿导出件对账的人会以为多印了奖牌。 +const jointMedalNote = "注：本赛事含联队，奖牌按「每个成员单位各记 1 枚」统计，各单位奖牌数之和会大于实际颁发数" + +// jointMember 是联队里的一个成员单位：展示字段 + 份额 + 本单位实得积分。 +type jointMember struct { + TeamID int64 + Code string + // Name 是单位全称（缺全称时退简称）——现场看的就是这个，不能用编码凑合。 + Name string + Weight float64 + // CountsMedal 为 false 时这枚奖牌不记给本单位（缺省 true = 整枚各记）。 + CountsMedal bool + // Points 是本单位从这条成绩实得的积分（按流水统计：引擎已按份额拆好；没出分前是 0）。 + Points float64 + // Primary 标记这是报名的主单位（entries.team_id）：显示名与导出的编码都以它打头。 + Primary bool +} + +// jointTeam 是一条报名配的联队：成员单位按份额顺序（主单位排第一），至少两个。 +type jointTeam struct { + members []jointMember +} + +// Name 是联队的显示名：成员单位名写全，用 + 连起来再加「联队」——「第一分公司+第二分公司联队」。 +// 写法与导入表 team_code 的 `A+B` 同构，现场拿着一份表能一眼对上另一份。 +func (t jointTeam) Name() string { + names := make([]string, 0, len(t.members)) + for _, m := range t.members { + names = append(names, m.Name) + } + return strings.Join(names, "+") + "联队" +} + +// Code 是联队的单位编码：`T1+T2`，与导入表的 team_code 写法逐字一致， +// 于是导出的报名名单可以直接拿去重导（round-trip），不必手工改回单单位。 +func (t jointTeam) Code() string { + codes := make([]string, 0, len(t.members)) + for _, m := range t.members { + codes = append(codes, m.Code) + } + return strings.Join(codes, "+") +} + +// shareRatioNote 是只讲份额的说明：「联队分拆：第一分公司 50%、第二分公司 50%」。 +// 报名名单用它：那张表是报名侧的数据（号码布 / 批次 / 状态），没有积分列， +// 凭空冒出「5 分」反而让人以为这里也在算分。 +func (t jointTeam) shareRatioNote() string { + return "联队分拆：" + strings.Join(t.shareItems(false), "、") +} + +// shareNote 是份额说明：「联队分拆：第一分公司 7.5 分（50%）、第二分公司 7.5 分（50%）」。 +// +// 已经出分（成员里有非零积分）时把各单位的实得积分一并写出来——「各多少」问的就是它， +// 而导出件上的「积分」列只写了联队拿到的总分。还没出分时退化成只写份额比例。 +func (t jointTeam) shareNote() string { + return "联队分拆：" + strings.Join(t.shareItems(true), "、") +} + +// shareItems 拼各成员单位的份额描述，顺序与份额一致（主单位在前）。 +func (t jointTeam) shareItems(withPoints bool) []string { + sum := 0.0 + for _, m := range t.members { + sum += shareWeightOf(m.Weight) + } + if withPoints { + withPoints = false + for _, m := range t.members { + if m.Points != 0 { + withPoints = true + } + } + } + + items := make([]string, 0, len(t.members)) + for _, m := range t.members { + percent := formatPercent(shareWeightOf(m.Weight), sum) + if withPoints { + items = append(items, fmt.Sprintf("%s %s 分（%s）", m.Name, formatPoints(m.Points), percent)) + continue + } + items = append(items, m.Name+" "+percent) + } + return items +} + +// medalCell 把一枚联队奖牌写全：「金牌（联队 第一分公司+第二分公司，各单位各记 1 枚）」。 +// +// 括注必须留在奖牌这一格：奖牌明细里非联队行只有「金牌」两个字，读者把各单位的奖牌数加起来 +// 会比实际颁发的多（口径如此），这一句就是给那个数字的解释。有成员被显式关掉记牌时改写成 +// 「记给 甲、乙」——那种写法现在只有改份额的接口做得出来，但照样不能让人猜。 +func (t jointTeam) medalCell(medal string) string { + all := make([]string, 0, len(t.members)) + counting := make([]string, 0, len(t.members)) + for _, m := range t.members { + all = append(all, m.Name) + if m.CountsMedal { + counting = append(counting, m.Name) + } + } + if len(counting) == len(all) { + return fmt.Sprintf("%s（联队 %s，各单位各记 1 枚）", medal, strings.Join(all, "+")) + } + return fmt.Sprintf("%s（联队 %s，记给 %s）", medal, strings.Join(all, "+"), strings.Join(counting, "、")) +} + +// shareWeightOf 与引擎的 shareWeight 同一口径：0 与负数按 1 处理（份额是相对权重，不填即均分）。 +func shareWeightOf(weight float64) float64 { + if weight <= 0 { + return 1 + } + return weight +} + +// formatPercent 把份额写成占比（weight / Σweight）：1+1 → 50%、2:1 → 66.7% / 33.3%。 +// 保留一位小数并去掉多余的 0：现场看的是一眼能懂的比例，不是浮点数的原貌。 +func formatPercent(weight, sum float64) string { + if sum <= 0 { + sum = 1 + } + return strconv.FormatFloat(math.Round(weight/sum*1000)/10, 'f', -1, 64) + "%" +} + +// formatPoints 把积分写成文本：整数不带小数点，小数最多两位（引擎按份额拆出的 7.5 照实写）。 +func formatPoints(v float64) string { + return strconv.FormatFloat(math.Round(v*100)/100, 'f', -1, 64) +} + +// appendNote 把一句说明补进一格文本：原有内容（报名备注、修订痕迹）排在前面，用分号隔开。 +func appendNote(existing, note string) string { + if strings.TrimSpace(note) == "" { + return existing + } + if strings.TrimSpace(existing) == "" { + return note + } + return existing + "；" + note +} + +// entrySharesReady 判断份额表在不在。 +// +// 读路径要能读「还没跑到 0024 的库」：没有那张表就没有任何联队配置，显示照旧（主单位独占）。 +// 与 httpapi.entryTeamSharesReady 同一判据，只是这边没有 context 参数。 +func entrySharesReady(db *sql.DB) (bool, error) { + var n int + if err := db.QueryRow( + `SELECT COUNT(*) FROM sqlite_master WHERE type = 'table' AND name = 'entry_team_shares'`).Scan(&n); err != nil { + return false, fmt.Errorf("export: 查询报名份额表: %w", err) + } + return n != 0, nil +} + +// loadJointTeams 读全库的联队配置，按报名 id 归组；只有一条份额的报名不算联队，不进结果。 +// +// 「只有一条」这一档必须排掉：迁移会把每条老报名回填成一条「主单位独占 100%」， +// 导入也给普通报名写一条，把它们当成联队会让**所有**导出件的单位名列变成「XX联队」—— +// 那是老数据逐字节不变这条硬门槛要挡的事。 +// +// 各单位的实得积分一并读出来（分数按份额拆、末位吞余数，只在库里才准）， +// 用它拼「联队分拆：A 7.5 分、B 7.5 分」。表不在时返回空：没有份额表就没有联队配置。 +func loadJointTeams(db *sql.DB) (map[int64]jointTeam, error) { + ready, err := entrySharesReady(db) + if err != nil { + return nil, err + } + if !ready { + return nil, nil + } + + rows, err := db.Query(` + SELECT s.entry_id, s.team_id, COALESCE(t.code, ''), COALESCE(t.name, ''), COALESCE(t.short_name, ''), + s.points_share, s.medal_share, e.team_id, + COALESCE((SELECT SUM(l.points) FROM score_ledger l + WHERE l.entry_id = s.entry_id AND l.team_id = s.team_id AND l.voided = 0), 0) + FROM entry_team_shares s + JOIN teams t ON t.id = s.team_id + JOIN entries e ON e.id = s.entry_id + ORDER BY s.entry_id, s.sort_order, s.team_id`) + if err != nil { + return nil, fmt.Errorf("export: 读取联队份额: %w", err) + } + defer func() { _ = rows.Close() }() + + grouped := make(map[int64][]jointMember) + for rows.Next() { + var ( + entryID int64 + m jointMember + name string + short string + medal int + primary int64 + ) + if err := rows.Scan(&entryID, &m.TeamID, &m.Code, &name, &short, + &m.Weight, &medal, &primary, &m.Points); err != nil { + return nil, fmt.Errorf("export: 扫描联队份额: %w", err) + } + m.Name = displayName(name, short) + if m.Name == "" { + m.Name = m.Code + } + m.CountsMedal = medal != 0 + m.Primary = primary == m.TeamID + grouped[entryID] = append(grouped[entryID], m) + } + if err := rows.Err(); err != nil { + return nil, fmt.Errorf("export: 遍历联队份额: %w", err) + } + + out := make(map[int64]jointTeam, len(grouped)) + for entryID, members := range grouped { + if len(members) < 2 { + continue + } + out[entryID] = jointTeam{members: primaryFirst(members)} + } + return out, nil +} + +// primaryFirst 把主单位挪到成员列表最前面，其余保持份额表的顺序。 +// +// 显示名与导出的 `A+B` 都以主单位打头（口径：加号左边那个是主单位），而份额表里主单位 +// 不一定排第一——改份额的接口只要求主单位在成员里，没要求它排头。不归位的话， +// 一份导出件里的 `B+A` 重导回去会把主单位换成 B，报名身份（唯一键）跟着变。 +func primaryFirst(members []jointMember) []jointMember { + out := make([]jointMember, 0, len(members)) + for _, m := range members { + if m.Primary { + out = append(out, m) + } + } + for _, m := range members { + if !m.Primary { + out = append(out, m) + } + } + return out +} diff --git a/server/internal/export/joint_team_export_test.go b/server/internal/export/joint_team_export_test.go new file mode 100644 index 0000000..563179e --- /dev/null +++ b/server/internal/export/joint_team_export_test.go @@ -0,0 +1,408 @@ +package export + +import ( + "database/sql" + "path/filepath" + "strings" + "testing" +) + +// 联队的导出侧（devdocs/19）：一条成绩按份额拆给多个单位时，导出件必须 +// 1. 把联队的名字写出来，成员单位名写全（形如「第一分公司+第二分公司联队」）； +// 2. 看得出这条分拆给了哪几个单位、各多少（份额 + 各单位实得积分）。 +// 本文件逐份导出件钉住这两条；另一条硬门槛（没有联队的老数据一字不变）由 +// TestSingleUnitExportsHaveNoJointTeamText 与既有的各份导出用例共同守住。 + +// jointTeamMemberNames 是联队里的两个成员单位（与 seedEvent 的单位一致）。 +const ( + jointNameT1 = "第一分公司" + jointNameT2 = "第二分公司" + // jointTeamDisplay 是联队的显示名：成员单位名写全，中间用 + 连、末尾标「联队」。 + jointTeamDisplay = jointNameT1 + "+" + jointNameT2 + "联队" + // jointShareNote 是均分两份时的份额说明（两条流水的实得积分都是 5 分）。 + jointShareNote = "联队分拆：第一分公司 5 分（50%）、第二分公司 5 分（50%）" + // jointShareOnlyNote 是没有流水时（报名阶段）的份额说明：只讲份额，不讲分。 + jointShareOnlyNote = "联队分拆：第一分公司 50%、第二分公司 50%" +) + +// seedJointTeamEntry 把 seedEvent 的第 1 名改成联队（T1+T2）拿的：份额均分、奖牌整枚各记， +// 流水也按份额拆成两行。现场这两样都是引擎算出来的，导出测试直接造库（与 seedChannelRanks 同一套做法）。 +func seedJointTeamEntry(t *testing.T, db *sql.DB) { + t.Helper() + + stmts := []string{ + `INSERT INTO entry_team_shares(entry_id, team_id, points_share, medal_share, sort_order) + VALUES (1, 1, 1, 1, 0)`, + `INSERT INTO entry_team_shares(entry_id, team_id, points_share, medal_share, sort_order) + VALUES (1, 2, 1, 1, 1)`, + // 引擎把这一条成绩的 10 分拆成两行流水（份额之和归一，两名单位各一半）。 + `UPDATE score_ledger SET points = 5 WHERE entry_id = 1`, + `INSERT INTO score_ledger(team_id, athlete_id, event_id, entry_id, result_id, source_type, source_id, points) + VALUES (2, 1, 1, 1, 1, 'result', 1, 5)`, + } + for _, s := range stmts { + if _, err := db.Exec(s); err != nil { + t.Fatalf("造联队数据 %q: %v", s, err) + } + } +} + +// seedSingleShareRow 给某条报名只配一条份额：迁移与导入都会这么写（普通报名是「主单位独占 100%」）， +// 它**不是**联队，导出件必须与升级前一模一样。 +func seedSingleShareRow(t *testing.T, db *sql.DB, entryID, teamID int64) { + t.Helper() + if _, err := db.Exec( + `INSERT INTO entry_team_shares(entry_id, team_id, points_share, medal_share, sort_order) + VALUES (?, ?, 1, 1, 0)`, entryID, teamID); err != nil { + t.Fatalf("造独占份额: %v", err) + } +} + +// 分项成绩表：单位列写全联队成员，备注列写清分给了谁、各多少。 +func TestJointTeamEventSheetShowsMembersAndShares(t *testing.T) { + db := openEventDB(t) + seedEvent(t, db) + seedJointTeamEntry(t, db) + seedChannelRanks(t, db) + + dst := filepath.Join(t.TempDir(), "分项.xlsx") + if err := ExportEventXLSX(db, 1, dst, Options{}); err != nil { + t.Fatalf("导出分项成绩表: %v", err) + } + rows := readSheet(t, dst, "田径·100米跑·男子") + + // 第 1 名那条是联队（列序：名次/号码/单位/运动员-队/成绩/积分/状态/备注）。 + if got := cell(rows, 4, 2); got != jointTeamDisplay { + t.Errorf("联队行的单位 = %q，期望 %q", got, jointTeamDisplay) + } + if got := cell(rows, 4, 5); got != "10" { + t.Errorf("联队行的积分 = %q，期望 10（联队拿到的总分）", got) + } + if got := cell(rows, 4, 7); !strings.Contains(got, jointShareNote) { + t.Errorf("联队行的备注 = %q，期望含 %q", got, jointShareNote) + } + // 第 2 名那条不是联队：单位与备注都不该多出任何东西。 + if got := cell(rows, 5, 2); got != jointNameT2 { + t.Errorf("非联队行的单位 = %q，期望 %q", got, jointNameT2) + } + if got := cell(rows, 5, 7); got != "" { + t.Errorf("非联队行的备注应为空，得到 %q", got) + } +} + +// 报名名单：单位编码回写成导入时的 A+B 写法（导出件可直接拿去重导），单位名写全联队成员。 +func TestJointTeamEntriesSheetWritesJointTeamCode(t *testing.T) { + db := openEventDB(t) + seedEvent(t, db) + seedJointTeamEntry(t, db) + + dst := filepath.Join(t.TempDir(), "报名.xlsx") + if err := ExportEntriesXLSX(db, dst, EntriesFilter{}, Options{}); err != nil { + t.Fatalf("导出报名名单: %v", err) + } + rows := readSheet(t, dst, "报名名单") + + // 列序：小项编码/小项名/组别/单位编码/单位名/姓名/证件号/号码布/批次/性别/年龄/状态/备注。 + if got := cell(rows, 4, 3); got != "T1+T2" { + t.Errorf("联队行的单位编码 = %q，期望 T1+T2（与导入表的写法一致）", got) + } + if got := cell(rows, 4, 4); got != jointTeamDisplay { + t.Errorf("联队行的单位名 = %q，期望 %q", got, jointTeamDisplay) + } + if got := cell(rows, 4, 12); !strings.Contains(got, jointShareOnlyNote) { + t.Errorf("联队行的备注 = %q，期望含 %q", got, jointShareOnlyNote) + } + if got := cell(rows, 5, 3); got != "T2" { + t.Errorf("非联队行的单位编码 = %q，期望 T2", got) + } +} + +// 单位积分明细：某单位拿到的这一条来自联队，备注要说清分给了哪几个单位、各多少。 +func TestJointTeamTeamDetailNotesShare(t *testing.T) { + db := openEventDB(t) + seedEvent(t, db) + seedJointTeamEntry(t, db) + + dst := filepath.Join(t.TempDir(), "单位明细.xlsx") + if err := ExportTeamDetailXLSX(db, 1, dst, Options{}); err != nil { + t.Fatalf("导出单位积分明细: %v", err) + } + rows := readSheet(t, dst, "第一分公司积分明细") + if got := cell(rows, 4, 8); got != "5" { + t.Errorf("联队份额行的积分 = %q，期望 5（本单位那一半）", got) + } + if got := cell(rows, 4, 9); !strings.Contains(got, jointShareNote) { + t.Errorf("联队份额行的备注 = %q，期望含 %q", got, jointShareNote) + } + + // 总明细（第一张总表 + 每单位一张分表）与单表同口径，逐格写的是同一句话。 + allDst := filepath.Join(t.TempDir(), "单位总明细.xlsx") + if err := ExportAllTeamDetailsXLSX(db, allDst, Options{}); err != nil { + t.Fatalf("导出所有单位积分明细: %v", err) + } + master := readSheet(t, allDst, "积分总明细") + found := false + for r := range master { + if cell(master, r, 0) == jointNameT1 && strings.Contains(cell(master, r, 10), jointShareNote) { + found = true + } + } + if !found { + t.Errorf("总明细里第一分公司的联队份额行没有份额说明：%v", master) + } +} + +// 个人积分总明细：没有备注列，联队说明写在「来源」列（该行得分的来处）。 +func TestJointTeamAthleteDetailNotesShare(t *testing.T) { + db := openEventDB(t) + seedEvent(t, db) + seedJointTeamEntry(t, db) + + dst := filepath.Join(t.TempDir(), "个人.xlsx") + if err := ExportAthleteDetailXLSX(db, dst, Options{}); err != nil { + t.Fatalf("导出个人得分明细: %v", err) + } + rows := readSheet(t, dst, "第一分公司个人得分明细") + // 列序：运动员/大项/小项/组别/名次/成绩/得分/来源。 + if got := cell(rows, 4, 6); got != "5" { + t.Errorf("联队份额行的得分 = %q，期望 5", got) + } + if got := cell(rows, 4, 7); !strings.Contains(got, jointShareNote) { + t.Errorf("联队份额行的来源 = %q，期望含 %q", got, jointShareNote) + } +} + +// 单位奖牌明细：联队金牌两个单位各记一枚，导出件要在那一行就说清「各单位各记 1 枚」， +// 否则把各单位的奖牌数加起来会比实际颁发的多（口径 3，不是 bug）。 +func TestJointTeamMedalDetailShowsEveryUnit(t *testing.T) { + db := openEventDB(t) + seedEvent(t, db) + seedJointTeamEntry(t, db) + seedChannelRanks(t, db) + + dst := filepath.Join(t.TempDir(), "奖牌.xlsx") + if err := ExportMedalDetailXLSX(db, dst, Options{}); err != nil { + t.Fatalf("导出单位奖牌明细: %v", err) + } + want := "金牌（联队 " + jointNameT1 + "+" + jointNameT2 + "，各单位各记 1 枚）" + + master := readSheet(t, dst, "单位奖牌明细") + gold := make([]string, 0, 2) + for r := range master { + if strings.HasPrefix(cell(master, r, 5), "金牌") { + gold = append(gold, cell(master, r, 5)) + } + } + if len(gold) != 2 { + t.Fatalf("联队金牌应在总表出两行（两个单位各一行），得到 %d 行：%v", len(gold), master) + } + for i, got := range gold { + if got != want { + t.Errorf("总表第 %d 行联队奖牌 = %q，期望 %q", i+1, got, want) + } + } + // 非联队的银牌那一行一字不动。 + plain := false + for r := range master { + if cell(master, r, 5) == "银牌" { + plain = true + } + } + if !plain { + t.Errorf("普通奖牌行应保持「银牌」原文：%v", master) + } + + // 分表与总表同口径：第一分公司那一张表里的金牌也是同一句话。 + team := readSheet(t, dst, "第一分公司奖牌明细") + if got := cell(team, 4, 4); got != want { + t.Errorf("分表联队奖牌 = %q，期望 %q", got, want) + } + // 分表小计照旧数「本单位拿到几枚」——联队口径下它每个单位各算 1 枚。 + if got := cell(team, 5, 4); got != "金 1 / 银 0 / 铜 0" { + t.Errorf("分表小计 = %q，期望 金 1 / 银 0 / 铜 0", got) + } +} + +// 含联队的榜单类导出件要有一句口径说明：奖牌按「每个成员单位各记 1 枚」统计， +// 各单位奖牌数之和会大于实际颁发数。合计行本身不动（口径 3）。 +func TestJointTeamStandingsNotesMedalRule(t *testing.T) { + db := openEventDB(t) + seedEvent(t, db) + seedJointTeamEntry(t, db) + seedChannelRanks(t, db) + + dst := filepath.Join(t.TempDir(), "总表.xlsx") + if err := ExportStandingsXLSX(db, dst, Options{}); err != nil { + t.Fatalf("导出总表: %v", err) + } + medal := readSheet(t, dst, "单位奖牌榜") + if got := cell(medal, 1, 0); !strings.Contains(got, "每个成员单位各记 1 枚") { + t.Errorf("单位奖牌榜的副标题 = %q，期望含奖牌口径说明", got) + } + // 口径没变：两个单位各记 1 枚金牌（总表两行都是 1，不是各 0.5）。 + count := 0 + for r := range medal { + if cell(medal, r, 1) == "T1" || cell(medal, r, 1) == "T2" { + if cell(medal, r, 3) != "1" { + t.Errorf("%s 金牌 = %q，期望 1（整枚各记）", cell(medal, r, 1), cell(medal, r, 3)) + } + count++ + } + } + if count != 2 { + t.Errorf("单位奖牌榜应有 2 个单位行，得到 %d", count) + } +} + +// 球类现场的形态：名次是按单位手工录的（团体通道、没有对应成绩行），channel_ranks 的 +// entry_id 指到那条联队报名（引擎的 jointTeamEntry 干的活）。奖牌明细同样要认得出联队—— +// 只按成绩 id 找来源的做法在这里取不到任何展示字段（result_id 为空）。 +func TestJointTeamMedalDetailFromManualTeamRank(t *testing.T) { + db := openEventDB(t) + seedEvent(t, db) + seedJointTeamEntry(t, db) + + var profileID int64 + if err := db.QueryRow(`SELECT id FROM scoring_profiles WHERE code = 'team_top6'`).Scan(&profileID); err != nil { + t.Fatalf("读团体积分模板: %v", err) + } + if _, err := db.Exec(`INSERT INTO event_score_channels(event_id, scope, basis, profile_id, sort_order) + VALUES (1, 'team', 'manual', ?, 1)`, profileID); err != nil { + t.Fatalf("造团体通道: %v", err) + } + var channelID int64 + if err := db.QueryRow(`SELECT id FROM event_score_channels + WHERE event_id = 1 AND scope = 'team' AND basis = 'manual'`).Scan(&channelID); err != nil { + t.Fatalf("读团体通道: %v", err) + } + if _, err := db.Exec(`INSERT INTO channel_ranks(event_id, category_id, channel_id, basis, scope, subject_key, + entry_id, result_id, team_id, rank, points, status) + VALUES (1, 1, ?, 'manual', 'team', 'e:1', 1, NULL, 1, 1, 0, 'ok')`, channelID); err != nil { + t.Fatalf("造团体手工名次: %v", err) + } + + dst := filepath.Join(t.TempDir(), "奖牌.xlsx") + if err := ExportMedalDetailXLSX(db, dst, Options{}); err != nil { + t.Fatalf("导出单位奖牌明细: %v", err) + } + want := "金牌（联队 " + jointNameT1 + "+" + jointNameT2 + "，各单位各记 1 枚）" + master := readSheet(t, dst, "单位奖牌明细") + gold := 0 + for r := range master { + if strings.HasPrefix(cell(master, r, 5), "金牌") { + gold++ + if got := cell(master, r, 5); got != want { + t.Errorf("总表联队奖牌 = %q，期望 %q", got, want) + } + } + } + if gold != 2 { + t.Fatalf("联队金牌应给两个单位各出一行，得到 %d 行：%v", gold, master) + } +} + +// 按成员单位筛报名名单：联队那条报名挂在主单位（T1）名下，但成员单位 T2 的名单里也得有它， +// 否则 T2 导出自己的名单时，会以为自己没派人上场。 +func TestJointTeamEntriesSheetFilteredByMemberUnit(t *testing.T) { + db := openEventDB(t) + seedEvent(t, db) + seedJointTeamEntry(t, db) + + dst := filepath.Join(t.TempDir(), "报名.xlsx") + if err := ExportEntriesXLSX(db, dst, EntriesFilter{TeamID: 2}, Options{}); err != nil { + t.Fatalf("按成员单位导出报名名单: %v", err) + } + rows := readSheet(t, dst, "报名名单") + found := false + for r := range rows { + if cell(rows, r, 3) == "T1+T2" { + found = true + } + } + if !found { + t.Errorf("按成员单位 T2 导出时应能看到联队那条报名：%v", rows) + } + // 主单位筛选照旧（老行为一字不改）。 + primaryDst := filepath.Join(t.TempDir(), "报名主单位.xlsx") + if err := ExportEntriesXLSX(db, primaryDst, EntriesFilter{TeamID: 1}, Options{}); err != nil { + t.Fatalf("按主单位导出报名名单: %v", err) + } + primary := readSheet(t, primaryDst, "报名名单") + if len(primary) != 5 { // 4 行版式 + 主单位自己的那一条 + t.Fatalf("按主单位筛应只出 T1 的那一条，得到 %d 行：%v", len(primary), primary) + } +} + +// 份额表里主单位不排第一时（改份额的接口允许这样写），导出件的名字与 A+B 仍以主单位打头： +// 否则 `B+A` 重导回去会把报名的主单位换成 B。 +func TestJointTeamDisplayPutsPrimaryFirst(t *testing.T) { + db := openEventDB(t) + seedEvent(t, db) + // 故意把成员单位排在主单位前面（sort_order 0 = T2，1 = T1）。 + for _, s := range []string{ + `INSERT INTO entry_team_shares(entry_id, team_id, points_share, medal_share, sort_order) VALUES (1, 2, 1, 1, 0)`, + `INSERT INTO entry_team_shares(entry_id, team_id, points_share, medal_share, sort_order) VALUES (1, 1, 1, 1, 1)`, + } { + if _, err := db.Exec(s); err != nil { + t.Fatalf("造份额 %q: %v", s, err) + } + } + + dst := filepath.Join(t.TempDir(), "报名.xlsx") + if err := ExportEntriesXLSX(db, dst, EntriesFilter{}, Options{}); err != nil { + t.Fatalf("导出报名名单: %v", err) + } + rows := readSheet(t, dst, "报名名单") + if got := cell(rows, 4, 3); got != "T1+T2" { + t.Errorf("单位编码 = %q，期望 T1+T2（主单位永远排最前）", got) + } + if got := cell(rows, 4, 4); got != jointTeamDisplay { + t.Errorf("单位名 = %q，期望 %q", got, jointTeamDisplay) + } +} + +// 老数据门槛：只有一条独占份额（普通报名 / 迁移回填）时，各份导出件一个字都不能多。 +func TestSingleUnitExportsHaveNoJointTeamText(t *testing.T) { + db := openEventDB(t) + seedEvent(t, db) + // 迁移与导入都会给每条报名写一条独占份额：它不是联队。 + seedSingleShareRow(t, db, 1, 1) + seedSingleShareRow(t, db, 2, 2) + seedChannelRanks(t, db) + + dir := t.TempDir() + eventDst := filepath.Join(dir, "分项.xlsx") + if err := ExportEventXLSX(db, 1, eventDst, Options{}); err != nil { + t.Fatalf("导出分项成绩表: %v", err) + } + rows := readSheet(t, eventDst, "田径·100米跑·男子") + if got := cell(rows, 4, 2); got != jointNameT1 { + t.Errorf("普通报名的单位 = %q，期望 %q（联队显示名不能套到独占份额上）", got, jointNameT1) + } + if got := cell(rows, 4, 7); got != "" { + t.Errorf("普通报名的备注应为空，得到 %q", got) + } + + entriesDst := filepath.Join(dir, "报名.xlsx") + if err := ExportEntriesXLSX(db, entriesDst, EntriesFilter{}, Options{}); err != nil { + t.Fatalf("导出报名名单: %v", err) + } + erows := readSheet(t, entriesDst, "报名名单") + if got := cell(erows, 4, 3); got != "T1" { + t.Errorf("普通报名的单位编码 = %q，期望 T1", got) + } + if got := cell(erows, 4, 4); got != jointNameT1 { + t.Errorf("普通报名的单位名 = %q，期望 %q", got, jointNameT1) + } + + standingsDst := filepath.Join(dir, "总表.xlsx") + if err := ExportStandingsXLSX(db, standingsDst, Options{}); err != nil { + t.Fatalf("导出总表: %v", err) + } + medal := readSheet(t, standingsDst, "单位奖牌榜") + for r := range medal { + if strings.Contains(cell(medal, r, 0), "联队") || strings.Contains(cell(medal, r, 1), "联队") { + t.Errorf("无联队时副标题不该出现联队口径说明：%v", medal[r]) + } + } +} diff --git a/server/internal/export/joint_team_test.go b/server/internal/export/joint_team_test.go new file mode 100644 index 0000000..dc5821d --- /dev/null +++ b/server/internal/export/joint_team_test.go @@ -0,0 +1,37 @@ +package export + +import ( + "testing" +) + +// 导出是联队奖牌的第三条读路径（另有 REST 与 WS 快照）：它同样读 channel_ranks， +// 再按报名项的份额补归属。少了这一步，导出的单位奖牌榜会把联队的金牌只记给主单位。 +func TestJointTeamMedalExportCountsEveryMember(t *testing.T) { + db := openEventDB(t) + seedEvent(t, db) // T1 第 1 名、T2 第 2 名 + // 把 T1 的第 1 名改成联队（T1 + T2）拿的：份额均分、奖牌整枚各记。 + for _, s := range []string{ + `INSERT INTO entry_team_shares(entry_id, team_id, points_share, medal_share, sort_order) VALUES (1, 1, 1, 1, 0)`, + `INSERT INTO entry_team_shares(entry_id, team_id, points_share, medal_share, sort_order) VALUES (1, 2, 1, 1, 1)`, + } { + if _, err := db.Exec(s); err != nil { + t.Fatalf("造联队份额 %q: %v", s, err) + } + } + seedChannelRanks(t, db) + + book, err := LoadStandingsWorkbook(db, Options{}) + if err != nil { + t.Fatalf("读榜单工作簿: %v", err) + } + gold := make(map[int64]int, len(book.Medal)) + for _, row := range book.Medal { + gold[row.TeamID] = row.Gold + } + if gold[1] != 1 { + t.Fatalf("主单位 T1 应记 1 枚金牌，得到 %d（完整：%+v）", gold[1], book.Medal) + } + if gold[2] != 1 { + t.Fatalf("成员单位 T2 也应记 1 枚金牌（不是 0.5 枚、也不是 0 枚），得到 %d（完整：%+v）", gold[2], book.Medal) + } +} diff --git a/server/internal/export/load.go b/server/internal/export/load.go index c53aacf..c88fa71 100644 --- a/server/internal/export/load.go +++ b/server/internal/export/load.go @@ -23,6 +23,10 @@ type Meta struct { // 所以这一行事实上不会出现在导出件里；空值时 metaSubtitle 直接跳过它（代码卫生项 C28）。 // 留字段是因为打印件抬头本来就该有「谁导的」——要接线时由 handler 从会话里取用户名填进来即可。 GeneratedBy string + // Note 是附在副标题后面的口径说明，由 Load* 按数据内容补（当前只有「本赛事含联队」时才会写： + // 奖牌每个成员单位各记 1 枚，各单位奖牌数之和会大于实际颁发数）。 + // 留空时副标题与改动前逐字一致——无联队的老导出件不能因为加了这个字段而变形。 + Note string } func (m Meta) normalized() Meta { @@ -132,6 +136,15 @@ func LoadStandingsWorkbook(db *sql.DB, opts Options) (StandingsWorkbook, error) medal := domain.BuildMedalStandings(in) athlete := domain.BuildAthleteStandings(in) fillTeamDisplay(team, medal, athlete, allTeams) + // 含联队时在副标题上写清奖牌口径：每个成员单位各记 1 枚，各单位奖牌数之和会大于实际颁发数。 + // 合计行本身不改（那是定稿口径），只把那个数字解释清楚。 + joints, err := loadJointTeams(db) + if err != nil { + return StandingsWorkbook{}, err + } + if len(joints) > 0 { + meta.Note = jointMedalNote + } return StandingsWorkbook{Meta: meta, Team: team, Medal: medal, Athlete: athlete}, nil } @@ -330,11 +343,6 @@ func loadRanked(db *sql.DB) ([]domain.RankedResult, error) { v := value.Float64 rr.ResultValue = &v } - // 归属份额沿用「主单位独占 100%」：team_id 为空（聚合 / 团体手工名次理论上不会）时不造份额， - // 免得给 0 号单位凭空记牌，与 domain 的 wholeShare 一致。 - if rr.TeamID != 0 { - rr.Shares = []domain.TeamShare{{TeamID: rr.TeamID, Weight: 1}} - } rr.AwardMedals = awardMedals != 0 rr.CountToMedals = countToMedals != 0 rr.CountToTeamMedals = countToTeamMed != 0 @@ -343,9 +351,60 @@ func loadRanked(db *sql.DB) ([]domain.RankedResult, error) { if err := rows.Err(); err != nil { return nil, fmt.Errorf("export: 遍历名次: %w", err) } + // 归属份额按报名项配置补（联队：一条成绩归多个单位）：与 REST 的 buildRanked、 + // 快照的 loadRanked 同口径。没有报名项的名次与没配份额的老数据都退回「主单位独占 100%」， + // team_id 为空时不造份额，免得给 0 号单位凭空记牌。 + shares, err := loadEntryTeamShares(db) + if err != nil { + return nil, err + } + for i := range out { + out[i].Shares = domain.ResolveShares(shares[out[i].EntryID], out[i].TeamID) + } return out, nil } +// loadEntryTeamShares 读全部报名的份额（联队配置），按 entry_id 归组。 +// 与 HTTP 侧的 loadEntryTeamSharesQ 同一份表、同一套排序：展示与流水顺序要稳定。 +// +// 表不在（库还没跑到 0024）时返回空：没有份额表就没有联队配置，主单位独占 100% 正是老库 +// 本来就该得到的结果，不是容错降级（见 httpapi.entryTeamSharesReady）。 +func loadEntryTeamShares(db *sql.DB) (map[int64][]domain.TeamShare, error) { + var n int + if err := db.QueryRow( + `SELECT COUNT(*) FROM sqlite_master WHERE type = 'table' AND name = 'entry_team_shares'`).Scan(&n); err != nil { + return nil, fmt.Errorf("export: 查询报名份额表: %w", err) + } + if n == 0 { + return nil, nil + } + rows, err := db.Query(`SELECT entry_id, team_id, points_share, medal_share + FROM entry_team_shares + ORDER BY entry_id, sort_order, team_id`) + if err != nil { + return nil, fmt.Errorf("export: 读取报名份额: %w", err) + } + defer func() { _ = rows.Close() }() + + out := make(map[int64][]domain.TeamShare) + for rows.Next() { + var ( + entryID int64 + s domain.TeamShare + medal int + ) + if err := rows.Scan(&entryID, &s.TeamID, &s.Weight, &medal); err != nil { + return nil, fmt.Errorf("export: 扫描报名份额: %w", err) + } + if medal == 0 { + excluded := false + s.Medal = &excluded + } + out[entryID] = append(out[entryID], s) + } + return out, rows.Err() +} + // eventInfo 是导出分项成绩表需要的项目信息。 type eventInfo struct { id int64 @@ -372,13 +431,18 @@ func LoadEventWorkbook(db *sql.DB, eventID int64, opts Options) (EventsWorkbook, } sheets := make([]EventSheet, 0, len(events)) + // 联队配置读一次给全部工作表复用：一个小项组别一张表，逐张去查会白跑几十遍。 + joints, err := loadJointTeams(db) + if err != nil { + return EventsWorkbook{}, err + } for _, ev := range events { cats, err := loadCategories(db, ev.id) if err != nil { return EventsWorkbook{}, err } if len(cats) == 0 { - rows, err := loadEventRows(db, ev.id, 0, opts.IncludeDrafts) + rows, err := loadEventRows(db, ev.id, 0, opts.IncludeDrafts, joints) if err != nil { return EventsWorkbook{}, err } @@ -386,7 +450,7 @@ func LoadEventWorkbook(db *sql.DB, eventID int64, opts Options) (EventsWorkbook, continue } for _, cat := range cats { - rows, err := loadEventRows(db, ev.id, cat.id, opts.IncludeDrafts) + rows, err := loadEventRows(db, ev.id, cat.id, opts.IncludeDrafts, joints) if err != nil { return EventsWorkbook{}, err } @@ -465,7 +529,7 @@ func loadCategories(db *sql.DB, eventID int64) ([]categoryInfo, error) { // 未录入成绩的报名项也会列出，状态显示「未录入」——现场核对名单时用得上。 // includeDrafts 为 false 时草稿成绩的值不对外，但那一行仍占位（Unpublished）； // 连成绩行都没有的报名项同样占位（NoResult）；成绩已发布但整组还没结算的占位（Unsettled）。 -func loadEventRows(db *sql.DB, eventID, categoryID int64, includeDrafts bool) ([]EventResultRow, error) { +func loadEventRows(db *sql.DB, eventID, categoryID int64, includeDrafts bool, joints map[int64]jointTeam) ([]EventResultRow, error) { // 名次列取「主通道」名次（devdocs 17 §11.3）：双通道项目（个人通道 + 团体通道）一行只能出一个名次， // 口径 = scope=athlete 优先，其次通道 sort_order 小者。 // channel_ranks 是发布 / 重算才重建的派生数据，还没有它时（老库刚升级、只排名不计分项目的合成通道 @@ -484,7 +548,7 @@ func loadEventRows(db *sql.DB, eventID, categoryID int64, includeDrafts bool) ([ WHERE l.entry_id = en.id AND l.voided = 0), 0), r.status, r.state, en.status, COALESCE(en.remark, ''), COALESCE(r.note, ''), r.result_value IS NOT NULL, - COALESCE(gs.required, 0), COALESCE(gs.published, 0) + COALESCE(gs.required, 0), COALESCE(gs.published, 0), en.id FROM entries en JOIN teams t ON t.id = en.team_id LEFT JOIN athletes a ON a.id = en.athlete_id @@ -535,16 +599,23 @@ func loadEventRows(db *sql.DB, eventID, categoryID int64, includeDrafts bool) ([ resultNote string hasValue int required, published int + entryID int64 ) if err := rows.Scan(&rank, &isTie, &row.Bib, &memberJSON, &row.TeamName, &athleteName, &row.ResultText, &row.Unit, &row.Points, &resultStat, &resultState, &entryStat, - &entryRemark, &resultNote, &hasValue, &required, &published); err != nil { + &entryRemark, &resultNote, &hasValue, &required, &published, &entryID); err != nil { return nil, fmt.Errorf("export: 扫描成绩: %w", err) } row.Participant = participantName(athleteName, memberJSON) row.Rank = rankLabel(rank, isTie != 0) row.Status = statusLabel(resultStat, resultState, entryStat) row.Remark = joinRemark(entryRemark, resultNote) + // 联队：单位列写全成员单位（「第一分公司+第二分公司联队」），备注里写清分给了谁、各多少。 + // 普通报名（含迁移回填的单条独占份额）不走这里，单位名与备注与改动前逐字一致。 + if joint, ok := joints[entryID]; ok { + row.TeamName = joint.Name() + row.Remark = appendNote(row.Remark, joint.shareNote()) + } // results.state 是 NOT NULL，所以 state 为空只可能是 LEFT JOIN 没命中所致：这条报名还没录成绩。 // 它与「有草稿没发布」要分开：前者三格都没值，后者只是成绩值不对外。 row.NoResult = !resultState.Valid @@ -585,7 +656,11 @@ func LoadTeamDetailWorkbook(db *sql.DB, teamID int64, opts Options) (TeamDetailW if err != nil { return TeamDetailWorkbook{}, err } - rows, err := loadTeamDetailRows(db, teamID) + joints, err := loadJointTeams(db) + if err != nil { + return TeamDetailWorkbook{}, err + } + rows, err := loadTeamDetailRows(db, teamID, joints) if err != nil { return TeamDetailWorkbook{}, err } @@ -638,7 +713,7 @@ const teamDetailRankExpr = `COALESCE(( ORDER BY CASE WHEN ch.scope = 'athlete' THEN 0 ELSE 1 END, ch.sort_order, ch.id, cr.id LIMIT 1), COALESCE(r.rank, 0))` -func loadTeamDetailRows(db *sql.DB, teamID int64) ([]TeamDetailRow, error) { +func loadTeamDetailRows(db *sql.DB, teamID int64, joints map[int64]jointTeam) ([]TeamDetailRow, error) { // 聚合通道（basis=aggregate，即「按队内平均」）的流水 entry_id / result_id 都为空， // 从 entries 取不到组别。这类流水是「单位在本组别的成绩取平均」的产物，组别在算分时已经确定； // 库里没把它落到流水上，只能回推：单位在本小项只参加了一个组别时，那个组别就是答案（ac 子查询）。 @@ -691,6 +766,11 @@ func loadTeamDetailRows(db *sql.DB, teamID int64) ([]TeamDetailRow, error) { // 在一份表里是「11.58 秒」、在另一份里是「11.58」，两张表摆在一起核对时会被当成两个数。 r.ResultText = displayResult(resultText, unit) r.Source = sourceLabel(source) + // 这条流水来自联队时说明份额：本单位拿到的是拆给它的那一份（积分列已经是拆后的值）， + // 备注里再把「分给了哪几个单位、各多少」一次写全，核对时不必回头查另一张表。 + if joint, ok := joints[entryID]; ok { + r.Remark = appendNote(r.Remark, joint.shareNote()) + } r.individual = athleteID != 0 keys = append(keys, revisions.KeyFor(source, eventID, entryID)) out = append(out, r) diff --git a/server/internal/export/medals.go b/server/internal/export/medals.go index 508ca57..703458c 100644 --- a/server/internal/export/medals.go +++ b/server/internal/export/medals.go @@ -32,6 +32,10 @@ type MedalDetailRow struct { Medal string Participant string + // jointNote 是联队奖牌的展示值（非空时覆盖 Medal 列）：「金牌（联队 A+B，各单位各记 1 枚）」。 + // 口径是每个成员单位各记一整枚，各单位的奖牌数加起来会比实际颁发的多，这一格就是那句解释。 + jointNote string + // 排序键，只在本包内用，不导出。 sportSort int eventSort int @@ -59,7 +63,9 @@ var medalDetailColumns = []column{ {"小项", 18, kindText}, {"组别", 14, kindText}, {"名次", 8, kindCenter}, - {"奖牌", 8, kindCenter}, + // 奖牌列不是窄的居中列：联队奖牌要把「各单位各记 1 枚」写在奖牌格子里（口径 3）， + // 窄列 + 居中 + 不换行会被右边非空的「运动员/队」裁掉，那句话就白写了。 + {"奖牌", 26, kindText}, // 与分项成绩表的「运动员/队」同宽：奖牌明细同样会印接力队名单。 {"运动员/队", 24, kindText}, } @@ -153,7 +159,11 @@ func medalRow(r MedalDetailRow) []any { if r.Rank > 0 { rank = strconv.Itoa(r.Rank) } - return []any{r.SportName, r.EventName, r.Category, rank, r.Medal, r.Participant} + medal := any(r.Medal) + if r.jointNote != "" { + medal = r.jointNote + } + return []any{r.SportName, r.EventName, r.Category, rank, medal, r.Participant} } // LoadMedalDetailWorkbook 读取全部奖牌来源。 @@ -168,6 +178,14 @@ func LoadMedalDetailWorkbook(db *sql.DB, opts Options) (MedalDetailWorkbook, err if err != nil { return MedalDetailWorkbook{}, err } + // 联队配置：一条成绩归多个单位时，每个成员单位各记一枚整牌，奖牌那一格要写清这件事。 + joints, err := loadJointTeams(db) + if err != nil { + return MedalDetailWorkbook{}, err + } + if len(joints) > 0 { + meta.Note = jointMedalNote + } // 名次输入与榜单同源：loadRanked 只取已发布、有效、计分小项的名次。 ranked, err := loadRanked(db) if err != nil { @@ -197,7 +215,7 @@ func LoadMedalDetailWorkbook(db *sql.DB, opts Options) (MedalDetailWorkbook, err sheets := make([]MedalDetailSheet, 0, len(teams)) for _, t := range teams { - rows := medalRowsOfTeam(t.ID, hits, ctx, eventCtx) + rows := medalRowsOfTeam(t.ID, hits, ctx, eventCtx, joints) if len(rows) == 0 { continue } @@ -208,10 +226,13 @@ func LoadMedalDetailWorkbook(db *sql.DB, opts Options) (MedalDetailWorkbook, err // medalHit 是一枚奖牌：来自哪个小项 / 组别的哪条成绩、什么名次、什么牌。 // 聚合名次与团体手工名次没有单条成绩（resultID 为 0），小项 + 组别是展示字段的兜底来源。 +// entryID 是这条名次对应的报名项：联队份额挂在报名的，联队奖牌的那句说明只能靠它查到 +// （球类现场的名次正是手工按单位录的，此时 resultID 为空，只有 entryID 认得出来）。 type medalHit struct { eventID int64 categoryID int64 resultID int64 + entryID int64 rank int medal string } @@ -235,15 +256,18 @@ func medalHits(ranked []domain.RankedResult, excludeTeam bool) map[int64][]medal for _, row := range rows { for i := 0; i < row.Gold; i++ { out[row.TeamID] = append(out[row.TeamID], medalHit{ - eventID: rr.EventID, categoryID: rr.CategoryID, resultID: rr.ResultID, rank: 1, medal: medalGold}) + eventID: rr.EventID, categoryID: rr.CategoryID, resultID: rr.ResultID, + entryID: rr.EntryID, rank: 1, medal: medalGold}) } for i := 0; i < row.Silver; i++ { out[row.TeamID] = append(out[row.TeamID], medalHit{ - eventID: rr.EventID, categoryID: rr.CategoryID, resultID: rr.ResultID, rank: 2, medal: medalSilver}) + eventID: rr.EventID, categoryID: rr.CategoryID, resultID: rr.ResultID, + entryID: rr.EntryID, rank: 2, medal: medalSilver}) } for i := 0; i < row.Bronze; i++ { out[row.TeamID] = append(out[row.TeamID], medalHit{ - eventID: rr.EventID, categoryID: rr.CategoryID, resultID: rr.ResultID, rank: 3, medal: medalBronze}) + eventID: rr.EventID, categoryID: rr.CategoryID, resultID: rr.ResultID, + entryID: rr.EntryID, rank: 3, medal: medalBronze}) } } } @@ -385,7 +409,7 @@ func loadMedalEventContext(db *sql.DB) (map[eventCategoryKey]medalContext, error // medalRowsOfTeam 把某单位的奖牌拼成展示行，按大项/小项/组别/名次的既有顺序排列。 // 展示字段优先按成绩取（能带上运动员 / 接力队名单），取不到再按小项 + 组别兜底。 -func medalRowsOfTeam(teamID int64, hits map[int64][]medalHit, ctx map[int64]medalContext, eventCtx map[eventCategoryKey]medalContext) []MedalDetailRow { +func medalRowsOfTeam(teamID int64, hits map[int64][]medalHit, ctx map[int64]medalContext, eventCtx map[eventCategoryKey]medalContext, joints map[int64]jointTeam) []MedalDetailRow { list := hits[teamID] rows := make([]MedalDetailRow, 0, len(list)) for _, h := range list { @@ -393,7 +417,7 @@ func medalRowsOfTeam(teamID int64, hits map[int64][]medalHit, ctx map[int64]meda if !ok { c = eventCtx[eventCategoryKey{eventID: h.eventID, categoryID: h.categoryID}] } - rows = append(rows, MedalDetailRow{ + row := MedalDetailRow{ SportName: c.sportName, EventName: c.eventName, Category: c.category, @@ -406,7 +430,15 @@ func medalRowsOfTeam(teamID int64, hits map[int64][]medalHit, ctx map[int64]meda eventID: c.eventID, categoryID: c.categoryID, resultID: h.resultID, - }) + } + // 联队奖牌：把成员单位与「各单位各记 1 枚」写在奖牌那一格（口径 3）。 + // 名次不带报名项时（聚合通道）不补：那种名次本来就不拆份额，说明只会误导。 + if h.entryID != 0 { + if joint, ok := joints[h.entryID]; ok { + row.jointNote = joint.medalCell(h.medal) + } + } + rows = append(rows, row) } sort.SliceStable(rows, func(i, j int) bool { a, b := rows[i], rows[j] diff --git a/server/internal/export/style.go b/server/internal/export/style.go index 9dfc0bf..b0502ba 100644 --- a/server/internal/export/style.go +++ b/server/internal/export/style.go @@ -343,6 +343,9 @@ func metaSubtitle(m Meta) string { if m.GeneratedBy != "" { parts = append(parts, "导出人 "+m.GeneratedBy) } + if m.Note != "" { + parts = append(parts, m.Note) + } return strings.Join(parts, " · ") } diff --git a/server/internal/export/team_all.go b/server/internal/export/team_all.go index cea8305..b5414da 100644 --- a/server/internal/export/team_all.go +++ b/server/internal/export/team_all.go @@ -126,9 +126,15 @@ func LoadAllTeamDetailsWorkbook(db *sql.DB, opts Options) (AllTeamDetailsWorkboo } orderTeamsByStandings(teams, order) + // 联队配置读一次给全部单位分表复用（几个单位就查几遍纯属浪费）。 + joints, err := loadJointTeams(db) + if err != nil { + return AllTeamDetailsWorkbook{}, err + } + sheets := make([]TeamDetailSheet, 0, len(teams)) for _, t := range teams { - rows, err := loadTeamDetailRows(db, t.ID) + rows, err := loadTeamDetailRows(db, t.ID, joints) if err != nil { return AllTeamDetailsWorkbook{}, err } diff --git a/server/internal/httpapi/dto.go b/server/internal/httpapi/dto.go index 79d986f..4854aaa 100644 --- a/server/internal/httpapi/dto.go +++ b/server/internal/httpapi/dto.go @@ -129,6 +129,24 @@ type entryDTO struct { TeamName string `json:"teamName,omitempty"` ShortName *string `json:"shortName,omitempty"` CategoryName string `json:"categoryName,omitempty"` + // TeamShares 是这条报名的归属份额（联队）：读侧至少一条，第一条是主单位（= teamId）。 + // 普通报名也下发一条独占份额，前端不必为「有没有联队」写两套渲染。 + TeamShares []entryTeamShareDTO `json:"teamShares"` +} + +// entryTeamShareDTO 是报名份额的一条（联队的一个成员单位）。 +// +// - weight：积分份额，**相对权重**（缺省 1）。引擎按权重之和归一，所以 1+1 与 0.5+0.5 等价； +// 入库也就存原值，不做归一，避免 2:1 被写成 0.666…/0.333… 这种除不尽的数。 +// - medal ：这枚奖牌是否**整枚**记给该单位（缺省 true）。联队的金牌两个单位各记 1 枚， +// 与 weight 无关——奖牌榜数整数枚，不按积分权重拆。 +// - teamCode / teamName 是读侧补的展示字段（前端拼「A+B联队」用），写侧不需要带。 +type entryTeamShareDTO struct { + TeamID int64 `json:"teamId"` + Weight float64 `json:"weight"` + Medal *bool `json:"medal,omitempty"` + TeamCode string `json:"teamCode,omitempty"` + TeamName string `json:"teamName,omitempty"` } type entryWithResultDTO struct { diff --git a/server/internal/httpapi/entries_sheet_template.go b/server/internal/httpapi/entries_sheet_template.go index 817c572..451d240 100644 --- a/server/internal/httpapi/entries_sheet_template.go +++ b/server/internal/httpapi/entries_sheet_template.go @@ -433,6 +433,56 @@ func entryTemplateHeader(language string) []string { return out } +// 联队（devdocs/19）怎么写，是模板必须教给填表人的事：单位编码写 `A+B`，加号左边是主单位， +// 积分平均分、奖牌两边各记一枚。中英各一份，与表头语言一致。 +// +// 文案只能挂在**不会变成数据的载体**上：表头行是导入器认模板的锚点（必须留在第 1 行、12 列 +// 一字不动），工作表名是「小项@组别」的范围锚点（也不能多出一张说明表，否则整份文件按分工作表 +// 口径解析时会对不上号）。所以这里用两处：单位编码表头的**单元格批注**（红三角一眼能看见） +// 与这一列的**输入提示**（点中格子就弹出来）。 +const ( + entryJointHintZH = "单位编码怎么写：\n" + + "· 单个单位参赛：填它的编码，例如 A。\n" + + "· 同一小项组别里两个单位联合参赛（联队）：写 A+B，加号左边那个是主单位。\n" + + "　　积分在两个单位之间平均分（各 50%，拆出 0.5 分照实记）；\n" + + "　　奖牌两边各记一枚整牌——联队的金牌，A、B 各记 1 枚。" + entryJointPromptZH = "联队写 A+B（加号左边是主单位）：积分平均分，奖牌两边各记一枚" + entryJointTitleZH = "单位编码怎么写" + entryJointHintEN = "How to fill the team code:\n" + + "- One unit: its code, for example A.\n" + + "- Two units entering together as a joint team (same event and category): write A+B, " + + "the left one is the primary unit.\n" + + " Points are split evenly between them (50% each; halves such as 7.5 are kept as they are);\n" + + " each unit is credited one full medal - a joint gold counts as one for A and one for B." + entryJointPromptEN = "Joint team: write A+B (left one is the primary unit). " + + "Points split evenly, each unit gets one full medal" + entryJointTitleEN = "How to fill the team code" + // entryTemplateAuthor 是批注作者。写系统名（与导出件的文档属性同一套）， + // 绝不写构建期注入的内部署名。 + entryTemplateAuthor = "赛事积分榜系统" + // entryTemplateHintRows 是输入提示覆盖的行数：模板是空表，给填表人留够行即可。 + entryTemplateHintRows = 500 +) + +// entryTemplateJointHint 按表头语言取「联队怎么写」的说明（批注正文 + 输入提示的标题与正文）。 +func entryTemplateJointHint(language string) (hint, title, prompt string) { + if language == "en" { + return entryJointHintEN, entryJointTitleEN, entryJointPromptEN + } + return entryJointHintZH, entryJointTitleZH, entryJointPromptZH +} + +// entryTeamCodeColumn 是 team_code 在表头里的列号（0 起）。模板的说明挂在这一列上， +// 所以它从 importColumns 现算，改了列序也不会挂错格子。 +func entryTeamCodeColumn() int { + for i, column := range importColumns { + if column.name == "team_code" { + return i + } + } + return -1 +} + // entryTemplateFilename 是两种表头语言的下载文件名，前端按同一份口径拼文件名。 func entryTemplateFilename(language string) string { if language == "en" { @@ -488,9 +538,13 @@ func (s *server) entriesTemplateXLSX(w http.ResponseWriter, r *http.Request) (an } headers := entryTemplateHeader(language) + hint, hintTitle, prompt := entryTemplateJointHint(language) sheets := make([]entriesTemplateSheet, 0, len(plan.sheets)) for _, planned := range plan.sheets { - sheets = append(sheets, entriesTemplateSheet{Name: planned.Name, Headers: headers}) + sheets = append(sheets, entriesTemplateSheet{ + Name: planned.Name, Headers: headers, + JointHint: hint, JointHintTitle: hintTitle, JointPrompt: prompt, + }) } name := entryTemplateFilename(language) ascii := "entries-template-" + language + ".xlsx" @@ -518,6 +572,11 @@ func entrySheetExcludedMessage(problems []string) string { type entriesTemplateSheet struct { Name string Headers []string + // JointHint / JointHintTitle / JointPrompt 是「单位编码写 A+B」的说明（按表头语言取）， + // 挂在该列的批注与输入提示上。 + JointHint string + JointHintTitle string + JointPrompt string } // writeEntriesTemplateXLSX 写整份模板工作簿。 @@ -580,6 +639,9 @@ func writeEntriesTemplateXLSX(out io.Writer, sheets []entriesTemplateSheet) erro if err := f.SetRowHeight(sheet.Name, 1, 24); err != nil { return err } + if err := writeEntryJointTeamHint(f, sheet); err != nil { + return err + } // 冻结表头：一张表几十行，往下翻的时候列名得一直看得见。 if err := f.SetPanes(sheet.Name, &excelize.Panes{ Freeze: true, YSplit: 1, TopLeftCell: "A2", ActivePane: "bottomLeft", @@ -592,3 +654,45 @@ func writeEntriesTemplateXLSX(out io.Writer, sheets []entriesTemplateSheet) erro } return nil } + +// writeEntryJointTeamHint 把「联队怎么写」挂在单位编码列上：表头那一格一条批注（有红三角）， +// 整列一条输入提示（点中格子就弹出）。 +// +// 只动这两种载体，不碰任何单元格的值与行列结构：填好的表原样传回来时，导入器读到的仍是 +// 「第 1 行 12 列表头 + 数据行」，批注与输入提示不是数据。 +func writeEntryJointTeamHint(f *excelize.File, sheet entriesTemplateSheet) error { + column := entryTeamCodeColumn() + if column < 0 || column >= len(sheet.Headers) || sheet.JointHint == "" { + return nil + } + name, err := excelize.ColumnNumberToName(column + 1) + if err != nil { + return err + } + if err := f.AddComment(sheet.Name, excelize.Comment{ + Cell: name + "1", + Author: entryTemplateAuthor, + Text: sheet.JointHint, + Width: 360, + Height: 170, + }); err != nil { + return fmt.Errorf("httpapi: 写模板批注 %s!%s1: %w", sheet.Name, name, err) + } + if sheet.JointPrompt == "" { + return nil + } + // 刻意用 type="none"：这里只要一条提示，不要任何取值限制——现场的表千奇百怪， + // 模板不该因为一条校验规则把好好的编码挡在门外。 + dv := excelize.NewDataValidation(true) + dv.SetSqref(fmt.Sprintf("%s2:%s%d", name, name, entryTemplateHintRows)) + dv.Type = "none" + title := sheet.JointHintTitle + if title == "" { + title = "单位编码" + } + dv.SetInput(title, sheet.JointPrompt) + if err := f.AddDataValidation(sheet.Name, dv); err != nil { + return fmt.Errorf("httpapi: 写模板输入提示 %s!%s: %w", sheet.Name, name, err) + } + return nil +} diff --git a/server/internal/httpapi/entry_shares.go b/server/internal/httpapi/entry_shares.go new file mode 100644 index 0000000..1d6e16a --- /dev/null +++ b/server/internal/httpapi/entry_shares.go @@ -0,0 +1,421 @@ +package httpapi + +import ( + "context" + "database/sql" + "fmt" + "net/http" + "strings" + + "git.yeij.top/AskaEth/Scoreboard/server/internal/domain" + "git.yeij.top/AskaEth/Scoreboard/server/internal/middleware" +) + +// 本文件是「联队 + 份额分成」的读写与解析（devdocs/19）。 +// +// 表达方式：**联队是一条报名，不是一个新单位**。新建/修改报名时给多个成员单位（默认均分）， +// 分数与奖牌由引擎按份额下发到各单位；entries.team_id 仍是主单位（加号左边那个）， +// 既有查询、唯一键、榜单兜底都还认它。 +// +// 与导入的关系：报名表的 team_code 列写 `A+B` 就是联队（默认均分），解析见 parseJointTeamCodes。 + +// maxJointTeamMembers 是联队的成员单位上限。现场最多见过三个单位合并，给到 5 已经远超需要； +// 上限的作用是拦住「一整格都是加号」这类误填，而不是限制业务。 +const maxJointTeamMembers = 5 + +// parseJointTeamCodes 解析报名表 team_code 单元格：`A` → 单单位，`A+B` → 联队（A 是主单位）。 +// +// 全角 ＋ 与两侧空格都当作分隔符的一部分（现场用中文输入法填表，打出来的常是全角）， +// 但**只做这一层归一**：分段为空（`A+`、`+B`、`A++B`）、重复（`A+A`）、超长一律报错。 +// 报错必须说清「这一格该怎么写」——现场看到一句「编码非法」是没法照着改的。 +func parseJointTeamCodes(raw string) ([]string, error) { + normalized := strings.ReplaceAll(raw, "＋", "+") + parts := strings.Split(normalized, "+") + codes := make([]string, 0, len(parts)) + seen := make(map[string]bool, len(parts)) + for _, part := range parts { + code := strings.TrimSpace(part) + if code == "" { + return nil, fmt.Errorf("单位编码 %s 里有一段是空的：联队要写成两个单位编码用 + 连起来（例如 A+B）", raw) + } + if seen[code] { + return nil, fmt.Errorf("单位编码 %s 里同一个单位出现了两次：联队的每个单位只能写一次", raw) + } + seen[code] = true + codes = append(codes, code) + } + if len(codes) > maxJointTeamMembers { + return nil, fmt.Errorf("单位编码 %s 里写了 %d 个单位：一个联队最多 %d 个单位", + raw, len(codes), maxJointTeamMembers) + } + return codes, nil +} + +// lookupImportTeams 把 team_code 解析成单位 id 与份额：普通报名一个单位，联队多个（默认均分）。 +// +// 返回的份额就是写库要用的那套：每条权重 1（均分），medal 缺省（整枚各记）。 +// 主单位是 codes[0]（加号左边那个），它进 entries.team_id。 +// +// 报错都是给现场看的行级文案，不包 apiError：调用方（导入主循环）用 err.Error() 原样回显， +// 多一层前缀现场反而看不懂。单位不存在时必须点明是联队里的哪一段，否则一行 `A+B` 里 +// 找不到 B 的时候，录入员会以为是 A 写错了。 +func (s *server) lookupImportTeams(ctx context.Context, teamCode string) ([]int64, []entryTeamShareDTO, error) { + codes, err := parseJointTeamCodes(teamCode) + if err != nil { + return nil, nil, err + } + ids := make([]int64, 0, len(codes)) + shares := make([]entryTeamShareDTO, 0, len(codes)) + for _, code := range codes { + id, err := s.lookupID(ctx, `SELECT id FROM teams WHERE code = ?`, code) + if err != nil { + if len(codes) > 1 { + return nil, nil, fmt.Errorf("单位 %s 不存在（来自联队编码 %s）", code, teamCode) + } + return nil, nil, fmt.Errorf("单位 %s 不存在", code) + } + // 编码查单位时不排除已隐藏的（编码有唯一索引，排除会撞索引或重复建档）， + // 命中就复活他：这一行马上要给他建报名，人却看不见就说不通了。 + if err := s.reviveTeam(ctx, id); err != nil { + return nil, nil, err + } + ids = append(ids, id) + shares = append(shares, entryTeamShareDTO{TeamID: id, Weight: 1}) + } + return ids, shares, nil +} + +// entryTeamSharesReady 判断份额表在不在。 +// +// 读路径要能读「还没跑到 0024 的库」：迁移在服务启动时补跑（main.go），但榜单可能在迁移之前 +// 被读一次——0022 的老库回归用例就是在迁移前读榜的，它读的正是升级前那份错榜。 +// 表不在 = 库里没有任何联队配置 = 主单位独占 100%，正是老数据本来就该得到的结果， +// 所以按「没有份额」处理是**精确**的，不是容错降级（份额表缺表时不可能丢掉真实配置）。 +func entryTeamSharesReady(ctx context.Context, q queryer) (bool, error) { + var n int + if err := q.QueryRowContext(ctx, + `SELECT COUNT(*) FROM sqlite_master WHERE type = 'table' AND name = 'entry_team_shares'`).Scan(&n); err != nil { + return false, err + } + return n != 0, nil +} + +// loadEntryTeamSharesQ 读一条 SQL 里给定范围内报名的份额，按 entry_id 归组。 +// eventID 为 0 表示全库（导出与快照用，与它们读 channel_ranks 的范围一致）。 +// +// 排序按 (sort_order, team_id)：主单位排第一是由写侧保证的，引擎不依赖顺序取分， +// 但展示与流水顺序要稳定，否则同一份数据两次导出会排出两个样子。 +func loadEntryTeamSharesQ(ctx context.Context, q queryer, eventID int64) (map[int64][]domain.TeamShare, error) { + ready, err := entryTeamSharesReady(ctx, q) + if err != nil { + return nil, internal(err) + } + if !ready { + return nil, nil + } + query := `SELECT s.entry_id, s.team_id, s.points_share, s.medal_share + FROM entry_team_shares s` + args := []any{} + if eventID != 0 { + query += ` JOIN entries e ON e.id = s.entry_id WHERE e.event_id = ?` + args = append(args, eventID) + } + query += ` ORDER BY s.entry_id, s.sort_order, s.team_id` + + rows, err := q.QueryContext(ctx, query, args...) + if err != nil { + return nil, internal(err) + } + defer func() { _ = rows.Close() }() + + out := make(map[int64][]domain.TeamShare) + for rows.Next() { + var ( + entryID int64 + s domain.TeamShare + medal int + ) + if err := rows.Scan(&entryID, &s.TeamID, &s.Weight, &medal); err != nil { + return nil, internal(err) + } + if medal == 0 { + excluded := false + s.Medal = &excluded + } + out[entryID] = append(out[entryID], s) + } + return out, rows.Err() +} + +// loadEntrySharesDTOs 读某小项全部报名的份额读数形态：带上单位编码 / 名称， +// 前端据此拼「A+B联队」，不必再查一次单位表。 +func (s *server) loadEntrySharesDTOs(ctx context.Context, q queryer, eventID int64) (map[int64][]entryTeamShareDTO, error) { + ready, err := entryTeamSharesReady(ctx, q) + if err != nil { + return nil, internal(err) + } + if !ready { + return nil, nil + } + rows, err := q.QueryContext(ctx, + `SELECT s.entry_id, s.team_id, s.points_share, s.medal_share, t.code, t.name + FROM entry_team_shares s + JOIN entries e ON e.id = s.entry_id + JOIN teams t ON t.id = s.team_id + WHERE e.event_id = ? + ORDER BY s.entry_id, s.sort_order, s.team_id`, eventID) + if err != nil { + return nil, internal(err) + } + defer func() { _ = rows.Close() }() + + out := make(map[int64][]entryTeamShareDTO) + for rows.Next() { + var ( + entryID int64 + item entryTeamShareDTO + medal int + ) + if err := rows.Scan(&entryID, &item.TeamID, &item.Weight, &medal, &item.TeamCode, &item.TeamName); err != nil { + return nil, internal(err) + } + if medal == 0 { + excluded := false + item.Medal = &excluded + } + out[entryID] = append(out[entryID], item) + } + return out, rows.Err() +} + +// entrySharesOf 把一条报名的份额补齐成「至少一条」：库里没有份额行时按主单位独占 100%。 +// 与引擎的 domain.ResolveShares 同口径（那边用 []domain.TeamShare，这边还要带展示字段）。 +// 主单位的编码 / 名称由调用方给（报名查询里本来就 join 了单位表）。 +func entrySharesOf(configured []entryTeamShareDTO, primaryTeamID int64, code, name string) []entryTeamShareDTO { + if len(configured) > 0 { + return configured + } + if primaryTeamID == 0 { + return nil + } + return []entryTeamShareDTO{{TeamID: primaryTeamID, Weight: 1, TeamCode: code, TeamName: name}} +} + +// replaceEntryShares 按给定顺序重写一条报名的份额（先删后插，幂等）。 +// +// 为什么每次都重写、而不是「有联队才写」：报名可以被改成另一个样子（联队改回单单位、 +// 换成员单位）。只增不减会留下旧份额，那条报名以后一直按早就改掉的配置分账。 +// 传空份额时按主单位独占补一条，保持「读侧至少一条」这个不变式。 +func replaceEntryShares(ctx context.Context, q queryer, entryID, primaryTeamID int64, shares []entryTeamShareDTO) error { + if _, err := q.ExecContext(ctx, `DELETE FROM entry_team_shares WHERE entry_id = ?`, entryID); err != nil { + return internal(err) + } + if len(shares) == 0 { + shares = []entryTeamShareDTO{{TeamID: primaryTeamID, Weight: 1}} + } + for i, s := range shares { + medal := 1 + if !entryShareCountsMedal(s) { + medal = 0 + } + if _, err := q.ExecContext(ctx, + `INSERT INTO entry_team_shares (entry_id, team_id, points_share, medal_share, sort_order) + VALUES (?, ?, ?, ?, ?)`, + entryID, s.TeamID, entryShareWeight(s), medal, i); err != nil { + return internal(err) + } + } + return nil +} + +// sharesContainTeam 判断份额里有没有这个单位（导入侧用它核对「主单位还在不在成员里」）。 +func sharesContainTeam(shares []entryTeamShareDTO, teamID int64) bool { + for _, s := range shares { + if s.TeamID == teamID { + return true + } + } + return false +} + +// entryShareCountsMedal 与 domain.TeamShare.CountsMedal 同一口径：缺省（nil）= 整枚各记。 +func entryShareCountsMedal(s entryTeamShareDTO) bool { + return s.Medal == nil || *s.Medal +} + +// entryShareWeight 与 domain 的 shareWeight 同一口径：0（不填）按 1 处理，也就是均分。 +// 负数在 validateEntryShares 就被拦下，这里的兜底只是让写库不会撞上 CHECK。 +func entryShareWeight(s entryTeamShareDTO) float64 { + if s.Weight <= 0 { + return 1 + } + return s.Weight +} + +// validateEntryShares 校验一次份额改动，返回给人看的 400 错误。 +// +// 规则（每一条都对着一种会算错分的写法）： +// - 不能为空：份额为空等于没说清这条报名的分该给谁； +// - 每个单位都得存在且没被假删除：删掉的单位不该再收分； +// - 权重不能是负数：份额是相对权重，不填（0）就是 1——「均分」的写法，负数没有任何含义； +// - 同一个单位只能出现一次：重复会让同一条成绩给同一个单位记两份分、两枚牌； +// - 必须包含主单位（entries.team_id）：主单位是这条报名在库里的身份（唯一键用它）， +// 把它排除在份额之外，只会得到「报名挂在 A 头上、分全给了 B」这种看不见的错。 +func (s *server) validateEntryShares(ctx context.Context, primaryTeamID int64, shares []entryTeamShareDTO) error { + if len(shares) == 0 { + return badRequest("teamShares 不能为空：至少要有主单位一条", nil) + } + if len(shares) > maxJointTeamMembers { + return badRequest(fmt.Sprintf("teamShares 最多 %d 个单位：一个联队不需要这么多成员", maxJointTeamMembers), nil) + } + ids := make([]int64, 0, len(shares)) + seen := make(map[int64]bool, len(shares)) + hasPrimary := false + for i, s := range shares { + if s.TeamID == 0 { + return badRequest("teamShares[].teamId 必填", i) + } + if seen[s.TeamID] { + return badRequest(fmt.Sprintf("teamShares 里单位 %d 出现了两次：同一个单位只能占一份", s.TeamID), i) + } + seen[s.TeamID] = true + if s.Weight < 0 { + return badRequest(fmt.Sprintf("teamShares[].weight 不能为负数（当前 %v）：份额是相对权重，不填或填 0 就按 1 算（均分）", s.Weight), i) + } + if s.TeamID == primaryTeamID { + hasPrimary = true + } + ids = append(ids, s.TeamID) + } + if !hasPrimary { + return badRequest(fmt.Sprintf("teamShares 必须包含这条报名的主单位 %d：主单位不能从份额里去掉（换主单位要重新建报名）", primaryTeamID), nil) + } + + args := make([]any, 0, len(ids)) + for _, id := range ids { + args = append(args, id) + } + rows, err := s.ev.QueryContext(ctx, + `SELECT id FROM teams WHERE deleted_at IS NULL AND id IN (`+placeholders(len(ids))+`)`, args...) + if err != nil { + return internal(err) + } + defer func() { _ = rows.Close() }() + exists := make(map[int64]bool, len(ids)) + for rows.Next() { + var id int64 + if err := rows.Scan(&id); err != nil { + return internal(err) + } + exists[id] = true + } + if err := rows.Err(); err != nil { + return err + } + missing := make([]int64, 0) + for _, id := range ids { + if !exists[id] { + missing = append(missing, id) + } + } + if len(missing) > 0 { + return badRequest("teamId 不存在或已删除", missing) + } + return nil +} + +// loadEntryForShares 读一条报名的落点（小项 / 组别 / 主单位），份额改动要用它决定重算范围。 +func (s *server) loadEntryForShares(ctx context.Context, entryID int64) (eventID, categoryID, teamID int64, err error) { + err = s.ev.QueryRowContext(ctx, + `SELECT event_id, category_id, team_id FROM entries WHERE id = ?`, entryID). + Scan(&eventID, &categoryID, &teamID) + if err == sql.ErrNoRows { + return 0, 0, 0, notFound("报名项不存在") + } + if err != nil { + return 0, 0, 0, internal(err) + } + return eventID, categoryID, teamID, nil +} + +// updateEntryTeamShares 改写一条报名的份额并重算它所在的小项组别。 +// +// 必须重算：份额决定同一条成绩的分记在谁头上，不重算就是「界面显示改好了、榜单还是旧分」。 +// 奖牌不需要单独处理——它由读取侧按 entry_team_shares 现算，落地即生效。 +func (s *server) updateEntryTeamShares(ctx context.Context, entryID int64, shares []entryTeamShareDTO, actorID int64) (entryDTO, error) { + eventID, categoryID, teamID, err := s.loadEntryForShares(ctx, entryID) + if err != nil { + return entryDTO{}, err + } + if err := s.validateEntryShares(ctx, teamID, shares); err != nil { + return entryDTO{}, err + } + + tx, err := s.ev.BeginTx(ctx, nil) + if err != nil { + return entryDTO{}, internal(err) + } + defer func() { _ = tx.Rollback() }() + + if err := replaceEntryShares(ctx, tx, entryID, teamID, shares); err != nil { + return entryDTO{}, err + } + score, err := recomputeLedgerTx(ctx, tx, eventID, categoryID, actorID, "报名份额变更后重算") + if err != nil { + return entryDTO{}, err + } + if err := applyComputedRanks(ctx, tx, score.Ranked); err != nil { + return entryDTO{}, err + } + if err := s.bumpEvent(ctx, tx, eventID); err != nil { + return entryDTO{}, err + } + if err := s.bumpStandings(ctx, tx, actorID); err != nil { + return entryDTO{}, err + } + if err := tx.Commit(); err != nil { + return entryDTO{}, internal(err) + } + return s.getEntry(ctx, entryID) +} + +// getEntry 读回单条报名（含份额），供份额改写接口回显。 +func (s *server) getEntry(ctx context.Context, entryID int64) (entryDTO, error) { + e, err := scanEntry(s.ev.QueryRowContext(ctx, entrySelect+` WHERE e.id = ?`, entryID)) + if err != nil { + if err == sql.ErrNoRows { + return entryDTO{}, notFound("报名项不存在") + } + return entryDTO{}, internal(err) + } + shares, err := s.loadEntrySharesDTOs(ctx, s.ev, e.EventID) + if err != nil { + return entryDTO{}, err + } + e.TeamShares = entrySharesOf(shares[e.ID], e.TeamID, e.TeamCode, e.TeamName) + return e, nil +} + +// updateEntryTeamSharesHandler 是 PUT /api/entries/{id}/team-shares： +// 改一条报名的成员单位与权重（联队），成功后返回这条报名的完整读数。 +func (s *server) updateEntryTeamSharesHandler(w http.ResponseWriter, r *http.Request) (any, error) { + id, err := pathID(r, "id") + if err != nil { + return nil, err + } + var in entryTeamSharesPayload + if err := decodeJSON(r, &in); err != nil { + return nil, err + } + before, err := s.getEntry(r.Context(), id) + if err != nil { + return nil, err + } + updated, err := s.updateEntryTeamShares(r.Context(), id, in.TeamShares, middleware.User(r.Context()).ID) + if err != nil { + return nil, err + } + s.audit(r.Context(), "entry.team_shares.update", "entry", id, + map[string]any{"teamShares": before.TeamShares}, map[string]any{"teamShares": updated.TeamShares}) + return updated, nil +} diff --git a/server/internal/httpapi/entry_shares_test.go b/server/internal/httpapi/entry_shares_test.go new file mode 100644 index 0000000..dbcb021 --- /dev/null +++ b/server/internal/httpapi/entry_shares_test.go @@ -0,0 +1,396 @@ +package httpapi_test + +import ( + "fmt" + "net/http" + "strings" + "testing" +) + +// 本文件钉住「联队 + 份额分成」从导入到榜单的完整链路（devdocs/19）： +// - 报名表 team_code 写 `A+B` → 一条报名挂两个单位（默认均分），主单位是加号左边那个； +// - 团体第 1 名 15 分 → 两个单位各 7.5 分；金牌两个单位**各记 1 枚**（不是各 0.5 枚）； +// - 权重可配（2:1 → 10 / 5），改完当场重算推榜； +// - 非法写法（单位不存在 / 缺一段 / 重复 / 太多）必须拦下并给出照得着改的报错。 + +// seedMatchEvent 造一个「球类」小项：match 类型 + 按单位录名次的团体通道 +// （规则包给 match 的模板就是 scope=team + basis=manual），返回小项与组别 id。 +func seedMatchEvent(t *testing.T, env *testEnv, ids seedIDs) (eventID, categoryID int64) { + t.Helper() + eventID = env.insert(t, `INSERT INTO events (sport_id, code, name, event_type, result_mode, result_type, + compare, scored, multiplier, status) + VALUES (?, 'BALL', '篮球', 'match', 'manual', 'count', 'none', 1, 1, 'ongoing')`, ids.sport) + categoryID = env.insert(t, `INSERT INTO event_categories (event_id, name, multiplier, sort_order) + VALUES (?, '男子', 1, 0)`, eventID) + env.exec(t, `INSERT INTO event_score_channels (event_id, scope, basis, profile_id, sort_order) + VALUES (?, 'team', 'manual', ?, 0)`, eventID, profileIDByCode(t, env, "team_top6")) + return eventID, categoryID +} + +// jointImportRow 拼一行团体报名（无姓名 = 团体行），列序与 importHeader 一致。 +func jointImportRow(eventCode, category, teamCode string) string { + return strings.Join([]string{eventCode, category, teamCode, "", "", "", "", "", "", "registered", "张伟/李强"}, ",") +} + +// importCSV 上传一份单表 CSV（表头 + 若干行）。 +func importCSV(t *testing.T, env *testEnv, client *http.Client, rows ...string) (int, envelope) { + t.Helper() + content := importHeader + "\n" + strings.Join(rows, "\n") + "\n" + return env.postImport(t, client, "/api/entries/import", content, "") +} + +// sharesDump 导出某小项「报名 + 份额」的原始落库事实（列序见下面的查询）： +// share_team 为 "" 表示这条报名一条份额都没有（不该出现）。 +func sharesDump(t *testing.T, env *testEnv, eventID int64) string { + t.Helper() + return tableDump(t, env, fmt.Sprintf( + `SELECT e.id AS entry_id, COALESCE(e.athlete_id, 0) AS athlete_id, e.team_id, + COALESCE(s.team_id, 0) AS share_team, COALESCE(s.points_share, 0) AS points_share, + COALESCE(s.medal_share, 0) AS medal_share, COALESCE(s.sort_order, 0) AS sort_order + FROM entries e + LEFT JOIN entry_team_shares s ON s.entry_id = e.id + WHERE e.event_id = %d + ORDER BY e.id, s.sort_order, s.team_id`, eventID)) +} + +// shareRow 按 tableDump 的格式拼一行份额（列名=值，行尾一个空格）。 +func shareRow(entryID, athleteID, teamID, shareTeam int64, weight float64, medal, order int) string { + return fmt.Sprintf("entry_id=%d athlete_id=%d team_id=%d share_team=%d points_share=%v medal_share=%d sort_order=%d \n", + entryID, athleteID, teamID, shareTeam, weight, medal, order) +} + +// shareAbsentRow 是「这条报名一条份额行都没有」的 dump 行：种子 / 手工造的报名直接写 entries， +// 绕过了导入，库里就没有份额行——读侧与引擎都按主单位独占 100% 兜底（老数据同理）。 +func shareAbsentRow(entryID, athleteID, teamID int64) string { + return fmt.Sprintf("entry_id=%d athlete_id=%d team_id=%d share_team=0 points_share=0 medal_share=0 sort_order=0 \n", + entryID, athleteID, teamID) +} + +// firstEntryID 取某小项的第一条报名 id。 +func firstEntryID(t *testing.T, env *testEnv, eventID int64) int64 { + t.Helper() + var id int64 + if err := env.ev.QueryRow(`SELECT id FROM entries WHERE event_id = ? ORDER BY id LIMIT 1`, eventID).Scan(&id); err != nil { + t.Fatalf("读报名项: %v", err) + } + return id +} + +// standingsRow 取积分榜上某个单位那一行（REST /api/standings 的原始读数）。 +func standingsRow(t *testing.T, env *testEnv, client *http.Client, teamID int64) map[string]any { + t.Helper() + status, resp := env.do(client, http.MethodGet, "/api/standings", nil, false) + if status != http.StatusOK || !resp.OK { + t.Fatalf("读积分榜应 200，得到 %d %+v", status, resp.Error) + } + for _, row := range decodeData[[]map[string]any](t, resp) { + if row["teamId"] == float64(teamID) { + return row + } + } + t.Fatalf("积分榜上没有单位 %d", teamID) + return nil +} + +// assertStanding 断言某单位的总分与金银铜。 +func assertStanding(t *testing.T, env *testEnv, client *http.Client, teamID int64, points float64, gold, silver, bronze int) { + t.Helper() + row := standingsRow(t, env, client, teamID) + if got := row["totalPoints"].(float64); got != points { + t.Errorf("单位 %d 总分 = %v，期望 %v（整行：%+v）", teamID, got, points, row) + } + for name, want := range map[string]int{"gold": gold, "silver": silver, "bronze": bronze} { + if got := row[name].(float64); got != float64(want) { + t.Errorf("单位 %d 的 %s = %v，期望 %d（整行：%+v）", teamID, name, got, want, row) + } + } +} + +// 现场场景：两个单位因人数不足合并参赛，团体第 1 名 15 分 → A、B 各 7.5 分、各 1 枚金牌。 +func TestImportJointTeamSplitsPointsAndMedals(t *testing.T) { + env, ids, client := recorderWithSeed(t) + eventID, categoryID := seedMatchEvent(t, env, ids) + + status, resp := importCSV(t, env, client, jointImportRow("BALL", "男子", "A+B")) + if status != http.StatusOK || !resp.OK { + t.Fatalf("导入联队报名应 200，得到 %d %+v", status, resp.Error) + } + if result := decodeData[map[string]any](t, resp); result["created"].(float64) != 1 { + t.Fatalf("应新建 1 条报名，得到 %+v", result) + } + + // 主单位是加号左边那个（A），份额表里两条均分、奖牌各记整枚。 + entryID := firstEntryID(t, env, eventID) + want := shareRow(entryID, 0, ids.teamA, ids.teamA, 1, 1, 0) + + shareRow(entryID, 0, ids.teamA, ids.teamB, 1, 1, 1) + if got := sharesDump(t, env, eventID); got != want { + t.Fatalf("联队报名落库不对：\n得到 %s期望 %s", got, want) + } + + // 团体名次录在主单位上（现场就是按单位录名次）：联队第 1 名。 + if status, resp := putTeamRanks(t, env, client, eventID, categoryID, []map[string]any{ + {"teamId": ids.teamA, "rank": 1}, + }); status != http.StatusOK { + t.Fatalf("录团体名次应 200，得到 %d %+v", status, resp.Error) + } + + // 积分各 7.5（允许出现小数），金牌各 1 枚。 + assertStanding(t, env, client, ids.teamA, 7.5, 1, 0, 0) + assertStanding(t, env, client, ids.teamB, 7.5, 1, 0, 0) + + ledger := tableDump(t, env, `SELECT team_id, points FROM score_ledger WHERE voided = 0 ORDER BY team_id`) + wantLedger := fmt.Sprintf("team_id=%d points=7.5 \nteam_id=%d points=7.5 \n", ids.teamA, ids.teamB) + if ledger != wantLedger { + t.Fatalf("积分流水应按份额拆成两条：\n得到 %s期望 %s", ledger, wantLedger) + } +} + +// 权重可配：改成 2:1 → 10 / 5；奖牌仍是各 1 枚（两个口径互不影响）。 +func TestUpdateEntryTeamSharesWeights(t *testing.T) { + env, ids, client := recorderWithSeed(t) + eventID, categoryID := seedMatchEvent(t, env, ids) + if status, resp := importCSV(t, env, client, jointImportRow("BALL", "男子", "A+B")); status != http.StatusOK { + t.Fatalf("导入联队报名应 200，得到 %d %+v", status, resp.Error) + } + entryID := firstEntryID(t, env, eventID) + if status, resp := putTeamRanks(t, env, client, eventID, categoryID, []map[string]any{ + {"teamId": ids.teamA, "rank": 1}, + }); status != http.StatusOK { + t.Fatalf("录团体名次应 200，得到 %d %+v", status, resp.Error) + } + assertStanding(t, env, client, ids.teamA, 7.5, 1, 0, 0) + + path := fmt.Sprintf("/api/entries/%d/team-shares", entryID) + status, resp := env.do(client, http.MethodPut, path, map[string]any{ + "teamShares": []map[string]any{ + {"teamId": ids.teamA, "weight": 2}, + {"teamId": ids.teamB, "weight": 1}, + }, + }, true) + if status != http.StatusOK || !resp.OK { + t.Fatalf("改份额应 200，得到 %d %+v", status, resp.Error) + } + updated := decodeData[map[string]any](t, resp) + shares, _ := updated["teamShares"].([]any) + if len(shares) != 2 { + t.Fatalf("回显应带两条份额，得到 %+v", updated["teamShares"]) + } + first, _ := shares[0].(map[string]any) + if first["teamId"] != float64(ids.teamA) || first["weight"] != float64(2) { + t.Fatalf("回显的第一条应是主单位 A 权重 2，得到 %+v", first) + } + if first["teamCode"] != "A" || first["teamName"] != "第一分公司" { + t.Fatalf("回显应带上单位编码与名称（前端拼「A+B联队」用），得到 %+v", first) + } + + // 改完当场重算：2:1 拆成 10 / 5，奖牌不受权重影响，仍是各 1 枚。 + assertStanding(t, env, client, ids.teamA, 10, 1, 0, 0) + assertStanding(t, env, client, ids.teamB, 5, 1, 0, 0) + + // 奖牌开关按单位存（medal=false 落成 medal_share=0 再读回来），积分照旧按权重拆。 + status, resp = env.do(client, http.MethodPut, path, map[string]any{ + "teamShares": []map[string]any{ + {"teamId": ids.teamA, "weight": 2}, + {"teamId": ids.teamB, "weight": 1, "medal": false}, + }, + }, true) + if status != http.StatusOK || !resp.OK { + t.Fatalf("关掉成员单位的奖牌应 200，得到 %d %+v", status, resp.Error) + } + shares, _ = decodeData[map[string]any](t, resp)["teamShares"].([]any) + second, _ := shares[1].(map[string]any) + if second["medal"] != false { + t.Fatalf("回显应带上「这个单位不记奖牌」（medal:false），得到 %+v", second) + } + assertStanding(t, env, client, ids.teamA, 10, 1, 0, 0) + assertStanding(t, env, client, ids.teamB, 5, 0, 0, 0) +} + +// 非法份额的报错必须说清怎么改（人话），且一律不落库。 +func TestUpdateEntryTeamSharesRejectsBadPayloads(t *testing.T) { + env, ids, client := recorderWithSeed(t) + eventID, _ := seedMatchEvent(t, env, ids) + if status, resp := importCSV(t, env, client, jointImportRow("BALL", "男子", "A")); status != http.StatusOK { + t.Fatalf("导入单人报名应 200，得到 %d %+v", status, resp.Error) + } + entryID := firstEntryID(t, env, eventID) + path := fmt.Sprintf("/api/entries/%d/team-shares", entryID) + baseline := tableDump(t, env, `SELECT team_id, points_share FROM entry_team_shares ORDER BY team_id`) + + cases := []struct { + name string + body map[string]any + want string + }{ + {"空份额", map[string]any{"teamShares": []map[string]any{}}, "teamShares 不能为空"}, + {"缺主单位", map[string]any{"teamShares": []map[string]any{{"teamId": ids.teamB}}}, "必须包含这条报名的主单位"}, + {"单位重复", map[string]any{"teamShares": []map[string]any{ + {"teamId": ids.teamA}, {"teamId": ids.teamA}}}, "出现了两次"}, + {"权重为负", map[string]any{"teamShares": []map[string]any{ + {"teamId": ids.teamA, "weight": -1}}}, "不能为负数"}, + {"单位不存在", map[string]any{"teamShares": []map[string]any{ + {"teamId": ids.teamA}, {"teamId": 999999}}}, "不存在或已删除"}, + } + for _, tc := range cases { + t.Run(tc.name, func(t *testing.T) { + status, resp := env.do(client, http.MethodPut, path, tc.body, true) + if status != http.StatusBadRequest { + t.Fatalf("应 400，得到 %d %+v", status, resp) + } + if resp.Error == nil || !strings.Contains(resp.Error.Message, tc.want) { + t.Fatalf("报错应含 %q，得到 %+v", tc.want, resp.Error) + } + // 拦下就不能落库：份额表必须一个字节都没动。 + if got := tableDump(t, env, `SELECT team_id, points_share FROM entry_team_shares ORDER BY team_id`); got != baseline { + t.Fatalf("被拒的请求改动了份额表：\n之前 %s之后 %s", baseline, got) + } + }) + } +} + +// 报名表里非法写法的联队：拦下这一行并给出照得着改的报错，其余行照常导入。 +func TestImportJointTeamRejectsBadForms(t *testing.T) { + cases := []struct { + name string + teamCode string + want string + }{ + {"成员单位不存在", "A+ZZ", "单位 ZZ 不存在（来自联队编码 A+ZZ）"}, + {"加号后面缺一段", "A+", "里有一段是空的"}, + {"加号前面缺一段", "+B", "里有一段是空的"}, + {"同一个单位写两遍", "A+A", "同一个单位出现了两次"}, + {"成员太多", "A+B+C+D+E+F", "一个联队最多 5 个单位"}, + } + for _, tc := range cases { + t.Run(tc.name, func(t *testing.T) { + env, ids, client := recorderWithSeed(t) + eventID, _ := seedMatchEvent(t, env, ids) + + // 前面一行是正常的单单位报名：它必须照常导入（坏行不能拖垮整张表）。 + status, resp := importCSV(t, env, client, + jointImportRow("BALL", "男子", "A"), + jointImportRow("BALL", "男子", tc.teamCode), + ) + if status != http.StatusOK || !resp.OK { + t.Fatalf("导入端点应 200（逐行报错），得到 %d %+v", status, resp.Error) + } + result := decodeData[map[string]any](t, resp) + if result["created"].(float64) != 1 || result["skipped"].(float64) != 1 { + t.Fatalf("应 1 条成功 1 条跳过，得到 %+v", result) + } + errs, _ := result["errors"].([]any) + if len(errs) != 1 || !strings.Contains(fmt.Sprint(errs[0]), tc.want) { + t.Fatalf("第 2 行的报错应含 %q，得到 %+v", tc.want, errs) + } + if n := countRows(t, env, `SELECT COUNT(*) FROM entries WHERE event_id = ?`, eventID); n != 1 { + t.Fatalf("坏行不该落库，报名数 = %d（明细：\n%s）", n, sharesDump(t, env, eventID)) + } + // 成功那行必须是「主单位独占」一条：坏行的解析结果不能污染它。 + entryID := firstEntryID(t, env, eventID) + want := shareRow(entryID, 0, ids.teamA, ids.teamA, 1, 1, 0) + if got := sharesDump(t, env, eventID); got != want { + t.Fatalf("正常行应只挂主单位一条份额：\n得到 %s期望 %s", got, want) + } + }) + } +} + +// 全角加号与两侧空格照样认（现场用中文输入法填表，打出来的常是全角）。 +func TestImportJointTeamAcceptsFullWidthPlus(t *testing.T) { + env, ids, client := recorderWithSeed(t) + eventID, _ := seedMatchEvent(t, env, ids) + if status, resp := importCSV(t, env, client, jointImportRow("BALL", "男子", "A ＋ B")); status != http.StatusOK { + t.Fatalf("导入应 200，得到 %d %+v", status, resp.Error) + } + entryID := firstEntryID(t, env, eventID) + want := shareRow(entryID, 0, ids.teamA, ids.teamA, 1, 1, 0) + + shareRow(entryID, 0, ids.teamA, ids.teamB, 1, 1, 1) + if got := sharesDump(t, env, eventID); got != want { + t.Fatalf("全角加号应解析成同一个联队：\n得到 %s期望 %s", got, want) + } +} + +// 联队改回单单位（或换成员单位）时份额必须跟着变：只增不改会把旧配置一直用下去。 +func TestImportJointTeamResetsSharesOnReimport(t *testing.T) { + env, ids, client := recorderWithSeed(t) + eventID, _ := seedMatchEvent(t, env, ids) + if status, resp := importCSV(t, env, client, jointImportRow("BALL", "男子", "A+B")); status != http.StatusOK { + t.Fatalf("导入联队报名应 200，得到 %d %+v", status, resp.Error) + } + status, resp := importCSV(t, env, client, jointImportRow("BALL", "男子", "A")) + if status != http.StatusOK || !resp.OK { + t.Fatalf("重传单单位应 200，得到 %d %+v", status, resp.Error) + } + if result := decodeData[map[string]any](t, resp); result["updated"].(float64) != 1 { + t.Fatalf("应更新同一行，得到 %+v", result) + } + entryID := firstEntryID(t, env, eventID) + want := shareRow(entryID, 0, ids.teamA, ids.teamA, 1, 1, 0) + if got := sharesDump(t, env, eventID); got != want { + t.Fatalf("改回单单位后份额应只剩主单位一条：\n得到 %s期望 %s", got, want) + } +} + +// 单个单位的报名照旧：库里写一条「主单位独占 100%」，读接口也下发一条，前端不必分支。 +func TestSingleUnitEntryKeepsWholeShare(t *testing.T) { + env, ids, client := recorderWithSeed(t) + eventID, categoryID := seedMatchEvent(t, env, ids) + if status, resp := importCSV(t, env, client, jointImportRow("BALL", "男子", "A")); status != http.StatusOK { + t.Fatalf("导入应 200，得到 %d %+v", status, resp.Error) + } + entryID := firstEntryID(t, env, eventID) + want := shareRow(entryID, 0, ids.teamA, ids.teamA, 1, 1, 0) + if got := sharesDump(t, env, eventID); got != want { + t.Fatalf("单单位报名应写一条独占份额：\n得到 %s期望 %s", got, want) + } + + board := getEntryBoard(t, env, client, eventID) + if len(board.Entries) != 1 { + t.Fatalf("应有一条报名，得到 %+v", board.Entries) + } + shares, _ := board.Entries[0]["teamShares"].([]any) + if len(shares) != 1 { + t.Fatalf("读接口应下发一条份额（普通报名也一样），得到 %+v", board.Entries[0]["teamShares"]) + } + share, _ := shares[0].(map[string]any) + if share["teamId"] != float64(ids.teamA) || share["weight"] != float64(1) || share["teamCode"] != "A" { + t.Fatalf("份额读数应为 {teamId:A, weight:1, teamCode:A}，得到 %+v", share) + } + + // 独占口径下名次与积分照旧：第 1 名 15 分全给 A，B 一分没有。 + if status, resp := putTeamRanks(t, env, client, eventID, categoryID, []map[string]any{ + {"teamId": ids.teamA, "rank": 1}, + }); status != http.StatusOK { + t.Fatalf("录团体名次应 200，得到 %d %+v", status, resp.Error) + } + assertStanding(t, env, client, ids.teamA, 15, 1, 0, 0) + assertStanding(t, env, client, ids.teamB, 0, 0, 0, 0) +} + +// 人员匹配可能把报名改挂到库里那条档案的单位（keep-existing 的既有口径「报名跟随库里已有的单位」）： +// 份额必须跟着**最终主单位**走。跟不上的话就会出现「报名挂在 A 名下、分却记给了表格里写的 B」—— +// 现场看不出来，但榜单直接是错的。 +func TestImportSharesFollowMatchedUnit(t *testing.T) { + env, ids, client := recorderWithSeed(t) + env.exec(t, `UPDATE athletes SET id_card = '110101199001011234', bib = 'A100' WHERE id = ?`, ids.athleteA) + + // 表里写 B，库里这个人的单位是 A，用户选 keep-existing → 报名仍挂在 A。 + body := importHeader + "\nM100,男子,B,张伟,110101199001011234,男,,A100,,registered,\n" + decisions := `[{"idCard":"110101199001011234","action":"keep-existing"}]` + status, resp := env.postImport(t, client, "/api/entries/import/resolve", body, decisions) + if status != http.StatusOK || !resp.OK { + t.Fatalf("决策导入应 200，得到 %d %+v", status, resp.Error) + } + + want := shareRow(ids.entryA, ids.athleteA, ids.teamA, ids.teamA, 1, 1, 0) + + shareAbsentRow(ids.entryB, ids.athB, ids.teamB) + if got := sharesDump(t, env, ids.event); got != want { + t.Fatalf("份额应跟随最终主单位 A：\n得到 %s期望 %s", got, want) + } + + // 榜单上分也只能记给 A：报名挂在 A 名下，B 一分没有。 + publishResults(t, env, client, ids.event, "shares-follow-matched-unit", + map[string]any{"entryId": ids.entryA, "resultValue": 11.2, "resultText": "11.2", "unit": "秒", "status": "ok"}) + assertStanding(t, env, client, ids.teamA, 10, 1, 0, 0) + assertStanding(t, env, client, ids.teamB, 0, 0, 0, 0) +} diff --git a/server/internal/httpapi/handlers_config.go b/server/internal/httpapi/handlers_config.go index b9aefbf..82d68af 100644 --- a/server/internal/httpapi/handlers_config.go +++ b/server/internal/httpapi/handlers_config.go @@ -1291,19 +1291,16 @@ func (s *server) importEntriesWith(ctx context.Context, sheets []importSheet, de continue } } - teamID, err := s.lookupID(ctx, `SELECT id FROM teams WHERE code = ?`, teamCode) + // team_code 写 `A+B` 就是联队（devdocs/19）：解析出多个成员单位，第一个是主单位， + // 分与奖牌按份额下发给各单位。成员单位的存在性、复活与报错都在里面， + // 报错文案与单单位口径逐字一致（现场几百份老表的提示格式不该变样）。 + teamIDs, teamShares, err := s.lookupImportTeams(ctx, teamCode) if err != nil { - result.Skipped++ - result.Errors = append(result.Errors, prefix+s.interceptRow(line, "单位 %s 不存在", teamCode)) - continue - } - // 编码查单位时不排除已隐藏的（编码有唯一索引，排除会撞索引或重复建档）， - // 命中就复活他：这一行马上要给他建报名，人却看不见就说不通了。 - if err := s.reviveTeam(ctx, teamID); err != nil { result.Skipped++ result.Errors = append(result.Errors, prefix+s.interceptRow(line, "%s", err.Error())) continue } + teamID := teamIDs[0] if table.scope == nil { if categoryName != "" { categoryID, err = s.lookupID(ctx, `SELECT id FROM event_categories WHERE event_id = ? AND name = ?`, eventID, categoryName) @@ -1427,10 +1424,19 @@ func (s *server) importEntriesWith(ctx context.Context, sheets []importSheet, de teamID = matched.TeamID } + // 份额必须跟着**最终**的主单位走：上面的人员匹配可能把报名改挂到库里那条档案的单位 + // （keep-existing 的既有口径「报名跟随库里已有的单位」）。主单位掉到表格写的成员之外时 + // 整组退回独占，与升级前一致——报名挂在哪个单位，分就记给哪个单位； + // 否则会出现「报名挂在 A 名下、分却记给了表格里写的 B」这种看不见的错。 + if !sharesContainTeam(teamShares, teamID) { + teamShares = nil + } + outcome, err := s.upsertImportedEntry(ctx, entryDTO{ EventID: eventID, CategoryID: categoryID, TeamID: teamID, + TeamShares: teamShares, AthleteID: athleteID, MemberNames: splitNames(cell("member_names")), Bib: nilIfEmpty(bib), diff --git a/server/internal/httpapi/joint_team_template_test.go b/server/internal/httpapi/joint_team_template_test.go new file mode 100644 index 0000000..060317b --- /dev/null +++ b/server/internal/httpapi/joint_team_template_test.go @@ -0,0 +1,101 @@ +package httpapi_test + +import ( + "net/http" + "strings" + "testing" +) + +// 报名模板要让填表人知道联队怎么写（devdocs/19）：单位编码写 `A+B`，加号左边那个是主单位， +// 积分平均分、奖牌两边各记一枚。 +// +// 说明只能挂在「不会变成数据」的载体上：表头行是导入器认模板的锚点（必须留在第 1 行、 +// 12 列一成不变），工作表名是「小项@组别」的范围锚点（也不能多出说明表）， +// 所以这里用**单元格批注**（表头「单位编码」那一格）+ **该列的输入提示**（选中即弹出）。 +func TestEntriesTemplateExplainsJointTeamCode(t *testing.T) { + env, _, client := recorderWithSeed(t) + + for _, lang := range []string{"zh", "en"} { + f, _ := env.fetchTemplate(t, client, lang) + sheets := f.GetSheetList() + if len(sheets) == 0 { + t.Fatalf("lang=%s 模板没有工作表", lang) + } + for _, sheet := range sheets { + comments, err := f.GetComments(sheet) + if err != nil { + t.Fatalf("[%s] 读工作表 %s 的批注: %v", lang, sheet, err) + } + if len(comments) != 1 { + t.Fatalf("[%s] 工作表 %s 应有且仅有 1 条批注（挂在单位编码表头），得到 %d 条", lang, sheet, len(comments)) + } + comment := comments[0] + if comment.Cell != "C1" { + t.Errorf("[%s] 批注应挂在单位编码表头 C1，得到 %s", lang, comment.Cell) + } + if !strings.Contains(comment.Text, "A+B") { + t.Errorf("[%s] 批注没写清联队怎么写：%q", lang, comment.Text) + } + // 批注作者写系统名（与导出件的文档属性同一套），不是构建期注入的内部署名。 + if comment.Author != "赛事积分榜系统" { + t.Errorf("[%s] 批注作者 = %q，期望系统名", lang, comment.Author) + } + + validations, err := f.GetDataValidations(sheet) + if err != nil { + t.Fatalf("[%s] 读工作表 %s 的输入提示: %v", lang, sheet, err) + } + prompt := "" + for _, dv := range validations { + if dv.Sqref != "" && strings.HasPrefix(dv.Sqref, "C2") && dv.Prompt != nil { + prompt = *dv.Prompt + } + } + if !strings.Contains(prompt, "A+B") { + t.Errorf("[%s] 单位编码列的输入提示应写明联队写法，得到 %q", lang, prompt) + } + } + } +} + +// 模板上的中文说明必须与导入的实际行为一致：照说明填 `A+B`，导进来就是一条报名挂两个单位、均分。 +func TestEntriesTemplateJointTeamRowImports(t *testing.T) { + env, ids, client := recorderWithSeed(t) + + f, _ := env.fetchTemplate(t, client, "") + // 范围由表名承担，「项目编码 / 组别」两列留空；单位编码按模板说明写 A+B。 + appendRows(t, f, "100米跑@男子", [][]string{{ + "", "", "A+B", "联队小张", "110101199001011234", "男", "26", "301", "", "1", "registered", "", + }}) + + status, resp := env.uploadEntries(t, client, "报名模板.xlsx", workbookBytes(t, f)) + if status != http.StatusOK || !resp.OK { + t.Fatalf("照模板说明填的联队行应导入成功，得到 %d %+v", status, resp.Error) + } + if result := decodeData[entryImportResultBody](t, resp); len(result.Errors) != 0 { + t.Fatalf("不该有报错行：%v", result.Errors) + } + + // 落库事实：新报名一条、两个单位各占一份（权重 1 = 均分），主单位是加号左边的 A。 + var entryID int64 + if err := env.ev.QueryRow( + `SELECT e.id FROM entries e JOIN athletes a ON a.id = e.athlete_id + WHERE e.event_id = ? AND a.name = '联队小张'`, ids.event).Scan(&entryID); err != nil { + t.Fatalf("查新报名: %v", err) + } + var primary, shares int + if err := env.ev.QueryRow(`SELECT team_id FROM entries WHERE id = ?`, entryID).Scan(&primary); err != nil { + t.Fatalf("查主单位: %v", err) + } + if int64(primary) != ids.teamA { + t.Errorf("主单位应是加号左边的 A（%d），得到 %d", ids.teamA, primary) + } + if err := env.ev.QueryRow( + `SELECT COUNT(*) FROM entry_team_shares WHERE entry_id = ? AND points_share = 1 AND medal_share = 1`, + entryID).Scan(&shares); err != nil { + t.Fatalf("查份额: %v", err) + } + if shares != 2 { + t.Errorf("联队报名的份额行 = %d，期望 2（两个单位各一份、均分、奖牌各整枚）", shares) + } +} diff --git a/server/internal/httpapi/legacy_forms_golden_test.go b/server/internal/httpapi/legacy_forms_golden_test.go new file mode 100644 index 0000000..0578a17 --- /dev/null +++ b/server/internal/httpapi/legacy_forms_golden_test.go @@ -0,0 +1,150 @@ +package httpapi_test + +import ( + "crypto/sha256" + "encoding/hex" + "fmt" + "net/http" + "strings" + "testing" +) + +// 本文件是联队改动（devdocs/19）的「老数据零变化」硬门槛在**接口层**的一半： +// 四种形态（普通个人 / 纯团体 / 双计 / 团体报名项双通道）走真实的导入 · 发布 · 录名次接口， +// 再把积分榜、个人榜、报名 / 成绩 / 流水 / 通道名次四张表的原始内容拼成一份签名。 +// +// 签名取自**联队实现之前**的代码（git archive HEAD 的修前副本上跑出来的），实现之后必须一字不差。 +// +// 为什么特意**不含** GET /api/events/{id}/entries：那条读接口这次有意新增了 teamShares 字段 +// （联队的成员单位与权重，前端据此渲染「A+B联队」），契约变了不该算回归； +// 它由 TestSingleUnitEntryKeepsWholeShare 单独钉住（普通报名下发一条独占份额）。 +const legacyFormsGoldenAPI = "aa6cea376734cfc5f2334551dfa3095f31543babb10e00c2318b5146a8af42d2" + +// TestLegacyFormsAPISnapshotUnchanged 对拍四种形态的榜单与落库事实。 +func TestLegacyFormsAPISnapshotUnchanged(t *testing.T) { + env, ids, client := recorderWithSeed(t) + dump := legacyFormsAPIDump(t, env, client, ids) + + // 防空转：签名里必须真的能看到四种形态的痕迹。少了这几处，对拍就成了「两份空文本相等」。 + if n := strings.Count(dump, `"totalPoints"`); n < 3 { + t.Fatalf("积分榜签名里只有 %d 行（三个单位都该在榜上）：\n%s", n, dump) + } + if !strings.Contains(dump, "t:") || !strings.Contains(dump, "e:") { + t.Fatalf("签名里应同时有「按单位录的名次」与「按报名项的名次」：\n%s", dump) + } + if !strings.Contains(dump, "points=") || !strings.Contains(dump, "subject_key") { + t.Fatalf("签名里应带上流水与通道名次的落库事实：\n%s", dump) + } + + sum := sha256.Sum256([]byte(dump)) + got := hex.EncodeToString(sum[:]) + if got != legacyFormsGoldenAPI { + t.Fatalf("无联队的老数据在榜单 / 流水 / 名次上变了：\n签名 = %s\n期望 = %s", + got, legacyFormsGoldenAPI) + } +} + +// legacyFormsAPIDump 造出四种形态并拼出签名文本。 +func legacyFormsAPIDump(t *testing.T, env *testEnv, client *http.Client, ids seedIDs) string { + t.Helper() + + // 第三个单位：颁奖牌榜上要有「没参加这个项目」的行，才能看出兜底行有没有变化。 + teamC := env.insert(t, `INSERT INTO teams (code, name, short_name, sort_order, active) + VALUES ('C', '第三分公司', '三司', 2, 1)`) + athC := env.insert(t, `INSERT INTO athletes (name, gender, team_id, active) + VALUES ('王芳', '女', ?, 1)`, teamC) + + // 形态 1 · 普通个人：seed 的 M100（individual + 个人成绩通道）。 + env.exec(t, `INSERT INTO entries (event_id, category_id, team_id, athlete_id, status) + VALUES (?, ?, ?, ?, 'registered')`, ids.event, ids.category, teamC, athC) + publishResults(t, env, client, ids.event, "legacy-individual", + map[string]any{"entryId": ids.entryA, "resultValue": 11.2, "resultText": "11.2", "unit": "秒", "status": "ok"}, + map[string]any{"entryId": ids.entryB, "resultValue": 11.5, "resultText": "11.5", "unit": "秒", "status": "ok"}, + map[string]any{"entryId": envEntryID(t, env, ids.event, athC), "resultValue": 12.0, "resultText": "12.0", "unit": "秒", "status": "ok"}, + ) + + // 形态 2 · 纯团体：球类（match）+ 按单位录的团体名次。 + ballEvent, ballCategory := seedMatchEvent(t, env, ids) + if status, resp := putTeamRanks(t, env, client, ballEvent, ballCategory, []map[string]any{ + {"teamId": ids.teamA, "rank": 1}, + {"teamId": ids.teamB, "rank": 2}, + {"teamId": teamC, "rank": 2}, + }); status != http.StatusOK { + t.Fatalf("录团体名次应 200，得到 %d %+v", status, resp.Error) + } + + // 形态 3 · 双计：个人成绩通道（不计入单位总分）+ 团体聚合通道。 + mixEvent := env.insert(t, `INSERT INTO events (sport_id, code, name, event_type, result_mode, result_type, + compare, scored, multiplier, status) + VALUES (?, 'MIX2', '团体引体向上', 'individual_team', 'auto', 'count', 'desc', 1, 1, 'ongoing')`, ids.sport) + mixCategory := env.insert(t, `INSERT INTO event_categories (event_id, name, multiplier, sort_order) + VALUES (?, '男子', 1, 0)`, mixEvent) + env.exec(t, `INSERT INTO event_score_channels (event_id, scope, basis, profile_id, sort_order, count_to_team) + VALUES (?, 'athlete', 'result', ?, 0, 0)`, mixEvent, profileIDByCode(t, env, "individual_top6")) + env.exec(t, `INSERT INTO event_score_channels (event_id, scope, basis, profile_id, sort_order) + VALUES (?, 'team', 'aggregate', ?, 1)`, mixEvent, profileIDByCode(t, env, "team_top6")) + mixRows := make([]map[string]any, 0, 3) + for i, athleteID := range []int64{ids.athleteA, ids.athB, athC} { + entryID := env.insert(t, `INSERT INTO entries (event_id, category_id, team_id, athlete_id, status) + VALUES (?, ?, ?, ?, 'registered')`, mixEvent, mixCategory, []int64{ids.teamA, ids.teamB, teamC}[i], athleteID) + mixRows = append(mixRows, map[string]any{ + "entryId": entryID, "resultValue": 10 + i, "resultText": fmt.Sprint(10 + i), "unit": "次", "status": "ok", + }) + } + publishResults(t, env, client, mixEvent, "legacy-individual-team", mixRows...) + + // 形态 4 · 团体报名项双通道：团体报名项（athlete_id 为空）+ 个人成绩通道 + 团体手工通道。 + dualEvent := env.insert(t, `INSERT INTO events (sport_id, code, name, event_type, result_mode, result_type, + compare, scored, multiplier, status) + VALUES (?, 'DUAL', '混合配置试验', 'team', 'auto', 'count', 'desc', 1, 1, 'ongoing')`, ids.sport) + dualCategory := env.insert(t, `INSERT INTO event_categories (event_id, name, multiplier, sort_order) + VALUES (?, '男子', 1, 0)`, dualEvent) + env.exec(t, `INSERT INTO event_score_channels (event_id, scope, basis, profile_id, sort_order) + VALUES (?, 'athlete', 'result', ?, 0)`, dualEvent, profileIDByCode(t, env, "individual_top6")) + env.exec(t, `INSERT INTO event_score_channels (event_id, scope, basis, profile_id, sort_order) + VALUES (?, 'team', 'manual', ?, 1)`, dualEvent, profileIDByCode(t, env, "team_top6")) + dualRows := make([]map[string]any, 0, 3) + for i, teamID := range []int64{ids.teamA, ids.teamB, teamC} { + entryID := env.insert(t, `INSERT INTO entries (event_id, category_id, team_id, athlete_id, status) + VALUES (?, ?, ?, NULL, 'registered')`, dualEvent, dualCategory, teamID) + dualRows = append(dualRows, map[string]any{ + "entryId": entryID, "resultValue": 90 - 10*i, "resultText": fmt.Sprint(90 - 10*i), "unit": "次", "status": "ok", + }) + } + publishResults(t, env, client, dualEvent, "legacy-dual", dualRows...) + // 团体名次按单位录（覆盖值优先于报名项自己的名次）：这一支产出的名次没有报名项， + // subject_key 是「单位」，正是这次改动碰过的地方。 + if status, resp := putTeamRanks(t, env, client, dualEvent, dualCategory, []map[string]any{ + {"teamId": ids.teamA, "rank": 2}, + {"teamId": ids.teamB, "rank": 1}, + {"teamId": teamC, "rank": 3}, + }); status != http.StatusOK { + t.Fatalf("录团体名次应 200，得到 %d %+v", status, resp.Error) + } + + return strings.Join([]string{ + rawData(t, env, client, "/api/standings"), + rawData(t, env, client, "/api/standings/athletes"), + tableDump(t, env, `SELECT id, event_id, category_id, team_id, COALESCE(athlete_id, 0) AS athlete_id, status + FROM entries ORDER BY id`), + tableDump(t, env, `SELECT id, event_id, entry_id, COALESCE(rank, 0) AS rank, COALESCE(result_value, 0) AS value, + status, state FROM results ORDER BY id`), + tableDump(t, env, `SELECT id, team_id, COALESCE(athlete_id, 0) AS athlete_id, COALESCE(event_id, 0) AS event_id, + COALESCE(entry_id, 0) AS entry_id, source_type, source_id, points, count_to_team, voided + FROM score_ledger ORDER BY id`), + tableDump(t, env, `SELECT id, event_id, category_id, channel_id, basis, scope, subject_key, + COALESCE(entry_id, 0) AS entry_id, COALESCE(team_id, 0) AS team_id, rank, points + FROM channel_ranks ORDER BY id`), + }, "\n---\n") + "\n" +} + +// envEntryID 取某小项里某运动员的报名项 id。 +func envEntryID(t *testing.T, env *testEnv, eventID, athleteID int64) int64 { + t.Helper() + var id int64 + if err := env.ev.QueryRow( + `SELECT id FROM entries WHERE event_id = ? AND athlete_id = ?`, eventID, athleteID).Scan(&id); err != nil { + t.Fatalf("读报名项: %v", err) + } + return id +} diff --git a/server/internal/httpapi/payload.go b/server/internal/httpapi/payload.go index b60b01f..f54f0c4 100644 --- a/server/internal/httpapi/payload.go +++ b/server/internal/httpapi/payload.go @@ -45,6 +45,14 @@ type entryHeatPayload struct { RequestID string `json:"requestId"` } +// entryTeamSharesPayload 是 PUT /api/entries/{id}/team-shares 的请求体：整组替换一条报名的份额。 +// 不传重量字段（weight 缺省 1）就是均分；medal 缺省 true = 这枚奖牌整枚记给该单位。 +// 必须包含主单位（entries.team_id），且每个单位只能出现一次——校验见 validateEntryShares。 +type entryTeamSharesPayload struct { + TeamShares []entryTeamShareDTO `json:"teamShares"` + RequestID string `json:"requestId"` +} + // entryBatchPayload 是报名项批量操作的请求体： // action 决定语义（scratch 退赛可恢复 / restore 恢复 / remove 物理移出报名）， // ids 是勾选的报名项（重复会自动去重），reason 可选、只进审计便于事后对账。 diff --git a/server/internal/httpapi/repo_events.go b/server/internal/httpapi/repo_events.go index 3be3356..b2b99b2 100644 --- a/server/internal/httpapi/repo_events.go +++ b/server/internal/httpapi/repo_events.go @@ -832,7 +832,18 @@ func (s *server) listEntries(ctx context.Context, eventID int64) ([]entryDTO, er } out = append(out, e) } - return out, rows.Err() + if err := rows.Err(); err != nil { + return nil, err + } + // 份额单独查一次再挂上：一个报名可能有多条（联队），join 进上面那条 SQL 会把报名行乘开。 + shares, err := s.loadEntrySharesDTOs(ctx, s.ev, eventID) + if err != nil { + return nil, err + } + for i := range out { + out[i].TeamShares = entrySharesOf(shares[out[i].ID], out[i].TeamID, out[i].TeamCode, out[i].TeamName) + } + return out, nil } // listEntriesWithResults 返回报名项及其成绩（无成绩时 result=null）。 diff --git a/server/internal/httpapi/repo_import.go b/server/internal/httpapi/repo_import.go index 22014de..be5b02f 100644 --- a/server/internal/httpapi/repo_import.go +++ b/server/internal/httpapi/repo_import.go @@ -674,11 +674,19 @@ func (s *server) upsertImportedEntry(ctx context.Context, in entryDTO) (entryImp if err != nil { return entryImportOutcome{}, err } - if _, err := s.ev.ExecContext(ctx, + res, err := s.ev.ExecContext(ctx, `INSERT INTO entries (event_id, category_id, team_id, athlete_id, member_names, bib, seed, heat, status) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`, in.EventID, in.CategoryID, in.TeamID, nullI64(in.AthleteID), marshalNames(in.MemberNames), - nullStr(in.Bib), nullStr(in.Seed), nullI64(in.Heat), status); err != nil { + nullStr(in.Bib), nullStr(in.Seed), nullI64(in.Heat), status) + if err != nil { + return entryImportOutcome{}, err + } + newID, err := res.LastInsertId() + if err != nil { + return entryImportOutcome{}, internal(err) + } + if err := replaceEntryShares(ctx, s.ev, newID, in.TeamID, in.TeamShares); err != nil { return entryImportOutcome{}, err } outcome := entryImportOutcome{Created: true, EventID: in.EventID, CategoryID: in.CategoryID} @@ -705,6 +713,11 @@ func (s *server) upsertImportedEntry(ctx context.Context, in entryDTO) (entryImp status, existing); err != nil { return entryImportOutcome{}, err } + // 份额整组重写：同一行重传要幂等，改了写法（联队改回单单位、换成员）也要跟着变， + // 只增不改会把上一次的配置一直用下去（见 replaceEntryShares）。 + if err := replaceEntryShares(ctx, s.ev, existing, in.TeamID, in.TeamShares); err != nil { + return entryImportOutcome{}, err + } return entryImportOutcome{ EventID: in.EventID, CategoryID: in.CategoryID, diff --git a/server/internal/httpapi/repo_misc.go b/server/internal/httpapi/repo_misc.go index 0c59513..36978bb 100644 --- a/server/internal/httpapi/repo_misc.go +++ b/server/internal/httpapi/repo_misc.go @@ -619,17 +619,26 @@ func (s *server) buildRanked(ctx context.Context, q queryer) ([]domain.RankedRes v := value.Float64 rr.ResultValue = &v } - // 归属份额沿用「主单位独占 100%」：team_id 为空（理论上不会）时不造份额， - // 免得给 0 号单位凭空记牌，与 domain 的 wholeShare 一致。 - if rr.TeamID != 0 { - rr.Shares = []domain.TeamShare{{TeamID: rr.TeamID, Weight: 1}} - } rr.AwardMedals = awardMedals != 0 rr.CountToMedals = countToMedals != 0 rr.CountToTeamMedals = countToTeamMedals != 0 out = append(out, rr) } - return out, rows.Err() + if err := rows.Err(); err != nil { + return nil, err + } + // 归属份额按报名项的配置补：channel_ranks 只存名次与主体（entry_id 有外键、可回查）， + // 份额是报名项上的配置，引擎与榜单两边都必须从同一处读—— + // 没有报名项的名次（聚合 / 团体手工）与没配份额的老数据都退回「主单位独占 100%」， + // 与 domain.ResolveShares 同一口径（老数据因此一分一牌都不变）。 + shares, err := loadEntryTeamSharesQ(ctx, q, 0) + if err != nil { + return nil, err + } + for i := range out { + out[i].Shares = domain.ResolveShares(shares[out[i].EntryID], out[i].TeamID) + } + return out, nil } // breakdownRankExpr 取一条单位流水的名次（devdocs 17 §11.3）：优先按流水对应的通道与主体 diff --git a/server/internal/httpapi/scoring.go b/server/internal/httpapi/scoring.go index c48fe32..0326ae1 100644 --- a/server/internal/httpapi/scoring.go +++ b/server/internal/httpapi/scoring.go @@ -236,7 +236,18 @@ func loadEntriesQ(ctx context.Context, q queryer, eventID, categoryID int64) ([] e.MemberNames = parseNames(memberNames) out = append(out, e) } - return out, rows.Err() + if err := rows.Err(); err != nil { + return nil, err + } + // 联队份额随报名一起进引擎：引擎不看库，取分只认 Entry.TeamShares。 + shares, err := loadEntryTeamSharesQ(ctx, q, eventID) + if err != nil { + return nil, err + } + for i := range out { + out[i].TeamShares = shares[out[i].ID] + } + return out, nil } func loadResultsQ(ctx context.Context, q queryer, eventID, categoryID int64) ([]domain.Result, error) { @@ -503,7 +514,8 @@ func hasSubjectChannel(ctx context.Context, tx *sql.Tx, eventID int64) (bool, er // 结算范围与流水一致：categoryID > 0 只重建该组别，否则重建整个小项。 // SubjectKey 是 (通道, 组别, 主体) 的唯一键，聚合与团体手工名次没有报名项，靠它落库。 // AwardMedals / CountToMedals / CountToTeamMedals 是读取侧 join events / event_score_channels -// 得到的，不落这张表；shares 不进表（当前只有「主单位独占 100%」一种口径，读取侧按 team_id 重建）。 +// 得到的，不落这张表；shares 同样不进表——读取侧按 entry_id 回查报名份额（entry_team_shares）， +// 回查不到（没有报名项的名次、没配份额的老数据）与引擎一样退回「主单位独占 100%」。 func writeChannelRanksTx(ctx context.Context, tx *sql.Tx, score domain.EventScore, eventID, categoryID int64) error { if categoryID > 0 { if _, err := tx.ExecContext(ctx, diff --git a/server/internal/httpapi/server.go b/server/internal/httpapi/server.go index 9ef2d13..2ee8fcc 100644 --- a/server/internal/httpapi/server.go +++ b/server/internal/httpapi/server.go @@ -276,6 +276,9 @@ func (s *server) routes(mux *http.ServeMux) { // 报名项批量操作：退赛（scratched，可恢复）/ 恢复 / 移出报名（物理删除，不可恢复）。 // 权限与发布同档（recorder），不新增角色；跨小项混选允许，服务端按 (小项, 组别) 分组重算。 mux.HandleFunc("POST /api/entries/batch", s.write(auth.RoleRecorder, s.batchEntriesHandler)) + // 联队份额（devdocs/19）：改一条报名的成员单位与权重，改完当场重算并推榜。 + // 与其它报名写入同档权限（recorder）：它改的是报名，权限不该比报名导入更宽。 + mux.HandleFunc("PUT /api/entries/{id}/team-shares", s.write(auth.RoleRecorder, s.updateEntryTeamSharesHandler)) // 成绩 mux.HandleFunc("GET /api/results", s.public(s.listResultsHandler)) diff --git a/server/internal/realtime/snapshot.go b/server/internal/realtime/snapshot.go index 1b38bf9..ce6d333 100644 --- a/server/internal/realtime/snapshot.go +++ b/server/internal/realtime/snapshot.go @@ -330,15 +330,64 @@ func loadRanked(ctx context.Context, tx *sql.Tx) ([]domain.RankedResult, error) v := value.Float64 rr.ResultValue = &v } - // 与 REST 同口径：份额只有「主单位独占 100%」一种，team_id 为空时不造份额。 - if rr.TeamID != 0 { - rr.Shares = []domain.TeamShare{{TeamID: rr.TeamID, Weight: 1}} - } rr.AwardMedals = awardMedals != 0 rr.CountToMedals = countToMedals != 0 rr.CountToTeamMedals = countToTeamMedals != 0 out = append(out, rr) } + if err := rows.Err(); err != nil { + return nil, err + } + // 与 REST 的 buildRanked、导出的 loadRanked 同口径：联队份额按报名项配置补， + // 没有报名项的名次与没配份额的老数据退回「主单位独占 100%」。 + // 大屏的奖牌榜读的就是这里——少补这一趟，联队的名次在大屏上只记给主单位。 + shares, err := loadEntryTeamShares(ctx, tx) + if err != nil { + return nil, err + } + for i := range out { + out[i].Shares = domain.ResolveShares(shares[out[i].EntryID], out[i].TeamID) + } + return out, nil +} + +// loadEntryTeamShares 读全部报名的份额（联队配置），按 entry_id 归组。 +// +// 表不在（库还没跑到 0024）时返回空：没有份额表就没有联队配置，主单位独占 100% 正是老库 +// 本来就该得到的结果，不是容错降级（见 httpapi.entryTeamSharesReady）。 +func loadEntryTeamShares(ctx context.Context, tx *sql.Tx) (map[int64][]domain.TeamShare, error) { + var n int + if err := tx.QueryRowContext(ctx, + `SELECT COUNT(*) FROM sqlite_master WHERE type = 'table' AND name = 'entry_team_shares'`).Scan(&n); err != nil { + return nil, fmt.Errorf("查询报名份额表: %w", err) + } + if n == 0 { + return nil, nil + } + rows, err := tx.QueryContext(ctx, `SELECT entry_id, team_id, points_share, medal_share + FROM entry_team_shares + ORDER BY entry_id, sort_order, team_id`) + if err != nil { + return nil, fmt.Errorf("读取报名份额: %w", err) + } + defer func() { _ = rows.Close() }() + + out := make(map[int64][]domain.TeamShare) + for rows.Next() { + var ( + entryID int64 + s domain.TeamShare + medal int + ) + if err := rows.Scan(&entryID, &s.TeamID, &s.Weight, &medal); err != nil { + return nil, fmt.Errorf("扫描报名份额: %w", err) + } + if medal == 0 { + excluded := false + s.Medal = &excluded + } + out[entryID] = append(out[entryID], s) + } return out, rows.Err() } diff --git a/server/internal/realtime/snapshot_joint_team_test.go b/server/internal/realtime/snapshot_joint_team_test.go new file mode 100644 index 0000000..100dc8c --- /dev/null +++ b/server/internal/realtime/snapshot_joint_team_test.go @@ -0,0 +1,48 @@ +package realtime + +import ( + "context" + "fmt" + "testing" +) + +// 大屏（WS 快照）是联队奖牌的第三条读路径（另有 REST 与 xlsx 导出）。 +// 它读 channel_ranks 之后要按报名项的份额补归属，少了这一步，联队拿到的金牌在大屏上 +// 只会记给主单位，B 单位明明一起拿了金牌却榜上无名。 +// +// 这里造一条「联队报名 + 团体名次」的最小现场：报名挂在 A 头上、份额是 A+B， +// 名次 1（金牌）落在这条报名上，断言两个单位各记 1 枚。 +func TestSnapshotJointTeamMedalsGoToEveryMember(t *testing.T) { + env := newTestEnv(t) + db := env.db + + teamA := insertTeam(t, db, "A", "第一分公司", "一司") + teamB := insertTeam(t, db, "B", "第二分公司", "二司") + eventID := insertEvent(t, db, "BALL", "篮球") + categoryID := insertCategory(t, db, eventID, "男子") + entryID := insertEntry(t, db, eventID, categoryID, teamA, 0) + channelID := insertChannel(t, db, eventID, "team") + mustExec(t, db, `INSERT INTO channel_ranks (event_id, category_id, channel_id, basis, scope, subject_key, + entry_id, team_id, rank, points, status) + VALUES (?, ?, ?, 'manual', 'team', ?, ?, ?, 1, 0, 'ok')`, + eventID, categoryID, channelID, fmt.Sprintf("e:%d", entryID), entryID, teamA) + // 联队份额：A、B 均分、奖牌各记整枚（写侧就是这么落的，见 entry_team_shares 的迁移与 httpapi）。 + mustExec(t, db, `INSERT INTO entry_team_shares (entry_id, team_id, points_share, medal_share, sort_order) + VALUES (?, ?, 1, 1, 0), (?, ?, 1, 1, 1)`, entryID, teamA, entryID, teamB) + + snap, err := env.hub.Snapshot(context.Background()) + if err != nil { + t.Fatalf("构建快照: %v", err) + } + gold := make(map[int64]int, len(snap.Standings)) + for _, row := range snap.Standings { + gold[row.TeamID] = row.Gold + } + if gold[teamA] != 1 { + t.Fatalf("主单位 A 应记 1 枚金牌，得到 %d（完整：%+v）", gold[teamA], snap.Standings) + } + if gold[teamB] != 1 { + t.Fatalf("成员单位 B 也应记 1 枚金牌（不是 0.5 枚、也不是 0 枚），得到 %d（完整：%+v）", + gold[teamB], snap.Standings) + } +} diff --git a/server/migrations/event/0024_entry_team_shares.sql b/server/migrations/event/0024_entry_team_shares.sql new file mode 100644 index 0000000..50db085 --- /dev/null +++ b/server/migrations/event/0024_entry_team_shares.sql @@ -0,0 +1,37 @@ +-- 联队 + 份额分成（devdocs/19 的实现）。 +-- +-- 背景：现场有两个单位因参赛人数不足合并成一个单位参赛。不能新建「联队单位」——榜单会多出 +-- 一个单位，而且联队拿到的分与奖牌分不到 A、B 头上。所以把「一条报名归哪些单位、各占多少」 +-- 单独放一张表，entries.team_id 保留为**主单位**（既有查询、唯一键、榜单、导入都还认它）。 +-- +-- 两个口径必须分开表达（devdocs/19 第三节的拍板结果）： +-- points_share：积分份额，可配、默认均分。引擎按权重之和归一（1+1 就是各一半）， +-- 奇数分允许拆出小数（团体第 1 名 15 分 → 两个单位各 7.5 分）。 +-- medal_share ：奖牌是否**整枚**记给本单位。联队拿到的金牌两个单位各记 1 枚（不是各 0.5 枚）， +-- 所以它只有 0/1 两态，不跟着 points_share 拆成小数枚。 +-- 两个口径用一个数表达的话，7.5 分与「半枚金牌」会被迫绑在一起，奖牌榜立刻就错。 +-- +-- 老数据行为零变化：下面把每条既有报名回填成「主单位独占 100%」（权重 1 = 归一后仍是 100%， +-- medal_share 1 = 整枚），于是引擎、榜单、导出读老库得到的结果与升级前一模一样。 +-- 回填用 INSERT OR IGNORE：重复执行（schema_migrations 少一行被补跑）不会覆盖已经配好的联队份额， +-- 只会给还没有份额的报名补一条独占。 +-- +-- 写在读侧的一处约定：份额表里**没有行**等价于「主单位独占 100%」（domain.ResolveShares）。 +-- 回填让老数据以后者为准，两条路都给同一个结果；写侧永远保持「至少一条」。 + +CREATE TABLE IF NOT EXISTS entry_team_shares ( + entry_id INTEGER NOT NULL REFERENCES entries(id) ON DELETE CASCADE, + team_id INTEGER NOT NULL REFERENCES teams(id), + points_share REAL NOT NULL DEFAULT 1 CHECK (points_share > 0), + medal_share INTEGER NOT NULL DEFAULT 1 CHECK (medal_share IN (0, 1)), + -- 展示与流水顺序都用它：write 侧按请求给的顺序编号，导入按 team_code 里 A+B 的书写顺序。 + -- 主单位建议排第一（榜单与导出据此拼「A+B联队」），但引擎不依赖顺序取分（份额之和归一）。 + sort_order INTEGER NOT NULL DEFAULT 0, + PRIMARY KEY (entry_id, team_id) +); + +-- 不另建 entry_id 索引：主键 (entry_id, team_id) 的索引已经以 entry_id 打头， +-- 读侧的「按报名项批量取份额」走的正是它（多一个索引只会在每次写份额时多付一次代价）。 + +INSERT OR IGNORE INTO entry_team_shares (entry_id, team_id, points_share, medal_share, sort_order) +SELECT id, team_id, 1, 1, 0 FROM entries; diff --git a/server/migrations/event/migration_0024_test.go b/server/migrations/event/migration_0024_test.go new file mode 100644 index 0000000..b054b7c --- /dev/null +++ b/server/migrations/event/migration_0024_test.go @@ -0,0 +1,176 @@ +package event + +import ( + "database/sql" + "fmt" + "strings" + "testing" + + "git.yeij.top/AskaEth/Scoreboard/server/internal/store" +) + +// 0024：联队 + 份额分成（entry_team_shares）。 +// +// 三条底线： +// - 老库升级后每条既有报名都拿到一条「主单位独占 100%」（权重 1、整枚奖牌）， +// 于是引擎与榜单对老数据的行为一分不差； +// - 其它行（尤其是 entries.team_id 这个主单位）一行不动，也没有任何报名被删； +// - 幂等：重复执行（含把这条 SQL 的正文重放一遍）不会覆盖已经配好的联队份额。 +func TestMigration0024EntryTeamShares(t *testing.T) { + db := openEventDB(t) + applyBefore(t, db, "0024") // 回到「升级前」：库结构到 0023 为止 + + stmts := []string{ + `INSERT INTO teams(code, name) VALUES ('A', '第一分公司')`, + `INSERT INTO teams(code, name) VALUES ('B', '第二分公司')`, + `INSERT INTO sports(code, name) VALUES ('SP1', '田径')`, + `INSERT INTO events(sport_id, code, name, event_type, result_mode, result_type, compare, scored, multiplier, status) + VALUES (1, 'BALL', '篮球', 'match', 'manual', 'count', 'none', 1, 1, 'ongoing')`, + `INSERT INTO event_categories(event_id, name, multiplier, sort_order) VALUES (1, '男子', 1, 0)`, + `INSERT INTO athletes(name, gender, team_id) VALUES ('张伟', '男', 1)`, + // 个人报名（athlete_id 非空）与团体报名（athlete_id 为空）都要被回填。 + `INSERT INTO entries(event_id, category_id, team_id, athlete_id, status) VALUES (1, 1, 1, 1, 'registered')`, + `INSERT INTO entries(event_id, category_id, team_id, athlete_id, status) VALUES (1, 1, 2, NULL, 'registered')`, + } + for _, s := range stmts { + if _, err := db.Exec(s); err != nil { + t.Fatalf("造老库数据 %q: %v", s, err) + } + } + + // 升级前：这张表还不该存在。 + if _, err := db.Exec(`SELECT count(*) FROM entry_team_shares`); err == nil { + t.Fatal("升级前不应存在 entry_team_shares 表") + } else if !strings.Contains(err.Error(), "entry_team_shares") { + t.Fatalf("查询报错应点明缺表 entry_team_shares，实际 %v", err) + } + + if err := store.MigrateEvent(db); err != nil { + t.Fatalf("升级赛事库: %v", err) + } + + // 回填：每条报名一条「主单位独占 100%」，主单位就是 entries.team_id。 + rows, err := db.Query(`SELECT e.id, e.team_id, s.team_id, s.points_share, s.medal_share, s.sort_order + FROM entries e JOIN entry_team_shares s ON s.entry_id = e.id + ORDER BY e.id`) + if err != nil { + t.Fatalf("读回填结果: %v", err) + } + defer func() { _ = rows.Close() }() + seen := 0 + for rows.Next() { + var ( + entryID, primary, shareTeam int64 + pointsShare float64 + medalShare, sortOrder int + ) + if err := rows.Scan(&entryID, &primary, &shareTeam, &pointsShare, &medalShare, &sortOrder); err != nil { + t.Fatalf("扫描回填结果: %v", err) + } + if shareTeam != primary { + t.Errorf("报名 %d 回填出来的份额单位 = %d，期望主单位 %d", entryID, shareTeam, primary) + } + if pointsShare != 1 || medalShare != 1 || sortOrder != 0 { + t.Errorf("报名 %d 的独占份额应为 points_share=1 medal_share=1 sort_order=0，得到 %v/%d/%d", + entryID, pointsShare, medalShare, sortOrder) + } + seen++ + } + if err := rows.Err(); err != nil { + t.Fatalf("遍历回填结果: %v", err) + } + if seen != 2 { + t.Fatalf("回填行数 = %d，期望 2（每条既有报名一条）", seen) + } + + // entries 一行不少、主单位一列不改（回填只增一张表）。 + if got := countRows(t, db, "entries"); got != 2 { + t.Fatalf("升级后报名数 = %d，期望 2", got) + } + if got := queryInt(t, db, `SELECT count(*) FROM entries WHERE team_id NOT IN (SELECT id FROM teams)`); got != 0 { + t.Errorf("条目里出现了不存在的单位: %d 条", got) + } + + // 约束：权重必须为正、奖牌份数只有 0/1、同一报名同一单位只能一条。 + if _, err := db.Exec(`INSERT INTO entry_team_shares(entry_id, team_id, points_share) VALUES (1, 2, 0)`); err == nil { + t.Error("points_share = 0 应被 CHECK 拒绝（份额为零等于没写）") + } + if _, err := db.Exec(`INSERT INTO entry_team_shares(entry_id, team_id, medal_share) VALUES (1, 2, 2)`); err == nil { + t.Error("medal_share = 2 应被 CHECK 拒绝（奖牌只有整枚/不记两态）") + } + if _, err := db.Exec(`INSERT INTO entry_team_shares(entry_id, team_id) VALUES (1, 1)`); err == nil { + t.Error("同一报名同一单位重复应被主键拒绝") + } + // 联队：给报名 1 再加一条成员单位 B（这就是升级后写侧要写的东西）。 + if _, err := db.Exec(`INSERT INTO entry_team_shares(entry_id, team_id, points_share, medal_share, sort_order) + VALUES (1, 2, 1, 1, 1)`); err != nil { + t.Fatalf("写联队份额应成功: %v", err) + } + + // 幂等：再跑一次迁移，行数与内容都不变。 + before := dumpShares(t, db) + if err := store.MigrateEvent(db); err != nil { + t.Fatalf("重复升级应无副作用: %v", err) + } + if got := dumpShares(t, db); got != before { + t.Fatalf("重复迁移改动了份额：\n之前 %s\n之后 %s", before, got) + } + + // 迁移被重放（schema_migrations 少一行）时：只补缺的行，绝不覆盖已配好的联队份额。 + if _, err := db.Exec(readMigration(t, "0024")); err != nil { + t.Fatalf("重放 0024: %v", err) + } + if got := dumpShares(t, db); got != before { + t.Fatalf("重放 0024 改动了份额：\n之前 %s\n之后 %s", before, got) + } + + // 报名被删时份额跟着走（ON DELETE CASCADE），不留孤儿。 + if _, err := db.Exec(`DELETE FROM entries WHERE id = 2`); err != nil { + t.Fatalf("删报名: %v", err) + } + if got := queryInt(t, db, `SELECT count(*) FROM entry_team_shares WHERE entry_id = 2`); got != 0 { + t.Errorf("报名删掉后份额应级联清空，还剩 %d 条", got) + } + + // 外键悬挂检查。 + fkRows, err := db.Query(`PRAGMA foreign_key_check`) + if err != nil { + t.Fatalf("外键检查: %v", err) + } + defer func() { _ = fkRows.Close() }() + if fkRows.Next() { + t.Error("迁移后存在外键悬挂") + } + + // 迁移登记数对得上（这条迁移被记账一次）。 + if got, want := countRows(t, db, "schema_migrations"), migrationCount(t); got != want { + t.Errorf("迁移登记数 = %d，期望 %d", got, want) + } +} + +// dumpShares 把份额表按稳定顺序导成文本。 +func dumpShares(t *testing.T, db *sql.DB) string { + t.Helper() + var b strings.Builder + rows, err := db.Query(`SELECT entry_id, team_id, points_share, medal_share, sort_order + FROM entry_team_shares ORDER BY entry_id, team_id`) + if err != nil { + t.Fatalf("读份额: %v", err) + } + defer func() { _ = rows.Close() }() + for rows.Next() { + var ( + entryID, teamID int64 + pointsShare float64 + medalShare, sortOrder int + ) + if err := rows.Scan(&entryID, &teamID, &pointsShare, &medalShare, &sortOrder); err != nil { + t.Fatalf("扫描份额: %v", err) + } + fmt.Fprintf(&b, "%d:%d:%v:%d:%d\n", entryID, teamID, pointsShare, medalShare, sortOrder) + } + if err := rows.Err(); err != nil { + t.Fatalf("遍历份额: %v", err) + } + return b.String() +} diff --git a/web/src/admin/api/scoring.ts b/web/src/admin/api/scoring.ts index 915648a..fc133b4 100644 --- a/web/src/admin/api/scoring.ts +++ b/web/src/admin/api/scoring.ts @@ -1,4 +1,4 @@ -import { normalizeAggregateMode, normalizeAvgMode, normalizeCountToTeam } from '@/shared' +import { normalizeAggregateMode, normalizeAvgMode, normalizeCountToTeam, splitSharePoints } from '@/shared' import type { AvgMode, ChannelBasis, @@ -30,6 +30,13 @@ export interface ScorableRow { rank: number | null status: ResultStatus isTie: boolean + /** + * 归属份额（联队，devdocs/19）；普通报名不传 = 主单位独占 100%。 + * + * 引擎侧按份额把分拆给各成员单位（scoring.go 的 ledgerFromRanked），录入页的实时预览要同口径， + * 否则联队那条会显示成「A +15」，而发布后 A、B 各 +7.5。 + */ + shares?: readonly { teamId: number; weight: number }[] } const EPSILON = 1e-9 @@ -300,17 +307,50 @@ function rankOnlyChannel(event: Event): ScoreChannel { } } +/** 一行折算到某个单位的贡献（联队时一行会有多条）。 */ +export interface RowTeamShare { + teamId: number + points: number +} + export interface EventScoreResult { /** 每行各通道原始分之和（未乘个人→单位系数），用于表格积分列。 */ rowPoints: Map /** 每行折算到单位的贡献（个人通道分 × 系数 + 团体通道分），用于预览差值。 */ rowTeamPoints: Map + /** + * 上一行贡献按份额拆到各成员单位的结果，普通报名只有一条（主单位）。 + * + * 「已发布的分要从单位总分里扣掉」时不能按 `row.teamId` 累加 rowTeamPoints： + * 联队那条的整份分会全记在主单位头上，扣出来的差值在 B 单位那边是错的。 + */ + rowTeamShares: Map /** 每行展示名次；多通道时优先个人通道，与 applyComputedRanks 一致。 */ ranks: Map /** 按单位聚合的得分增量，用于预览面板。 */ teamPoints: Map } +/** + * 把一行的单位贡献拆到各成员单位（scoring.go 的 ledgerFromRanked 同口径）。 + * + * 聚合名次（entryId = 0，主体是单位或运动员）与没有配份额的行一律「主单位独占」： + * 引擎那边聚合并联队不拆份额（名次不对应报名项，读取侧回查不到份额），预览必须同口径， + * 否则会出现「预览按份额拆、发布后整份记给主单位」。 + */ +function rowTeamShares( + entryId: number, + teamId: number, + shares: readonly { teamId: number; weight: number }[] | undefined, + contribution: number, +): RowTeamShare[] { + if (entryId <= 0 || shares === undefined || shares.length < 2) { + return [{ teamId, points: contribution }] + } + const parts = splitSharePoints(contribution, shares) + return shares.map((share, index) => ({ teamId: share.teamId, points: parts[index] ?? 0 })) +} + export interface ScoreContext { event: Event category: EventCategory | null @@ -335,10 +375,16 @@ export function computeEventScore(rows: readonly ScorableRow[], context: ScoreCo const rowPoints = new Map() const rowTeamPoints = new Map() + const rowShares = new Map() const ranks = new Map() const rankScope = new Map() const teamPoints = new Map() + const sharesByEntry = new Map() + for (const row of rows) { + if (row.shares !== undefined && row.shares.length > 0) sharesByEntry.set(row.entryId, row.shares) + } + for (const channel of channels) { const profile = context.profiles.find((item) => item.id === channel.profileId) ?? null // 不计分时不需要积分表，按空模板处理即可（名次仍要算出来）。 @@ -346,11 +392,27 @@ export function computeEventScore(rows: readonly ScorableRow[], context: ScoreCo // countToTeam=false（例如「个人+团体」的个人通道）：分照算，但不进单位总分。 const countToTeam = normalizeCountToTeam(channel.countToTeam) for (const row of ranked) { + // 个人通道的分要按个人→单位系数折算，团体通道的分本来就是单位的分。 + const teamContribution = row.scope === 'athlete' ? row.points * weight : row.points + const parts = countToTeam + ? rowTeamShares(row.entryId, row.teamId, sharesByEntry.get(row.entryId), teamContribution) + : [] if (row.entryId > 0) { rowPoints.set(row.entryId, (rowPoints.get(row.entryId) ?? 0) + row.points) if (countToTeam) { - const teamContribution = row.scope === 'athlete' ? row.points * weight : row.points - rowTeamPoints.set(row.entryId, (rowTeamPoints.get(row.entryId) ?? 0) + teamContribution) + rowTeamPoints.set( + row.entryId, + (rowTeamPoints.get(row.entryId) ?? 0) + teamContribution, + ) + // 多通道叠加时按单位合并，而不是按下标对齐：渠道顺序一变，按下标就会串位。 + const merged = new Map((rowShares.get(row.entryId) ?? []).map((part) => [part.teamId, part.points])) + for (const part of parts) { + merged.set(part.teamId, (merged.get(part.teamId) ?? 0) + part.points) + } + rowShares.set( + row.entryId, + [...merged].map(([teamId, points]) => ({ teamId, points })), + ) } // 名次优先取个人通道；同一优先级下先处理的通道胜出。 const current = rankScope.get(row.entryId) @@ -360,13 +422,14 @@ export function computeEventScore(rows: readonly ScorableRow[], context: ScoreCo } } if (!countToTeam) continue - const teamContribution = row.scope === 'athlete' ? row.points * weight : row.points - teamPoints.set(row.teamId, (teamPoints.get(row.teamId) ?? 0) + teamContribution) + for (const part of parts) { + teamPoints.set(part.teamId, (teamPoints.get(part.teamId) ?? 0) + part.points) + } } } for (const row of rows) { if (!ranks.has(row.entryId)) ranks.set(row.entryId, null) } - return { rowPoints, rowTeamPoints, ranks, teamPoints } + return { rowPoints, rowTeamPoints, rowTeamShares: rowShares, ranks, teamPoints } } diff --git a/web/src/admin/components/baseData/ImportSection.vue b/web/src/admin/components/baseData/ImportSection.vue index 7231c90..c07d5d4 100644 --- a/web/src/admin/components/baseData/ImportSection.vue +++ b/web/src/admin/components/baseData/ImportSection.vue @@ -1,5 +1,6 @@