数据编辑页加「活动与类别」卡片:改名 / 删除 / 新增 / 合并

活动的管理能力其实后端早就有(create/update/delete 三个端点),但入口只藏在
「到访记录」卡片里——要先在下拉里选中某个活动,再点按钮弹 prompt,看不见
「哪些活动一条到访都没挂」(实测有 0 条的活动);类别则完全没有集中入口。

现在页首多了一张卡片(唯一默认展开的),两个表格都带用量:

- 活动:名称行内改、删除(有引用时二次确认并报条数)、新增,
  另有一条「把[A]并到[B]」——改名解决不了「两个名字指同一件事」,
  合并会把到访转过去、把 is_home/is_work 抄成目标的,再删源活动、清它的原始行留档。
- 类别:类别没有独立的表,值就长在 places.poi_category 上,所以「改名 / 清空」
  都是按值批量作用到地点;改成另一个已有值就是合并,不另做按钮。

新增端点:/admin/edit/category/rename、/admin/edit/category/clear、
/admin/edit/activity/merge。编辑页那条 DISTINCT poi_category 查询顺手改成
GROUP BY 带计数,一份数据两用。

顺带修一处会静默失效的写法:新表原来只写了 tb-stack,漏了配对的 tb,
而 CSS 全是 `.tw > table.tb.tb-stack …` ⇒ 一条堆叠规则都没命中,窄屏下表仍是
640px 底宽。横滑是在 .tw 里滚的、页面不溢出,肉眼很难发现,守卫测试也只查
「有没有 tb-stack」——已补上「有 tb-stack 必须有 tb」并做了变异验证。
This commit is contained in:
tamakyi
2026-09-20 09:51:43 +08:00
parent ffee082fad
commit da6fe54ab4
6 changed files with 523 additions and 10 deletions
+137 -4
View File
@@ -131,24 +131,47 @@ func (s *Server) editPage(w http.ResponseWriter, r *http.Request) {
if d.PageNo > d.PageCount { if d.PageNo > d.PageCount {
d.PageNo = d.PageCount d.PageNo = d.PageCount
} }
// 已有类别去重:新建表单和每行编辑的下拉都用它(提交值仍是原始标识符) // 已有类别去重:新建表单、每行编辑的下拉、顶部类别台账都用它(提交值仍是原始标识符);
crows, err := s.db.QueryContext(ctx, `SELECT DISTINCT poi_category FROM places // 顺手带上地点数,台账要按用量排序、也要知道改一下会影响多少行
WHERE dataset_id=$1 AND COALESCE(poi_category,'')<>'' ORDER BY poi_category`, ds.ID) crows, err := s.db.QueryContext(ctx, `SELECT poi_category, count(*) FROM places
WHERE dataset_id=$1 AND COALESCE(poi_category,'')<>'' GROUP BY 1 ORDER BY 1`, ds.ID)
if err != nil { if err != nil {
s.serverError(w, r, err) s.serverError(w, r, err)
return return
} }
for crows.Next() { for crows.Next() {
var c string var c string
if err := crows.Scan(&c); err != nil { var n int
if err := crows.Scan(&c, &n); err != nil {
crows.Close() crows.Close()
s.serverError(w, r, err) s.serverError(w, r, err)
return return
} }
d.Categories = append(d.Categories, EditOption{Label: c, Name: poiCategoryLabel(c)}) d.Categories = append(d.Categories, EditOption{Label: c, Name: poiCategoryLabel(c)})
d.CategoryRows = append(d.CategoryRows, EditCategory{Value: c, Label: poiCategoryLabel(c), Places: n})
} }
crows.Close() crows.Close()
// 活动台账:带上引用到访数,好一眼看出哪些压根没人用
arows, err := s.db.QueryContext(ctx, `SELECT a.id, COALESCE(a.name,''), a.is_home, a.is_work, count(v.id)
FROM activities a LEFT JOIN visits v ON v.activity_id=a.id
WHERE a.dataset_id=$1 GROUP BY a.id, a.name, a.is_home, a.is_work
ORDER BY 5 DESC, a.name`, ds.ID)
if err != nil {
s.serverError(w, r, err)
return
}
for arows.Next() {
var a EditActivity
if err := arows.Scan(&a.ID, &a.Name, &a.IsHome, &a.IsWork, &a.Visits); err != nil {
arows.Close()
s.serverError(w, r, err)
return
}
d.ActivityRows = append(d.ActivityRows, a)
}
arows.Close()
lrows, err := s.db.QueryContext(ctx, fmt.Sprintf(`SELECT p.id, p.src_pk, COALESCE(p.name,''), COALESCE(p.poi_category,''), lrows, err := s.db.QueryContext(ctx, fmt.Sprintf(`SELECT p.id, p.src_pk, COALESCE(p.name,''), COALESCE(p.poi_category,''),
COALESCE(p.province,''), COALESCE(p.city,''), COALESCE(p.district,''), COALESCE(p.thoroughfare,''), COALESCE(p.province,''), COALESCE(p.city,''), COALESCE(p.district,''), COALESCE(p.thoroughfare,''),
COALESCE(p.lat,0), COALESCE(p.lon,0), COALESCE(p.visit_count,0), COALESCE(p.lat,0), COALESCE(p.lon,0), COALESCE(p.visit_count,0),
@@ -617,6 +640,116 @@ func (s *Server) editActivityDelete(w http.ResponseWriter, r *http.Request) {
s.json(w, map[string]any{"ok": true}) s.json(w, map[string]any{"ok": true})
} }
// editCategoryRename 把某个类别整体改名。改成另一个**已经有地点在用**的类别就是合并——
// 两者本来就是同一条 UPDATE,所以不另做「合并」按钮。
func (s *Server) editCategoryRename(w http.ResponseWriter, r *http.Request) {
ctx := r.Context()
ds, err := s.datasetFor(ctx)
if err != nil || ds == nil {
s.json(w, map[string]any{"error": "还没有可编辑的数据集"})
return
}
if err := r.ParseForm(); err != nil {
s.serverError(w, r, err)
return
}
from := strings.TrimSpace(r.PostFormValue("from"))
to := strings.TrimSpace(r.PostFormValue("to"))
if from == "" || to == "" {
s.json(w, map[string]any{"error": "新旧类别都要填;要摘掉类别请用「清空」"})
return
}
if from == to {
s.json(w, map[string]any{"error": "新旧类别一样,没得改"})
return
}
res, err := s.db.ExecContext(ctx, `UPDATE places SET poi_category=$3
WHERE dataset_id=$1 AND poi_category=$2`, ds.ID, from, to)
if err != nil {
s.serverError(w, r, err)
return
}
n, _ := res.RowsAffected()
s.json(w, map[string]any{"ok": true, "places": n, "to": to, "label": poiCategoryLabel(to)})
}
// editCategoryClear 把某个类别从所有地点上摘掉(那些地点退回「未指定」)。
// 类别的值就长在 places.poi_category 上,没有独立的表,所以「删除类别」只能落成这个。
func (s *Server) editCategoryClear(w http.ResponseWriter, r *http.Request) {
ctx := r.Context()
ds, err := s.datasetFor(ctx)
if err != nil || ds == nil {
s.json(w, map[string]any{"error": "还没有可编辑的数据集"})
return
}
if err := r.ParseForm(); err != nil {
s.serverError(w, r, err)
return
}
from := strings.TrimSpace(r.PostFormValue("from"))
if from == "" {
s.json(w, map[string]any{"error": "请选择要清空的类别"})
return
}
res, err := s.db.ExecContext(ctx, `UPDATE places SET poi_category=NULL
WHERE dataset_id=$1 AND poi_category=$2`, ds.ID, from)
if err != nil {
s.serverError(w, r, err)
return
}
n, _ := res.RowsAffected()
s.json(w, map[string]any{"ok": true, "places": n})
}
// editActivityMerge 把 from 的到访全部转到 to 名下,然后删掉 from。
// 改名解决不了「两个名字指同一件事」(「活动」和「散步」这种),只有合并能收敛。
func (s *Server) editActivityMerge(w http.ResponseWriter, r *http.Request) {
ctx := r.Context()
ds, err := s.datasetFor(ctx)
if err != nil || ds == nil {
s.json(w, map[string]any{"error": "还没有可编辑的数据集"})
return
}
if err := r.ParseForm(); err != nil {
s.serverError(w, r, err)
return
}
from, _ := strconv.ParseInt(strings.TrimSpace(r.PostFormValue("from")), 10, 64)
to, _ := strconv.ParseInt(strings.TrimSpace(r.PostFormValue("to")), 10, 64)
if from <= 0 || to <= 0 || from == to {
s.json(w, map[string]any{"error": "请选两个不同的活动"})
return
}
var moved int64
if err := s.withTx(ctx, func(ex execer) error {
// 两端都必须是本数据集的:否则能把别处的到访「拐」过来
var n int
if err := ex.QueryRowContext(ctx, `SELECT count(*) FROM activities
WHERE dataset_id=$1 AND id IN ($2,$3)`, ds.ID, from, to).Scan(&n); err != nil {
return err
}
if n != 2 {
return errors.New("活动不存在")
}
// is_home / is_work 是从活动抄到到访上的冗余标记,跟着目标活动走
isHome, isWork := s.activityFlags(ctx, ex, to)
res, err := ex.ExecContext(ctx, `UPDATE visits SET activity_id=$3, is_home=$4, is_work=$5
WHERE dataset_id=$1 AND activity_id=$2`, ds.ID, from, to, isHome, isWork)
if err != nil {
return err
}
moved, _ = res.RowsAffected()
_, err = ex.ExecContext(ctx, `DELETE FROM activities WHERE id=$1 AND dataset_id=$2`, from, ds.ID)
return err
}); err != nil {
s.json(w, map[string]any{"error": err.Error()})
return
}
s.pruneEntityRaw(ctx, ds.ID)
s.refreshDatasetAgg(ctx, ds.ID)
s.json(w, map[string]any{"ok": true, "visits": moved})
}
// editPlaceCreate 是最前面那个融合表单(新建地点 / 给已有地点补到访)的处理函数。 // editPlaceCreate 是最前面那个融合表单(新建地点 / 给已有地点补到访)的处理函数。
func (s *Server) editPlaceCreate(w http.ResponseWriter, r *http.Request) { func (s *Server) editPlaceCreate(w http.ResponseWriter, r *http.Request) {
ctx := r.Context() ctx := r.Context()
+3
View File
@@ -256,6 +256,9 @@ func (s *Server) routes() {
s.mux.HandleFunc("POST /admin/edit/activity", s.requireAdmin(s.editActivityCreate)) s.mux.HandleFunc("POST /admin/edit/activity", s.requireAdmin(s.editActivityCreate))
s.mux.HandleFunc("POST /admin/edit/activity/update", s.requireAdmin(s.editActivityUpdate)) s.mux.HandleFunc("POST /admin/edit/activity/update", s.requireAdmin(s.editActivityUpdate))
s.mux.HandleFunc("POST /admin/edit/activity/delete", s.requireAdmin(s.editActivityDelete)) s.mux.HandleFunc("POST /admin/edit/activity/delete", s.requireAdmin(s.editActivityDelete))
s.mux.HandleFunc("POST /admin/edit/activity/merge", s.requireAdmin(s.editActivityMerge))
s.mux.HandleFunc("POST /admin/edit/category/rename", s.requireAdmin(s.editCategoryRename))
s.mux.HandleFunc("POST /admin/edit/category/clear", s.requireAdmin(s.editCategoryClear))
// 照片导入:EXIF 由浏览器读(不上传照片),确认后只把元数据提交上来落库 // 照片导入:EXIF 由浏览器读(不上传照片),确认后只把元数据提交上来落库
s.mux.HandleFunc("GET /admin/photos", s.requireAdmin(s.adminPhotosPage)) s.mux.HandleFunc("GET /admin/photos", s.requireAdmin(s.adminPhotosPage))
s.mux.HandleFunc("POST /admin/photos/import", s.requireAdmin(s.adminPhotosImport)) s.mux.HandleFunc("POST /admin/photos/import", s.requireAdmin(s.adminPhotosImport))
+175
View File
@@ -0,0 +1,175 @@
package web
import (
"encoding/json"
"net/http"
"net/http/httptest"
"net/url"
"strings"
"testing"
)
// taxonomyPost 按页面 fetch 的方式调「活动与类别」那几个端点,返回解析后的 JSON。
func taxonomyPost(t *testing.T, f *movementFixture, path string, form url.Values) map[string]any {
t.Helper()
rec := httptest.NewRecorder()
req := httptest.NewRequest(http.MethodPost, path, strings.NewReader(form.Encode()))
req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
ctx := req.WithContext(f.ctx)
switch path {
case "/admin/edit/category/rename":
f.srv.editCategoryRename(rec, ctx)
case "/admin/edit/category/clear":
f.srv.editCategoryClear(rec, ctx)
case "/admin/edit/activity/merge":
f.srv.editActivityMerge(rec, ctx)
default:
t.Fatalf("未接线的端点 %s", path)
}
var out map[string]any
if err := json.Unmarshal(rec.Body.Bytes(), &out); err != nil {
t.Fatalf("%s 返回的不是 JSON: %s", path, rec.Body.String())
}
return out
}
// 类别没有表,「改名」只能是按值批量改地点;填成另一个已有值就是合并。
func TestCategoryRenameMergesIntoExisting(t *testing.T) {
f := newMovementFixture(t)
mk := func(pk int, cat string) {
f.mustExec(t, `INSERT INTO places (dataset_id, src_pk, name, lat, lon, poi_category)
VALUES ($1,$2,'类别测试点',30,120,$3)`, f.dsID, pk, cat)
}
mk(690001, "测试类别甲")
mk(690002, "测试类别甲")
mk(690003, "测试类别乙")
t.Cleanup(func() {
f.pg.ExecContext(f.ctx, `DELETE FROM places WHERE dataset_id=$1 AND src_pk BETWEEN 690001 AND 690003`, f.dsID)
})
got := taxonomyPost(t, f, "/admin/edit/category/rename", url.Values{
"from": {"测试类别甲"}, "to": {"测试类别乙"},
})
if got["places"] != float64(2) {
t.Fatalf("应报告 2 个地点被改,实际 %v", got["places"])
}
if n := f.scalar(t, `SELECT count(*) FROM places WHERE dataset_id=$1 AND poi_category='测试类别乙'
AND src_pk BETWEEN 690001 AND 690003`, f.dsID); n != 3 {
t.Fatalf("甲应整体并进乙(共 3 个),实际 %d 个", n)
}
if n := f.scalar(t, `SELECT count(*) FROM places WHERE dataset_id=$1 AND poi_category='测试类别甲'`, f.dsID); n != 0 {
t.Fatalf("甲应一个不剩,还剩 %d 个", n)
}
}
// 新类别填空不能当成「改名成空」把类别悄悄丢掉——那是「清空」的活,要另走一步。
func TestCategoryRenameRefusesEmptyTarget(t *testing.T) {
f := newMovementFixture(t)
f.mustExec(t, `INSERT INTO places (dataset_id, src_pk, name, lat, lon, poi_category)
VALUES ($1,690011,'类别测试点',30,120,'测试类别丙')`, f.dsID)
t.Cleanup(func() {
f.pg.ExecContext(f.ctx, `DELETE FROM places WHERE dataset_id=$1 AND src_pk=690011`, f.dsID)
})
got := taxonomyPost(t, f, "/admin/edit/category/rename", url.Values{"from": {"测试类别丙"}, "to": {" "}})
if got["error"] == nil {
t.Fatal("新类别为空时应报错")
}
if n := f.scalar(t, `SELECT count(*) FROM places WHERE dataset_id=$1 AND poi_category='测试类别丙'`, f.dsID); n != 1 {
t.Fatalf("报错就不该动数据,实际只剩 %d 个", n)
}
}
// 「清空」= 摘掉类别:那些地点退回未指定(NULL),去重列表里也就不再出现。
func TestCategoryClearDetachesPlaces(t *testing.T) {
f := newMovementFixture(t)
for _, pk := range []int{690021, 690022} {
f.mustExec(t, `INSERT INTO places (dataset_id, src_pk, name, lat, lon, poi_category)
VALUES ($1,$2,'类别测试点',30,120,'测试类别丁')`, f.dsID, pk)
}
t.Cleanup(func() {
f.pg.ExecContext(f.ctx, `DELETE FROM places WHERE dataset_id=$1 AND src_pk BETWEEN 690021 AND 690022`, f.dsID)
})
got := taxonomyPost(t, f, "/admin/edit/category/clear", url.Values{"from": {"测试类别丁"}})
if got["places"] != float64(2) {
t.Fatalf("应报告 2 个地点被摘掉,实际 %v", got["places"])
}
if n := f.scalar(t, `SELECT count(*) FROM places WHERE dataset_id=$1 AND src_pk BETWEEN 690021 AND 690022
AND poi_category IS NULL`, f.dsID); n != 2 {
t.Fatalf("应写 NULL 而不是空串,实际 %d 个", n)
}
if n := f.scalar(t, `SELECT count(*) FROM places WHERE dataset_id=$1 AND poi_category='测试类别丁'`, f.dsID); n != 0 {
t.Fatalf("类别应彻底消失,还剩 %d 个", n)
}
}
// 合并:源的到访整体转到目标,源活动被删,is_home/is_work 跟着目标走
// (那两个是从活动抄到到访上的冗余标记,不跟着改就会留下一个矛盾的到访)。
func TestActivityMergeMovesVisitsThenDeletesSource(t *testing.T) {
f := newMovementFixture(t)
placeID, _ := fillupPlace(t, f)
mkAct := func(pk int, name string, home bool) int64 {
var id int64
if err := f.pg.QueryRowContext(f.ctx, `INSERT INTO activities
(dataset_id, src_pk, name, color, is_home) VALUES ($1,$2,$3,'',$4) RETURNING id`,
f.dsID, pk, name, home).Scan(&id); err != nil {
t.Fatalf("建活动失败: %v", err)
}
t.Cleanup(func() { f.pg.ExecContext(f.ctx, `DELETE FROM activities WHERE id=$1`, id) })
return id
}
from := mkAct(695001, "合并测试甲", false)
to := mkAct(695002, "合并测试乙", true)
f.mustExec(t, `UPDATE visits SET activity_id=$2, is_home=FALSE WHERE dataset_id=$1 AND place_id=$3`,
f.dsID, from, placeID)
if n := f.scalar(t, `SELECT count(*) FROM visits WHERE dataset_id=$1 AND activity_id=$2`, f.dsID, from); n == 0 {
t.Fatal("合并前应有到访挂在源活动上")
}
got := taxonomyPost(t, f, "/admin/edit/activity/merge", url.Values{
"from": {itoa(from)}, "to": {itoa(to)},
})
if got["error"] != nil {
t.Fatalf("合并不该失败: %v", got["error"])
}
if n := f.scalar(t, `SELECT count(*) FROM visits WHERE dataset_id=$1 AND activity_id=$2`, f.dsID, to); n == 0 {
t.Fatal("到访应转到目标活动名下")
}
if n := f.scalar(t, `SELECT count(*) FROM visits WHERE dataset_id=$1 AND is_home`, f.dsID); n == 0 {
t.Fatal("目标活动的 is_home 应抄到转过来的到访上")
}
if n := f.scalar(t, `SELECT count(*) FROM activities WHERE dataset_id=$1 AND id=$2`, f.dsID, from); n != 0 {
t.Fatal("源活动应被删掉")
}
if n := f.scalar(t, `SELECT count(*) FROM entity_raw WHERE dataset_id=$1 AND entity='ZACTIVITY' AND src_pk=695001`,
f.dsID); n != 0 {
t.Fatal("源活动的原始行留档应一起清掉,否则导出还会带它")
}
}
// 合并到自己或选空都必须拒绝,别把活动连同它的到访一起清掉。
func TestActivityMergeRefusesDegenerateInput(t *testing.T) {
f := newMovementFixture(t)
var id int64
if err := f.pg.QueryRowContext(f.ctx, `INSERT INTO activities (dataset_id, src_pk, name, color)
VALUES ($1,695011,'合并测试丙','') RETURNING id`, f.dsID).Scan(&id); err != nil {
t.Fatalf("建活动失败: %v", err)
}
t.Cleanup(func() { f.pg.ExecContext(f.ctx, `DELETE FROM activities WHERE id=$1`, id) })
for _, form := range []url.Values{
{"from": {itoa(id)}, "to": {itoa(id)}},
{"from": {itoa(id)}, "to": {"0"}},
{"from": {"0"}, "to": {itoa(id)}},
} {
if got := taxonomyPost(t, f, "/admin/edit/activity/merge", form); got["error"] == nil {
t.Fatalf("%v 应被拒绝", form)
}
}
if n := f.scalar(t, `SELECT count(*) FROM activities WHERE dataset_id=$1 AND id=$2`, f.dsID, id); n != 1 {
t.Fatal("被拒绝的合并不该动数据")
}
}
+177 -2
View File
@@ -22,6 +22,74 @@
{{else}} {{else}}
{{if not .CanExport}}<div class="alert err">导出所需要的基线库暂不可用(当初上传的原始 <span class="mono">.rondbackup</span> 可能已被清理)。请到<a href="/admin">后台</a>重新上传一次该备份文件,即可恢复导出。</div>{{end}} {{if not .CanExport}}<div class="alert err">导出所需要的基线库暂不可用(当初上传的原始 <span class="mono">.rondbackup</span> 可能已被清理)。请到<a href="/admin">后台</a>重新上传一次该备份文件,即可恢复导出。</div>{{end}}
{{/* 活动与类别是「分类字典」,不随下面的分页列表变,所以放最上面。
类别没有独立的表,值就长在 places.poi_category 上——所以「改名 / 清空」都是按值批量作用到地点。 */}}
<div class="card" data-card="taxonomy" id="taxonomy">
<h2>活动与类别</h2>
<div class="card-sub">
活动是单独的一张表(共 {{num (len .ActivityRows)}} 个),类别只是地点上的一个字段({{num (len .CategoryRows)}} 种在用)。
<b>改名时把值填成另一个已有的,就是合并</b>——整批并过去,不用先删再建。
</div>
<h3>活动</h3>
<div class="tw">
<table class="tb tb-stack">
<thead><tr><th>名称</th><th>引用</th><th>原生属性</th><th></th></tr></thead>
<tbody id="act-rows">
{{range .ActivityRows}}
<tr data-id="{{.ID}}" data-name="{{.Name}}">
<td data-label="名称"><input type="text" name="act-name" value="{{.Name}}" style="min-width:9em"></td>
<td data-label="引用">{{num .Visits}}</td>
<td data-label="原生属性">{{if .IsHome}}家{{end}}{{if and .IsHome .IsWork}} · {{end}}{{if .IsWork}}工作{{end}}</td>
<td class="ops">
<button class="btn sm" type="button" data-act="rename">改名</button>
<button class="btn sm" type="button" data-act="delete">删除</button>
</td>
</tr>
{{end}}
</tbody>
</table>
</div>
<div class="row" style="margin-top:10px;gap:8px;flex-wrap:wrap;align-items:center">
<span class="muted">合并:把</span>
<select id="merge-from" aria-label="合并来源">{{range .ActivityRows}}<option value="{{.ID}}">{{.Name}}({{num .Visits}})</option>{{end}}</select>
<span class="muted">并到</span>
<select id="merge-to" aria-label="合并目标">{{range .ActivityRows}}<option value="{{.ID}}">{{.Name}}({{num .Visits}})</option>{{end}}</select>
<button class="btn sm" type="button" id="merge-go">合并</button>
<span class="muted">|</span>
<input type="text" id="act-new" placeholder="新活动名称" style="min-width:8em">
<button class="btn sm" type="button" id="act-new-go">新增活动</button>
</div>
<h3>类别</h3>
<div class="tw">
<table class="tb tb-stack">
<thead><tr><th>类别</th><th>地点</th><th></th></tr></thead>
<tbody id="cat-rows">
{{range .CategoryRows}}
<tr data-value="{{.Value}}">
<td data-label="类别">
<input list="cat-values" type="text" name="cat-value" value="{{.Value}}" style="min-width:12em">
<div class="card-sub" style="margin:2px 0 0">{{.Label}}</div>
</td>
<td data-label="地点">{{num .Places}}</td>
<td class="ops">
<button class="btn sm" type="button" data-act="rename">改名</button>
<button class="btn sm" type="button" data-act="clear">清空</button>
</td>
</tr>
{{end}}
</tbody>
</table>
</div>
<datalist id="cat-values">{{range .CategoryRows}}<option value="{{.Value}}"></option>{{end}}</datalist>
<div class="card-sub" style="margin-top:8px">
把值改成另一个已有类别就是合并;「清空」= 那些地点退回「未指定」。
要加一个全新的类别,在地点行内编辑里选「自定义…」填就行——类别的候选本来就来自地点数据本身,
凭空预置一个没人用的值不会出现在任何下拉里。
</div>
</div>
<div class="card" data-card="place-new"> <div class="card" data-card="place-new">
<h2>新增地点</h2> <h2>新增地点</h2>
<div class="card-sub">按名称搜索可直接填入坐标;也可在地图上点击选点,坐标为 GCJ-02(与 rond 记录同系)。</div> <div class="card-sub">按名称搜索可直接填入坐标;也可在地图上点击选点,坐标为 GCJ-02(与 rond 记录同系)。</div>
@@ -595,8 +663,13 @@
head.appendChild(btn); head.appendChild(btn);
}); });
// 状态统一在这里落地:与上面的「装按钮/包 body」分开,重复执行也能对齐。 // 状态统一在这里落地:与上面的「装按钮/包 body」分开,重复执行也能对齐。
// 默认折叠——这页六张卡片全展开太长,只有明确记过「展开」的才展开。 // 默认折叠——这页卡片全展开太长,只有明确记过「展开」的才展开;
cards.forEach(function (card) { apply(card, state[card.dataset.card] !== false); }); // 「活动与类别」是新加的、也最小,默认展开,省得有人找不到。
cards.forEach(function (card) {
var collapsed = state[card.dataset.card];
if (collapsed === undefined) collapsed = card.dataset.card !== 'taxonomy';
apply(card, collapsed);
});
function show(card, collapsed) { function show(card, collapsed) {
apply(card, collapsed); apply(card, collapsed);
@@ -1176,6 +1249,108 @@
}); });
}); });
})(); })();
// ---------- 活动与类别:改名 / 删除 / 合并 / 清空 ----------
// 这些都是整批作用到数据上的操作,用量、原生属性、去重列表会一起变,
// 就地改 DOM 很容易拼出一个「看起来对」的状态,所以成功后直接整页重来拿新数字。
(function () {
var box = null;
function toast(text, bad) {
if (!box) {
var card = document.querySelector('[data-card="taxonomy"]');
var host = card.querySelector('.card-body') || card;
box = document.createElement('div');
host.insertBefore(box, host.firstChild);
}
box.className = 'alert ' + (bad ? 'err' : 'ok');
box.style.margin = '0 0 10px';
box.textContent = text;
if (!bad) box.scrollIntoView({ block: 'nearest' });
}
function post(path, body, after) {
fetch(path, {
method: 'POST',
headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
body: new URLSearchParams(body).toString()
}).then(function (r) { return r.json(); }).then(function (d) {
if (d.error) { toast(d.error, true); return; }
after(d);
}).catch(function (e) { toast('请求失败:' + e, true); });
}
function reload(text) {
location.href = '/admin/edit?ok=' + encodeURIComponent(text) + '#taxonomy';
}
function count(tr, label) {
var cell = tr.querySelector('[data-label="' + label + '"]');
return cell ? cell.textContent.trim() : '';
}
document.querySelectorAll('#act-rows tr').forEach(function (tr) {
var input = tr.querySelector('input[name="act-name"]');
var id = tr.dataset.id, name = tr.dataset.name;
tr.querySelector('[data-act="rename"]').addEventListener('click', function () {
var v = (input.value || '').trim();
if (!v) { toast('活动名称不能为空', true); return; }
if (v === name) { toast('名称没变', true); return; }
post('/admin/edit/activity/update', { id: id, name: v }, function () {
reload('活动已改名:' + name + ' → ' + v);
});
});
tr.querySelector('[data-act="delete"]').addEventListener('click', function () {
var n = count(tr, '引用');
var what = (!n || n === '0') ? '目前没有到访用它。'
: '引用它的 ' + n + ' 条到访会变成「未分类」。';
if (!window.confirm('删除活动「' + name + '」?\n' + what)) return;
post('/admin/edit/activity/delete', { id: id }, function () {
reload('已删除活动:' + name);
});
});
});
var mf = document.getElementById('merge-from');
var mt = document.getElementById('merge-to');
var go = document.getElementById('merge-go');
if (mf && mt && go) go.addEventListener('click', function () {
if (!mf.value || mf.value === mt.value) { toast('请选两个不同的活动', true); return; }
var a = mf.options[mf.selectedIndex].textContent;
var b = mt.options[mt.selectedIndex].textContent;
if (!window.confirm('把「' + a + '」的到访全部并到「' + b + '」,然后删掉「' + a + '」?')) return;
post('/admin/edit/activity/merge', { from: mf.value, to: mt.value }, function (d) {
reload('已把「' + a + '」并到「' + b + '」,转移 ' + d.visits + ' 条到访');
});
});
var an = document.getElementById('act-new');
var ang = document.getElementById('act-new-go');
if (an && ang) ang.addEventListener('click', function () {
var v = (an.value || '').trim();
if (!v) { toast('请填活动名称', true); return; }
post('/admin/edit/activity', { name: v }, function () {
reload('已新增活动:' + v);
});
});
document.querySelectorAll('#cat-rows tr').forEach(function (tr) {
var input = tr.querySelector('input[name="cat-value"]');
var from = tr.dataset.value;
tr.querySelector('[data-act="rename"]').addEventListener('click', function () {
var v = (input.value || '').trim();
if (!v) { toast('类别不能为空;要摘掉请用「清空」', true); return; }
if (v === from) { toast('类别没变', true); return; }
post('/admin/edit/category/rename', { from: from, to: v }, function (d) {
reload('已把 ' + count(tr, '地点') + ' 个地点的类别改成「' + (d.label || v) + '」');
});
});
tr.querySelector('[data-act="clear"]').addEventListener('click', function () {
var n = count(tr, '地点');
if (!window.confirm('清空 ' + n + ' 个地点的「' + from + '」类别?\n' +
'它们会退回「未指定」,统计里的这个类别会消失。')) return;
post('/admin/edit/category/clear', { from: from }, function (d) {
reload('已清空 ' + d.places + ' 个地点的类别');
});
});
});
})();
</script> </script>
{{end}} {{end}}
+24 -4
View File
@@ -750,10 +750,13 @@ type EditData struct {
PlaceOptions []EditOption PlaceOptions []EditOption
VisitOptions []EditOption // 最近到访(值=src_pk),供行程/天气表单选关联 VisitOptions []EditOption // 最近到访(值=src_pk),供行程/天气表单选关联
Categories []EditOption // 已有地点的类别(去重),供新建时下拉直选 Categories []EditOption // 已有地点的类别(去重),供新建时下拉直选
Places []EditPlace // ActivityRows / CategoryRows 是顶部「活动与类别」卡片用的台账(带用量)
Visits []EditVisit ActivityRows []EditActivity
Movements []EditMovement CategoryRows []EditCategory
Query string Places []EditPlace
Visits []EditVisit
Movements []EditMovement
Query string
// VisitQuery 是到访记录列表的搜索词(与地点列表的 Query 独立) // VisitQuery 是到访记录列表的搜索词(与地点列表的 Query 独立)
VisitQuery string VisitQuery string
// MovementFilter 是行程列表的筛选条件,都是选择框而不是让人手输关键词 // MovementFilter 是行程列表的筛选条件,都是选择框而不是让人手输关键词
@@ -894,6 +897,23 @@ type EditOption struct {
Label string Label string
} }
// EditActivity 是「活动与类别」卡片里的一行活动:带用量,好一眼看出哪些没人用。
type EditActivity struct {
ID int64
Name string
Visits int
IsHome bool
IsWork bool
}
// EditCategory 是类别台账的一行。类别没有表,值就是 places.poi_category,
// 所以「改名 / 清空」都是按值批量作用到地点上——改成另一个已有值就是合并。
type EditCategory struct {
Value string
Label string
Places int
}
type EditPlace struct { type EditPlace struct {
ID int64 ID int64
SrcPK int SrcPK int
+7
View File
@@ -208,6 +208,13 @@ func checkWideTablesOutsideGrid(t *testing.T, path, body string) int {
continue continue
} }
seen++ seen++
// 两个类是成对的:app.css 里每一条堆叠规则都写成 `.tw > table.tb.tb-stack …`。
// 只写 tb-stack 一条都命中不了,表格退回 `.tw > table.tb` 的 640px 底宽,
// 窄屏照旧横滑——而且横滑是在 .tw 里滚的,页面本身不溢出,肉眼很难发现
// (2026-09-20 加「活动与类别」卡片时就这么漏过一次)。
if m := classRe.FindStringSubmatch(tag); m == nil || !strings.Contains(" "+m[1]+" ", " tb ") {
t.Errorf("%s:tb-stack 表少了 tb 类(class=%q)——堆叠规则匹配不到,窄屏只能横滑", path, tag)
}
// 只有标了 tb-stack 的才算「宽表」;普通的窄表放进 g2 没问题,不该报。 // 只有标了 tb-stack 的才算「宽表」;普通的窄表放进 g2 没问题,不该报。
if inG2 { if inG2 {
t.Errorf("%s:一张宽表被放在 g2 网格里(卡片只剩半宽,桌面端要横滑)", path) t.Errorf("%s:一张宽表被放在 g2 网格里(卡片只剩半宽,桌面端要横滑)", path)