184 lines
8.7 KiB
Go
184 lines
8.7 KiB
Go
package saas
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"strings"
|
|
"time"
|
|
|
|
"data-terminal-cloud/internal/firmwareversion"
|
|
"data-terminal-cloud/internal/identity"
|
|
)
|
|
|
|
const deviceRecentWindow = 24 * time.Hour
|
|
|
|
type ConversationReadinessCheck struct {
|
|
Code string `json:"code"`
|
|
Status string `json:"status"`
|
|
Blocking bool `json:"blocking"`
|
|
Title string `json:"title"`
|
|
Detail string `json:"detail"`
|
|
Action string `json:"action,omitempty"`
|
|
}
|
|
|
|
type ConversationReadinessDevice struct {
|
|
ID string `json:"id"`
|
|
Model string `json:"model"`
|
|
Status string `json:"status"`
|
|
FirmwareVersion *string `json:"firmware_version,omitempty"`
|
|
MinimumFirmwareVersion *string `json:"minimum_firmware_version,omitempty"`
|
|
DesiredRevision int64 `json:"desired_revision"`
|
|
ReportedRevision *int64 `json:"reported_revision,omitempty"`
|
|
LastReportedAt *time.Time `json:"last_reported_at,omitempty"`
|
|
}
|
|
|
|
type ConversationReadiness struct {
|
|
SubjectID string `json:"subject_id"`
|
|
Ready bool `json:"ready"`
|
|
EvaluatedAt time.Time `json:"evaluated_at"`
|
|
Checks []ConversationReadinessCheck `json:"checks"`
|
|
Devices []ConversationReadinessDevice `json:"devices"`
|
|
StartTimeChecks []string `json:"start_time_checks"`
|
|
}
|
|
|
|
// GetConversationReadiness evaluates the household-manageable prerequisites for
|
|
// a subject's first call. Quota, routing and concurrent-call checks deliberately
|
|
// remain start-time checks because their state can change immediately after this
|
|
// response is returned.
|
|
func (s *Service) GetConversationReadiness(ctx context.Context, principal identity.Principal, subjectPublicID string) (ConversationReadiness, error) {
|
|
access, subject, err := resolveSubject(ctx, s.pool, principal, subjectPublicID, identity.CapabilitySubjectRead, false)
|
|
if err != nil {
|
|
return ConversationReadiness{}, err
|
|
}
|
|
|
|
result := ConversationReadiness{
|
|
SubjectID: subjectPublicID,
|
|
Ready: true,
|
|
EvaluatedAt: time.Now().UTC(),
|
|
Checks: make([]ConversationReadinessCheck, 0, 8),
|
|
Devices: make([]ConversationReadinessDevice, 0),
|
|
StartTimeChecks: []string{"usage_quota", "runtime_routing", "no_active_conversation"},
|
|
}
|
|
add := func(check ConversationReadinessCheck) {
|
|
result.Checks = append(result.Checks, check)
|
|
if check.Blocking && check.Status != "ready" {
|
|
result.Ready = false
|
|
}
|
|
}
|
|
|
|
if subject.Status == "active" {
|
|
add(readinessCheck("SUBJECT_ACTIVE", "ready", true, "长者档案已启用", "当前档案允许创建新通话。", ""))
|
|
} else {
|
|
add(readinessCheck("SUBJECT_ACTIVE", "blocked", true, "长者档案未启用", "请先把长者档案状态恢复为启用。", "EDIT_PROFILE"))
|
|
}
|
|
if nonEmptyProfileString(subject.ProfileData, "background") {
|
|
add(readinessCheck("PROFILE_BACKGROUND", "ready", true, "长者背景已填写", "授权背景会按档案版本冻结到新通话。", ""))
|
|
} else {
|
|
add(readinessCheck("PROFILE_BACKGROUND", "blocked", true, "缺少长者背景", "请填写简要家庭背景，避免首次交流缺少上下文。", "EDIT_PROFILE"))
|
|
}
|
|
if nonEmptyProfileString(subject.ConversationPreferences, "conversation_goal") {
|
|
add(readinessCheck("CONVERSATION_GOAL", "ready", true, "交流目标已填写", "新通话将使用当前档案版本中的交流目标。", ""))
|
|
} else {
|
|
add(readinessCheck("CONVERSATION_GOAL", "blocked", true, "缺少交流目标", "请填写本阶段希望达成的交流目标。", "EDIT_PROFILE"))
|
|
}
|
|
|
|
var hasVoiceConsent bool
|
|
err = s.pool.QueryRow(ctx, `
|
|
SELECT EXISTS(
|
|
SELECT 1 FROM consent_snapshot
|
|
WHERE tenant_id=$1::uuid AND subject_id=$2::uuid
|
|
AND effective_consents @> '{"voice_chat":true}'::jsonb
|
|
)`, access.tenantID, access.subjectID).Scan(&hasVoiceConsent)
|
|
if err != nil {
|
|
return ConversationReadiness{}, fmt.Errorf("check voice consent readiness: %w", err)
|
|
}
|
|
if hasVoiceConsent {
|
|
add(readinessCheck("VOICE_CONSENT", "ready", true, "语音通话授权已具备", "服务端已存在可冻结到新通话的有效授权快照。", ""))
|
|
} else {
|
|
add(readinessCheck("VOICE_CONSENT", "blocked", true, "缺少语音通话授权", "请完成至少一项明确分项授权并保留授权凭证。", "MANAGE_CONSENTS"))
|
|
}
|
|
|
|
rows, err := s.pool.Query(ctx, `
|
|
SELECT d.public_id::text,d.model,d.status,dt.firmware_version,d.minimum_firmware_version,
|
|
dt.desired_revision,dt.reported_revision,dt.last_reported_at
|
|
FROM device_binding b
|
|
JOIN device d ON d.id=b.device_id AND d.tenant_id=b.tenant_id
|
|
JOIN device_twin dt ON dt.device_id=d.id AND dt.tenant_id=d.tenant_id
|
|
WHERE b.tenant_id=$1::uuid AND b.subject_id=$2::uuid AND b.unbound_at IS NULL
|
|
ORDER BY b.bound_at DESC,d.id`, access.tenantID, access.subjectID)
|
|
if err != nil {
|
|
return ConversationReadiness{}, fmt.Errorf("list readiness devices: %w", err)
|
|
}
|
|
defer rows.Close()
|
|
for rows.Next() {
|
|
var item ConversationReadinessDevice
|
|
if err := rows.Scan(&item.ID, &item.Model, &item.Status, &item.FirmwareVersion, &item.MinimumFirmwareVersion,
|
|
&item.DesiredRevision, &item.ReportedRevision, &item.LastReportedAt); err != nil {
|
|
return ConversationReadiness{}, fmt.Errorf("scan readiness device: %w", err)
|
|
}
|
|
result.Devices = append(result.Devices, item)
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return ConversationReadiness{}, fmt.Errorf("iterate readiness devices: %w", err)
|
|
}
|
|
|
|
if len(result.Devices) == 0 {
|
|
add(readinessCheck("DEVICE_BOUND", "blocked", true, "尚未绑定设备", "请使用设备屏幕显示的一次性绑定码完成绑定。", "BIND_DEVICE"))
|
|
add(readinessCheck("DEVICE_RUNTIME", "blocked", true, "没有可用于通话的设备", "绑定并启动设备后才能发起首次通话。", "BIND_DEVICE"))
|
|
return result, nil
|
|
}
|
|
add(readinessCheck("DEVICE_BOUND", "ready", true, "设备已绑定", fmt.Sprintf("当前长者已绑定%d台设备。", len(result.Devices)), ""))
|
|
|
|
registered, reported, compatible, synced, recent := 0, 0, 0, 0, 0
|
|
for _, device := range result.Devices {
|
|
if device.Status != "registered" {
|
|
continue
|
|
}
|
|
registered++
|
|
if device.FirmwareVersion != nil && strings.TrimSpace(*device.FirmwareVersion) != "" {
|
|
reported++
|
|
if device.MinimumFirmwareVersion == nil || firmwareversion.AtLeast(*device.FirmwareVersion, *device.MinimumFirmwareVersion) {
|
|
compatible++
|
|
}
|
|
}
|
|
if device.ReportedRevision != nil && *device.ReportedRevision == device.DesiredRevision {
|
|
synced++
|
|
}
|
|
if device.LastReportedAt != nil && result.EvaluatedAt.Sub(*device.LastReportedAt) <= deviceRecentWindow {
|
|
recent++
|
|
}
|
|
}
|
|
if registered > 0 && reported > 0 {
|
|
add(readinessCheck("DEVICE_RUNTIME", "ready", true, "设备运行信息完整", fmt.Sprintf("%d台已注册设备已报告固件版本。", reported), ""))
|
|
} else if registered == 0 {
|
|
add(readinessCheck("DEVICE_RUNTIME", "blocked", true, "绑定设备不可用", "已绑定设备均不是注册状态，请联系运维处理设备状态。", "OPEN_DEVICES"))
|
|
} else {
|
|
add(readinessCheck("DEVICE_RUNTIME", "blocked", true, "设备尚未完成启动上报", "请启动设备并等待其完成引导和固件信息上报。", "OPEN_DEVICES"))
|
|
}
|
|
if compatible > 0 {
|
|
add(readinessCheck("FIRMWARE_POLICY", "ready", true, "设备固件满足最低版本", fmt.Sprintf("%d台设备可通过新通话固件门禁。", compatible), ""))
|
|
} else {
|
|
add(readinessCheck("FIRMWARE_POLICY", "blocked", true, "设备固件需要升级", "当前已上报设备均未达到最低固件版本，请先完成签名固件升级。", "OPEN_DEVICES"))
|
|
}
|
|
if synced > 0 {
|
|
add(readinessCheck("CONFIG_SYNC", "ready", false, "设备配置已同步", fmt.Sprintf("%d台设备已应用当前配置版本。", synced), ""))
|
|
} else {
|
|
add(readinessCheck("CONFIG_SYNC", "attention", false, "设备配置待同步", "这不会阻止创建通话，但设备应尽快拉取并应用当前配置。", "OPEN_DEVICES"))
|
|
}
|
|
if recent > 0 {
|
|
add(readinessCheck("RECENT_CONTACT", "ready", false, "设备近期已联系云端", fmt.Sprintf("%d台设备在24小时内完成过状态上报。", recent), ""))
|
|
} else {
|
|
add(readinessCheck("RECENT_CONTACT", "attention", false, "设备近期未联系云端", "通话开始前请确认设备已联网；在线状态会在通话心跳后更新。", "OPEN_DEVICES"))
|
|
}
|
|
return result, nil
|
|
}
|
|
|
|
func readinessCheck(code, status string, blocking bool, title, detail, action string) ConversationReadinessCheck {
|
|
return ConversationReadinessCheck{Code: code, Status: status, Blocking: blocking, Title: title, Detail: detail, Action: action}
|
|
}
|
|
|
|
func nonEmptyProfileString(values map[string]any, key string) bool {
|
|
value, ok := values[key].(string)
|
|
return ok && strings.TrimSpace(value) != ""
|
|
}
|