Files
knowledge-governance/internal/qaopsmirror/store.go
T
姚章浩 4a2b2b7d84
build / build (push) Successful in 1m5s
feat(qaops): 增加部门树区域统计与父子联选
区域配置入口改为区域统计,五列表按当前通讯录整支人员去重;调岗依当前归属、零分母未知、最近真实提问时间和父行收起不重算。仅读治理正式总表,后台单并发/请求合并/60秒缓存,目录与配置版本隔离,客户端失败不伪零。

保留区域自定义目录与预览/双版本锁保存,父部门勾选联选全后代,取消子支清除祖先整支选择,避免隐式覆盖未选子级;允许删除无引用区域,已有引用不静默孤立。统计页与设置共享选择,统计支持累计与北京时间自然月;不新增迁移,不改DobotAI生产、代理、原问答、历史趋势或已有AI任务。

验证已执行:完整make verify退出0,705 Go/340前端通过、120项声明的可选集成跳过且必需0跳过;镜像全量隔离PG race退出0;新增去重/调岗/空分母、后台缓存/并发、HTTP授权/严格请求、真PG目录与配置失效、树选择/收起、五列与删除保护均先红后绿。旧导航测试按新名称更新后全量通过。上线前治理库备份与真实恢复72表/29张QA内容哈希一致,匹配独立主密钥受限备份。

当前尚待精确SHA CI、同镜像真实数据浏览器与正式读回,不把源码验证称为已上线。公司真实区域映射不在本轮擅改;只在隔离库验证保存。
2026-10-19 19:01:36 +08:00

183 lines
6.7 KiB
Go

// Package qaopsmirror serves an explicitly synchronized local copy, never an implicit source fallback.
package qaopsmirror
import (
"context"
"encoding/json"
"errors"
"github.com/jackc/pgx/v5"
"github.com/jackc/pgx/v5/pgxpool"
"knowledge-governance/internal/dobotaiops"
"strings"
"sync"
"time"
)
const Interval = 5 * time.Minute
const localBaseSQL = `WITH records AS (SELECT id,asked_at,question,status,identity,quality_hash,payload FROM qa_ops_mirror_records WHERE tenant_key=$1)`
type Store struct {
pool *pgxpool.Pool
tenant string
mu sync.RWMutex
safety dobotaiops.SourceSafety
departmentStats departmentStatisticsCache
}
func NewStore(pool *pgxpool.Pool, tenant string) *Store { return &Store{pool: pool, tenant: tenant} }
type Status struct {
Mode string `json:"mode"`
Ready bool `json:"ready"`
Blocked bool `json:"blocked"`
Revision int64 `json:"revision"`
Records int64 `json:"records"`
SourceObservedAt *time.Time `json:"source_observed_at"`
LastSuccessAt *time.Time `json:"last_success_at"`
NextSyncAt *time.Time `json:"next_sync_at"`
ErrorCode string `json:"error_code"`
IntervalSeconds int `json:"interval_seconds"`
WorkerReady bool `json:"worker_ready"`
Job *SyncJob `json:"job"`
Safety dobotaiops.SourceSafety `json:"-"`
}
type SyncJob struct {
ID string `json:"id"`
State string `json:"state"`
Loaded int `json:"loaded"`
Expected int `json:"expected"`
Changed int `json:"changed"`
ErrorCode string `json:"error_code"`
}
func (s *Store) valid() bool {
return s != nil && s.pool != nil && strings.TrimSpace(s.tenant) == s.tenant && len(s.tenant) > 0 && len(s.tenant) <= 128 && !strings.ContainsRune(s.tenant, 0)
}
func (s *Store) readState(ctx context.Context, q dobotaiops.RecordQuerier) (Status, error) {
out := Status{Mode: "local", IntervalSeconds: int(Interval / time.Second)}
var safety []byte
err := q.QueryRow(ctx, `SELECT ready,blocked,revision,record_count,source_observed_at,synced_at,next_sync_at,last_error,source_safety FROM qa_ops_mirror_state WHERE tenant_key=$1`, s.tenant).Scan(&out.Ready, &out.Blocked, &out.Revision, &out.Records, &out.SourceObservedAt, &out.LastSuccessAt, &out.NextSyncAt, &out.ErrorCode, &safety)
if errors.Is(err, pgx.ErrNoRows) {
out.ErrorCode = "initial_sync_pending"
return out, nil
}
if err != nil || json.Unmarshal(safety, &out.Safety) != nil {
return Status{}, dobotaiops.ErrUnavailable
}
s.mu.Lock()
s.safety = out.Safety
s.mu.Unlock()
return out, nil
}
type txQuery struct{ pgx.Tx }
func (q txQuery) QueryRow(ctx context.Context, sql string, args ...any) dobotaiops.RecordRow {
return q.Tx.QueryRow(ctx, sql, args...)
}
type poolQuery struct{ *pgxpool.Pool }
func (q poolQuery) QueryRow(ctx context.Context, sql string, args ...any) dobotaiops.RecordRow {
return q.Pool.QueryRow(ctx, sql, args...)
}
func (s *Store) Available(ctx context.Context) error {
if !s.valid() {
return dobotaiops.ErrUnavailable
}
state, e := s.readState(ctx, poolQuery{s.pool})
if e != nil {
return e
}
if state.Blocked {
return dobotaiops.ErrNotReadOnly
}
if !state.Ready {
return dobotaiops.ErrUnavailable
}
return nil
}
func (s *Store) Safety() dobotaiops.SourceSafety { s.mu.RLock(); defer s.mu.RUnlock(); return s.safety }
func (s *Store) repository(revision *int64) *dobotaiops.RecordsRepository {
return s.repositoryFor(revision, false)
}
func (s *Store) repositoryFor(revision *int64, master bool) *dobotaiops.RecordsRepository {
base, summary, scope := localBaseSQL, localSummarySQL, localQualityScopeSQL
if master {
base, summary, scope = masterBaseSQL, masterSummarySQL, masterQualityScopeSQL
}
return dobotaiops.NewRecordsRepository(dobotaiops.RecordsRepositoryOptions{
BaseSQL: base, SummarySQL: summary, QualityScopeSQL: scope, TenantKey: s.tenant,
ValidateWindow: func(w dobotaiops.Window) error {
if w.TenantKey != s.tenant {
return dobotaiops.ErrInvalidQuery
}
_, e := dobotaiops.NewWindow(w.TenantKey, w.Start.Format(time.RFC3339Nano), w.End.Format(time.RFC3339Nano), 90*24*time.Hour, time.Now())
return e
},
ReadAsOf: func(ctx context.Context, q dobotaiops.RecordQuerier, t *time.Time) error {
if master {
return q.QueryRow(ctx, `SELECT updated_at FROM qa_ops_master_state WHERE tenant_key=$1`, s.tenant).Scan(t)
}
return q.QueryRow(ctx, `SELECT source_observed_at FROM qa_ops_mirror_state WHERE tenant_key=$1`, s.tenant).Scan(t)
},
Transaction: func(ctx context.Context, fn func(context.Context, dobotaiops.RecordQuerier) error) error {
if !s.valid() {
return dobotaiops.ErrUnavailable
}
ctx, cancel := context.WithTimeout(ctx, 15*time.Second)
defer cancel()
tx, e := s.pool.BeginTx(ctx, pgx.TxOptions{IsoLevel: pgx.RepeatableRead, AccessMode: pgx.ReadOnly})
if e != nil {
return dobotaiops.ErrUnavailable
}
defer func() { _ = tx.Rollback(context.Background()) }()
q := txQuery{tx}
if master {
if revision != nil {
if e = q.QueryRow(ctx, `SELECT COALESCE((SELECT revision FROM qa_ops_master_state WHERE tenant_key=$1),0)`, s.tenant).Scan(revision); e != nil {
return dobotaiops.ErrUnavailable
}
}
} else {
state, err := s.readState(ctx, q)
if err != nil {
return err
}
if state.Blocked {
return dobotaiops.ErrNotReadOnly
}
if !state.Ready {
return dobotaiops.ErrUnavailable
}
if revision != nil {
*revision = state.Revision
}
}
if e = fn(ctx, q); e != nil {
return e
}
if tx.Commit(ctx) != nil {
return dobotaiops.ErrUnavailable
}
return nil
},
})
}
func (s *Store) ListRecords(ctx context.Context, q dobotaiops.RecordQuery) (dobotaiops.RecordPage, error) {
var rev int64
p, e := s.repository(&rev).ListRecords(ctx, q)
p.LocalRevision = rev
p.Columns = []string{"question_chinese", "answer", "coverage", "is_correct", "product_category", "problem_type", "root_cause", "asked_at", "asker", "question", "language", "trigger_person", "department", "region", "feedback"}
return p, e
}
func (s *Store) GetRecord(ctx context.Context, tenant, id string) (dobotaiops.Record, error) {
return s.repository(nil).GetRecord(ctx, tenant, id)
}
func (s *Store) ReadUsageGroups(ctx context.Context, q dobotaiops.RecordQuery) (dobotaiops.UsageGroups, error) {
return s.repository(nil).ReadUsageGroups(ctx, q)
}
func (s *Store) ReadQualityScope(ctx context.Context, q dobotaiops.RecordQuery) (dobotaiops.QualityScope, error) {
return s.repository(nil).ReadQualityScope(ctx, q)
}