887 lines
27 KiB
Markdown
887 lines
27 KiB
Markdown
# 设计断链修复计划
|
|
|
|
**文档版本**: v1.0
|
|
**编写日期**: 2026-04-01
|
|
**目的**: 修复当前项目的设计断链问题,确保前后端设计闭环
|
|
|
|
---
|
|
|
|
## 一、当前设计断链清单
|
|
|
|
### 1.1 优先级分类
|
|
|
|
**P0 - 严重断链(必须立即修复)**
|
|
|
|
| ID | 断链类型 | 功能名称 | 影响 | 修复工作量 |
|
|
|----|---------|---------|------|----------|
|
|
| GAP-FE-001 | 前端缺失 | 管理员管理页 | 管理员无法通过后台管理管理员 | 3天 |
|
|
| GAP-FE-002 | 前端缺失 | 系统设置页 | 系统配置无法管理 | 4天 |
|
|
| GAP-FE-003 | 前端缺失 | 全局设备管理页 | 设备信息无法全局管理 | 3天 |
|
|
| GAP-FE-004 | 前端缺失 | 登录日志导出 | 无法导出登录日志 | 1天 |
|
|
| GAP-BE-001 | 后端缺失 | 系统设置API | 系统设置功能无法实现 | 3天 |
|
|
| GAP-INT-001 | 接线缺失 | 设备信任检查 | 设备信任功能不生效 | 2天 |
|
|
| GAP-INT-002 | 接线缺失 | 角色继承权限 | 角色继承功能不生效 | 2天 |
|
|
|
|
**P1 - 中等断链(当前Sprint修复)**
|
|
|
|
| ID | 断链类型 | 功能名称 | 影响 | 修复工作量 |
|
|
|----|---------|---------|------|----------|
|
|
| GAP-FE-005 | 前端缺失 | 批量操作(用户管理) | 批量删除/操作效率低 | 2天 |
|
|
| GAP-INT-003 | 接线缺失 | 异常检测接入 | 异常检测功能不生效 | 2天 |
|
|
| GAP-INT-004 | 接线缺失 | 密码历史记录检查 | 密码重复使用防护不生效 | 1天 |
|
|
|
|
**P2 - 轻微断链(下一Sprint修复)**
|
|
|
|
| ID | 断链类型 | 功能名称 | 影响 | 修复工作量 |
|
|
|----|---------|---------|------|----------|
|
|
| GAP-INT-005 | 接线缺失 | IP地理位置解析 | 异地登录检测不精确 | 1天 |
|
|
| GAP-INT-006 | 接线缺失 | 设备指纹采集 | 设备识别不准确 | 1天 |
|
|
|
|
### 1.2 断链分布统计
|
|
|
|
```
|
|
┌─────────────────────────────────────────────────────────────┐
|
|
│ 设计断链分布统计 │
|
|
├─────────────────────────────────────────────────────────────┤
|
|
│ │
|
|
│ 前端缺失: 4个 (管理员管理、系统设置、全局设备管理、导出) │
|
|
│ 后端缺失: 1个 (系统设置API) │
|
|
│ 接线缺失: 6个 (设备信任、角色继承、异常检测等) │
|
|
│ │
|
|
│ P0断链: 7个 │
|
|
│ P1断链: 3个 │
|
|
│ P2断链: 2个 │
|
|
│ │
|
|
│ 总修复工作量: 约30天 │
|
|
│ │
|
|
└─────────────────────────────────────────────────────────────┘
|
|
```
|
|
|
|
---
|
|
|
|
## 二、修复计划
|
|
|
|
### 2.1 修复优先级排序
|
|
|
|
**Sprint 12 (当前,剩余10天)**
|
|
|
|
| ID | 断链名称 | 优先级 | 负责人 | 计划完成 |
|
|
|----|---------|--------|--------|---------|
|
|
| GAP-BE-001 | 系统设置API | P0 | 后端A | 04-03 |
|
|
| GAP-INT-001 | 设备信任检查 | P0 | 后端A | 04-04 |
|
|
| GAP-INT-002 | 角色继承权限 | P0 | 后端A | 04-05 |
|
|
| GAP-INT-004 | 密码历史检查 | P1 | 后端A | 04-06 |
|
|
|
|
**Sprint 13 (下周,14天)**
|
|
|
|
| ID | 断链名称 | 优先级 | 负责人 | 计划完成 |
|
|
|----|---------|--------|--------|---------|
|
|
| GAP-FE-001 | 管理员管理页 | P0 | 前端A | 04-08 |
|
|
| GAP-FE-002 | 系统设置页 | P0 | 前端A | 04-10 |
|
|
| GAP-FE-003 | 全局设备管理页 | P0 | 前端A | 04-12 |
|
|
| GAP-FE-004 | 登录日志导出 | P0 | 前端A | 04-13 |
|
|
| GAP-INT-003 | 异常检测接入 | P1 | 后端A | 04-15 |
|
|
| GAP-FE-005 | 批量操作 | P1 | 前端A | 04-17 |
|
|
|
|
**Sprint 14 (下下周,14天)**
|
|
|
|
| ID | 断链名称 | 优先级 | 负责人 | 计划完成 |
|
|
|----|---------|--------|--------|---------|
|
|
| GAP-INT-005 | IP地理位置解析 | P2 | 后端A | 04-22 |
|
|
| GAP-INT-006 | 设备指纹采集 | P2 | 前端A | 04-23 |
|
|
|
|
### 2.2 详细修复方案
|
|
|
|
#### GAP-BE-001: 系统设置API
|
|
|
|
**问题描述**
|
|
- 前端系统设置页需要后端API支持
|
|
- 当前后端无系统设置相关接口
|
|
|
|
**修复方案**
|
|
|
|
**1. 数据库设计**
|
|
|
|
```sql
|
|
-- 系统设置表
|
|
CREATE TABLE system_configs (
|
|
id BIGINT PRIMARY KEY AUTO_INCREMENT,
|
|
config_key VARCHAR(100) NOT NULL UNIQUE COMMENT '配置键',
|
|
config_value TEXT NOT NULL COMMENT '配置值',
|
|
config_type ENUM('string', 'number', 'boolean', 'json') NOT NULL DEFAULT 'string' COMMENT '配置类型',
|
|
category VARCHAR(50) NOT NULL COMMENT '配置分类',
|
|
description VARCHAR(255) COMMENT '配置描述',
|
|
is_public TINYINT(1) DEFAULT 0 COMMENT '是否公开(前端可见)',
|
|
is_editable TINYINT(1) DEFAULT 1 COMMENT '是否可编辑',
|
|
default_value TEXT COMMENT '默认值',
|
|
validation_rule VARCHAR(255) COMMENT '验证规则',
|
|
created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
|
|
updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
|
|
created_by BIGINT COMMENT '创建人ID',
|
|
updated_by BIGINT COMMENT '更新人ID',
|
|
INDEX idx_category (category),
|
|
INDEX idx_key (config_key)
|
|
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='系统配置表';
|
|
|
|
-- 初始化默认配置
|
|
INSERT INTO system_configs (config_key, config_value, config_type, category, description, is_public, is_editable, default_value) VALUES
|
|
('system.name', 'UMS', 'string', 'system', '系统名称', 1, 1, 'UMS'),
|
|
('system.logo_url', '', 'string', 'system', '系统Logo URL', 1, 1, ''),
|
|
('system.timezone', 'Asia/Shanghai', 'string', 'system', '系统时区', 1, 1, 'Asia/Shanghai'),
|
|
('system.language', 'zh-CN', 'string', 'system', '系统语言', 1, 1, 'zh-CN'),
|
|
('auth.password_min_length', '8', 'number', 'auth', '密码最小长度', 1, 1, '8'),
|
|
('auth.password_max_age_days', '90', 'number', 'auth', '密码有效期(天)', 1, 1, '90'),
|
|
('auth.session_timeout_minutes', '30', 'number', 'auth', '会话超时时间(分钟)', 1, 1, '30'),
|
|
('auth.enable_totp', 'true', 'boolean', 'auth', '启用双因素认证', 1, 1, 'true'),
|
|
('auth.enable_device_trust', 'true', 'boolean', 'auth', '启用设备信任', 1, 1, 'true'),
|
|
('auth.device_trust_duration_days', '30', 'number', 'auth', '设备信任有效期(天)', 1, 1, '30'),
|
|
('notification.email_enabled', 'true', 'boolean', 'notification', '启用邮件通知', 1, 1, 'true'),
|
|
('notification.sms_enabled', 'false', 'boolean', 'notification', '启用短信通知', 1, 1, 'false'),
|
|
('security.max_login_attempts', '5', 'number', 'security', '最大登录尝试次数', 1, 1, '5'),
|
|
('security.login_lockout_minutes', '30', 'number', 'security', '登录锁定时间(分钟)', 1, 1, '30'),
|
|
('logging.log_level', 'info', 'string', 'logging', '日志级别', 1, 1, 'info'),
|
|
('logging.log_retention_days', '30', 'number', 'logging', '日志保留天数', 1, 1, '30');
|
|
```
|
|
|
|
**2. Domain模型**
|
|
|
|
```go
|
|
// internal/domain/system_config.go
|
|
package domain
|
|
|
|
import "time"
|
|
|
|
type SystemConfig struct {
|
|
ID int64 `json:"id"`
|
|
ConfigKey string `json:"config_key"`
|
|
ConfigValue string `json:"config_value"`
|
|
ConfigType string `json:"config_type"` // string, number, boolean, json
|
|
Category string `json:"category"`
|
|
Description string `json:"description"`
|
|
IsPublic bool `json:"is_public"`
|
|
IsEditable bool `json:"is_editable"`
|
|
DefaultValue string `json:"default_value"`
|
|
ValidationRule string `json:"validation_rule"`
|
|
CreatedAt time.Time `json:"created_at"`
|
|
UpdatedAt time.Time `json:"updated_at"`
|
|
CreatedBy *int64 `json:"created_by,omitempty"`
|
|
UpdatedBy *int64 `json:"updated_by,omitempty"`
|
|
}
|
|
|
|
type SystemConfigUpdate struct {
|
|
ConfigValue string `json:"config_value"`
|
|
UpdatedBy int64 `json:"updated_by"`
|
|
}
|
|
```
|
|
|
|
**3. Repository层**
|
|
|
|
```go
|
|
// internal/repository/system_config.go
|
|
package repository
|
|
|
|
import (
|
|
"context"
|
|
"d:/project/internal/domain"
|
|
"gorm.io/gorm"
|
|
)
|
|
|
|
type SystemConfigRepository struct {
|
|
db *gorm.DB
|
|
}
|
|
|
|
func NewSystemConfigRepository(db *gorm.DB) *SystemConfigRepository {
|
|
return &SystemConfigRepository{db: db}
|
|
}
|
|
|
|
func (r *SystemConfigRepository) GetByCategory(ctx context.Context, category string) ([]*domain.SystemConfig, error) {
|
|
var configs []*domain.SystemConfig
|
|
err := r.db.WithContext(ctx).
|
|
Where("category = ?", category).
|
|
Find(&configs).Error
|
|
return configs, err
|
|
}
|
|
|
|
func (r *SystemConfigRepository) GetByKey(ctx context.Context, key string) (*domain.SystemConfig, error) {
|
|
var config domain.SystemConfig
|
|
err := r.db.WithContext(ctx).
|
|
Where("config_key = ?", key).
|
|
First(&config).Error
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &config, nil
|
|
}
|
|
|
|
func (r *SystemConfigRepository) GetAllPublic(ctx context.Context) ([]*domain.SystemConfig, error) {
|
|
var configs []*domain.SystemConfig
|
|
err := r.db.WithContext(ctx).
|
|
Where("is_public = ?", true).
|
|
Order("category, config_key").
|
|
Find(&configs).Error
|
|
return configs, err
|
|
}
|
|
|
|
func (r *SystemConfigRepository) GetAll(ctx context.Context) ([]*domain.SystemConfig, error) {
|
|
var configs []*domain.SystemConfig
|
|
err := r.db.WithContext(ctx).
|
|
Order("category, config_key").
|
|
Find(&configs).Error
|
|
return configs, err
|
|
}
|
|
|
|
func (r *SystemConfigRepository) Update(ctx context.Context, key string, update *domain.SystemConfigUpdate) error {
|
|
return r.db.WithContext(ctx).
|
|
Model(&domain.SystemConfig{}).
|
|
Where("config_key = ? AND is_editable = ?", key, true).
|
|
Updates(map[string]interface{}{
|
|
"config_value": update.ConfigValue,
|
|
"updated_by": update.UpdatedBy,
|
|
"updated_at": "NOW()",
|
|
}).Error
|
|
}
|
|
|
|
func (r *SystemConfigRepository) GetByKeys(ctx context.Context, keys []string) (map[string]*domain.SystemConfig, error) {
|
|
var configs []*domain.SystemConfig
|
|
err := r.db.WithContext(ctx).
|
|
Where("config_key IN ?", keys).
|
|
Find(&configs).Error
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
result := make(map[string]*domain.SystemConfig)
|
|
for _, config := range configs {
|
|
result[config.ConfigKey] = config
|
|
}
|
|
return result, nil
|
|
}
|
|
```
|
|
|
|
**4. Service层**
|
|
|
|
```go
|
|
// internal/service/system_config.go
|
|
package service
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"fmt"
|
|
"d:/project/internal/domain"
|
|
"d:/project/internal/repository"
|
|
"encoding/json"
|
|
"strconv"
|
|
)
|
|
|
|
type SystemConfigService struct {
|
|
configRepo *repository.SystemConfigRepository
|
|
}
|
|
|
|
func NewSystemConfigService(configRepo *repository.SystemConfigRepository) *SystemConfigService {
|
|
return &SystemConfigService{
|
|
configRepo: configRepo,
|
|
}
|
|
}
|
|
|
|
type ConfigCategory struct {
|
|
Name string `json:"name"`
|
|
Label string `json:"label"`
|
|
Configs []*domain.SystemConfig `json:"configs"`
|
|
}
|
|
|
|
func (s *SystemConfigService) GetPublicConfigs(ctx context.Context) ([]*ConfigCategory, error) {
|
|
configs, err := s.configRepo.GetAllPublic(ctx)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return s.groupByCategory(configs), nil
|
|
}
|
|
|
|
func (s *SystemConfigService) GetAllConfigs(ctx context.Context) ([]*ConfigCategory, error) {
|
|
configs, err := s.configRepo.GetAll(ctx)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return s.groupByCategory(configs), nil
|
|
}
|
|
|
|
func (s *SystemConfigService) GetConfig(ctx context.Context, key string) (*domain.SystemConfig, error) {
|
|
return s.configRepo.GetByKey(ctx, key)
|
|
}
|
|
|
|
func (s *SystemConfigService) GetConfigsByKeys(ctx context.Context, keys []string) (map[string]*domain.SystemConfig, error) {
|
|
return s.configRepo.GetByKeys(ctx, keys)
|
|
}
|
|
|
|
func (s *SystemConfigService) UpdateConfig(ctx context.Context, key string, value string, userID int64) error {
|
|
config, err := s.configRepo.GetByKey(ctx, key)
|
|
if err != nil {
|
|
return fmt.Errorf("配置不存在: %s", key)
|
|
}
|
|
|
|
if !config.IsEditable {
|
|
return fmt.Errorf("配置不允许编辑: %s", key)
|
|
}
|
|
|
|
// 验证配置值
|
|
if err := s.validateConfigValue(config, value); err != nil {
|
|
return err
|
|
}
|
|
|
|
update := &domain.SystemConfigUpdate{
|
|
ConfigValue: value,
|
|
UpdatedBy: userID,
|
|
}
|
|
|
|
return s.configRepo.Update(ctx, key, update)
|
|
}
|
|
|
|
func (s *SystemConfigService) GetConfigValue(ctx context.Context, key string, defaultValue interface{}) (interface{}, error) {
|
|
config, err := s.configRepo.GetByKey(ctx, key)
|
|
if err != nil {
|
|
if errors.Is(err, gorm.ErrRecordNotFound) {
|
|
return defaultValue, nil
|
|
}
|
|
return nil, err
|
|
}
|
|
|
|
return s.parseConfigValue(config), nil
|
|
}
|
|
|
|
func (s *SystemConfigService) GetString(ctx context.Context, key string, defaultValue string) (string, error) {
|
|
value, err := s.GetConfigValue(ctx, key, defaultValue)
|
|
if err != nil {
|
|
return defaultValue, err
|
|
}
|
|
|
|
if str, ok := value.(string); ok {
|
|
return str, nil
|
|
}
|
|
return defaultValue, nil
|
|
}
|
|
|
|
func (s *SystemConfigService) GetInt(ctx context.Context, key string, defaultValue int) (int, error) {
|
|
value, err := s.GetConfigValue(ctx, key, defaultValue)
|
|
if err != nil {
|
|
return defaultValue, err
|
|
}
|
|
|
|
if num, ok := value.(int); ok {
|
|
return num, nil
|
|
}
|
|
return defaultValue, nil
|
|
}
|
|
|
|
func (s *SystemConfigService) GetBool(ctx context.Context, key string, defaultValue bool) (bool, error) {
|
|
value, err := s.GetConfigValue(ctx, key, defaultValue)
|
|
if err != nil {
|
|
return defaultValue, err
|
|
}
|
|
|
|
if b, ok := value.(bool); ok {
|
|
return b, nil
|
|
}
|
|
return defaultValue, nil
|
|
}
|
|
|
|
// 辅助方法
|
|
|
|
func (s *SystemConfigService) groupByCategory(configs []*domain.SystemConfig) []*ConfigCategory {
|
|
categoryMap := make(map[string]*ConfigCategory)
|
|
categoryLabels := map[string]string{
|
|
"system": "系统设置",
|
|
"auth": "认证设置",
|
|
"notification": "通知设置",
|
|
"security": "安全设置",
|
|
"logging": "日志设置",
|
|
}
|
|
|
|
for _, config := range configs {
|
|
if _, exists := categoryMap[config.Category]; !exists {
|
|
categoryMap[config.Category] = &ConfigCategory{
|
|
Name: config.Category,
|
|
Label: categoryLabels[config.Category],
|
|
}
|
|
}
|
|
categoryMap[config.Category].Configs = append(categoryMap[config.Category].Configs, config)
|
|
}
|
|
|
|
var result []*ConfigCategory
|
|
for _, category := range categoryMap {
|
|
result = append(result, category)
|
|
}
|
|
|
|
return result
|
|
}
|
|
|
|
func (s *SystemConfigService) validateConfigValue(config *domain.SystemConfig, value string) error {
|
|
switch config.ConfigType {
|
|
case "number":
|
|
_, err := strconv.Atoi(value)
|
|
if err != nil {
|
|
return fmt.Errorf("配置值必须是数字: %s", value)
|
|
}
|
|
case "boolean":
|
|
if value != "true" && value != "false" {
|
|
return fmt.Errorf("配置值必须是 true 或 false: %s", value)
|
|
}
|
|
case "json":
|
|
var js interface{}
|
|
if err := json.Unmarshal([]byte(value), &js); err != nil {
|
|
return fmt.Errorf("配置值必须是有效的JSON: %s", value)
|
|
}
|
|
}
|
|
|
|
// TODO: 实现 validation_rule 的验证逻辑
|
|
|
|
return nil
|
|
}
|
|
|
|
func (s *SystemConfigService) parseConfigValue(config *domain.SystemConfig) interface{} {
|
|
switch config.ConfigType {
|
|
case "number":
|
|
if num, err := strconv.Atoi(config.ConfigValue); err == nil {
|
|
return num
|
|
}
|
|
case "boolean":
|
|
return config.ConfigValue == "true"
|
|
case "json":
|
|
var js interface{}
|
|
if err := json.Unmarshal([]byte(config.ConfigValue), &js); err == nil {
|
|
return js
|
|
}
|
|
}
|
|
|
|
return config.ConfigValue
|
|
}
|
|
```
|
|
|
|
**5. Handler层**
|
|
|
|
```go
|
|
// internal/api/handler/system_config_handler.go
|
|
package handler
|
|
|
|
import (
|
|
"net/http"
|
|
"d:/project/internal/service"
|
|
"github.com/gin-gonic/gin"
|
|
)
|
|
|
|
type SystemConfigHandler struct {
|
|
configService *service.SystemConfigService
|
|
}
|
|
|
|
func NewSystemConfigHandler(configService *service.SystemConfigService) *SystemConfigHandler {
|
|
return &SystemConfigHandler{
|
|
configService: configService,
|
|
}
|
|
}
|
|
|
|
type UpdateConfigRequest struct {
|
|
ConfigValue string `json:"config_value" binding:"required"`
|
|
}
|
|
|
|
// GetPublicConfigs 获取公开配置(前端可见)
|
|
func (h *SystemConfigHandler) GetPublicConfigs(c *gin.Context) {
|
|
configs, err := h.configService.GetPublicConfigs(c.Request.Context())
|
|
if err != nil {
|
|
c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
|
|
return
|
|
}
|
|
|
|
c.JSON(http.StatusOK, gin.H{
|
|
"data": configs,
|
|
})
|
|
}
|
|
|
|
// GetAllConfigs 获取所有配置(管理员)
|
|
func (h *SystemConfigHandler) GetAllConfigs(c *gin.Context) {
|
|
configs, err := h.configService.GetAllConfigs(c.Request.Context())
|
|
if err != nil {
|
|
c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
|
|
return
|
|
}
|
|
|
|
c.JSON(http.StatusOK, gin.H{
|
|
"data": configs,
|
|
})
|
|
}
|
|
|
|
// UpdateConfig 更新配置
|
|
func (h *SystemConfigHandler) UpdateConfig(c *gin.Context) {
|
|
key := c.Param("key")
|
|
|
|
var req UpdateConfigRequest
|
|
if err := c.ShouldBindJSON(&req); err != nil {
|
|
c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
|
|
return
|
|
}
|
|
|
|
// 从上下文获取用户ID
|
|
userID, exists := c.Get("user_id")
|
|
if !exists {
|
|
c.JSON(http.StatusUnauthorized, gin.H{"error": "未认证"})
|
|
return
|
|
}
|
|
|
|
userIDInt, ok := userID.(int64)
|
|
if !ok {
|
|
c.JSON(http.StatusInternalServerError, gin.H{"error": "用户ID类型错误"})
|
|
return
|
|
}
|
|
|
|
err := h.configService.UpdateConfig(c.Request.Context(), key, req.ConfigValue, userIDInt)
|
|
if err != nil {
|
|
c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
|
|
return
|
|
}
|
|
|
|
c.JSON(http.StatusOK, gin.H{
|
|
"message": "配置更新成功",
|
|
})
|
|
}
|
|
|
|
// GetConfig 获取单个配置
|
|
func (h *SystemConfigHandler) GetConfig(c *gin.Context) {
|
|
key := c.Param("key")
|
|
|
|
config, err := h.configService.GetConfig(c.Request.Context(), key)
|
|
if err != nil {
|
|
c.JSON(http.StatusNotFound, gin.H{"error": "配置不存在"})
|
|
return
|
|
}
|
|
|
|
c.JSON(http.StatusOK, gin.H{
|
|
"data": config,
|
|
})
|
|
}
|
|
```
|
|
|
|
**6. 路由注册**
|
|
|
|
```go
|
|
// internal/api/router/router.go
|
|
// 添加系统设置路由
|
|
configGroup := apiV1.Group("/system")
|
|
configGroup.Use(middleware.RequireAuth())
|
|
configGroup.Use(middleware.RequireAdmin()) // 管理员权限
|
|
|
|
systemConfigHandler := handler.NewSystemConfigHandler(systemConfigService)
|
|
|
|
configGroup.GET("/configs/public", systemConfigHandler.GetPublicConfigs)
|
|
configGroup.GET("/configs", systemConfigHandler.GetAllConfigs)
|
|
configGroup.GET("/configs/:key", systemConfigHandler.GetConfig)
|
|
configGroup.PUT("/configs/:key", systemConfigHandler.UpdateConfig)
|
|
```
|
|
|
|
**7. 启动注入**
|
|
|
|
```go
|
|
// cmd/server/main.go
|
|
// 初始化系统配置
|
|
systemConfigRepo := repository.NewSystemConfigRepository(db.DB)
|
|
systemConfigService := service.NewSystemConfigService(systemConfigRepo)
|
|
|
|
// 注入到其他需要使用配置的服务中
|
|
// authService.SetConfigService(systemConfigService)
|
|
```
|
|
|
|
**验收标准**
|
|
- [ ] 数据库表创建成功
|
|
- [ ] 默认配置初始化成功
|
|
- [ ] GET /api/v1/system/configs/public 返回公开配置
|
|
- [ ] GET /api/v1/system/configs 返回所有配置(需管理员权限)
|
|
- [ ] PUT /api/v1/system/configs/:key 更新配置成功
|
|
- [ ] 非可编辑配置不允许更新
|
|
- [ ] 单元测试覆盖率达到80%
|
|
- [ ] API文档完整
|
|
|
|
---
|
|
|
|
#### GAP-INT-001: 设备信任检查接线
|
|
|
|
**问题描述**
|
|
- 设备信任的CRUD API已实现,但登录流程未使用
|
|
- 用户信任设备后,登录时仍要求2FA验证
|
|
|
|
**修复方案**
|
|
|
|
**1. 修改登录请求结构**
|
|
|
|
```go
|
|
// internal/service/auth.go
|
|
type LoginRequest struct {
|
|
Account string `json:"account" binding:"required"`
|
|
Password string `json:"password" binding:"required"`
|
|
Remember bool `json:"remember"`
|
|
DeviceID string `json:"device_id,omitempty"`
|
|
DeviceName string `json:"device_name,omitempty"`
|
|
DeviceOS string `json:"device_os,omitempty"`
|
|
DeviceBrowser string `json:"device_browser,omitempty"`
|
|
}
|
|
```
|
|
|
|
**2. 登录时自动注册设备**
|
|
|
|
```go
|
|
// internal/service/auth.go
|
|
func (s *AuthService) generateLoginResponse(ctx context.Context, user *domain.User, req *LoginRequest) (*LoginResponse, error) {
|
|
// ... token生成逻辑 ...
|
|
|
|
// 自动注册/更新设备记录
|
|
if s.deviceRepo != nil && req.DeviceID != "" {
|
|
s.bestEffortRegisterDevice(ctx, user.ID, req)
|
|
}
|
|
|
|
// ... 返回逻辑 ...
|
|
}
|
|
|
|
func (s *AuthService) bestEffortRegisterDevice(ctx context.Context, userID int64, req *LoginRequest) {
|
|
device := &domain.Device{
|
|
UserID: userID,
|
|
DeviceID: req.DeviceID,
|
|
DeviceName: req.DeviceName,
|
|
OS: req.DeviceOS,
|
|
Browser: req.DeviceBrowser,
|
|
LastSeenAt: time.Now(),
|
|
IsTrusted: false,
|
|
TrustExpiresAt: nil,
|
|
}
|
|
|
|
// 尝试获取现有设备
|
|
existing, err := s.deviceRepo.GetByDeviceID(ctx, userID, req.DeviceID)
|
|
if err == nil && existing != nil {
|
|
// 更新设备信息
|
|
existing.DeviceName = req.DeviceName
|
|
existing.OS = req.DeviceOS
|
|
existing.Browser = req.DeviceBrowser
|
|
existing.LastSeenAt = time.Now()
|
|
s.deviceRepo.Update(ctx, existing)
|
|
} else {
|
|
// 创建新设备
|
|
s.deviceRepo.Create(ctx, device)
|
|
}
|
|
}
|
|
```
|
|
|
|
**3. 2FA验证时检查设备信任**
|
|
|
|
```go
|
|
// internal/service/auth.go
|
|
func (s *AuthService) VerifyTOTP(ctx context.Context, req *VerifyTOTPRequest) error {
|
|
// 检查设备是否已信任
|
|
if req.DeviceID != "" && s.deviceRepo != nil {
|
|
device, err := s.deviceRepo.GetByDeviceID(ctx, req.UserID, req.DeviceID)
|
|
if err == nil && device != nil && device.IsTrusted {
|
|
// 检查信任是否过期
|
|
if device.TrustExpiresAt == nil || device.TrustExpiresAt.After(time.Now()) {
|
|
// 设备已信任且未过期,跳过2FA验证
|
|
return nil
|
|
}
|
|
}
|
|
}
|
|
|
|
// 正常TOTP验证流程
|
|
// ...
|
|
}
|
|
```
|
|
|
|
**验收标准**
|
|
- [ ] 登录时自动创建/更新设备记录
|
|
- [ ] 设备ID从登录请求中正确提取
|
|
- [ ] 信任设备的2FA验证被跳过
|
|
- [ ] 信任过期后重新要求2FA
|
|
- [ ] 单元测试覆盖
|
|
|
|
---
|
|
|
|
#### GAP-INT-002: 角色继承权限接线
|
|
|
|
**问题描述**
|
|
- 角色继承的Repository和Service已实现
|
|
- 但auth middleware未使用继承权限
|
|
|
|
**修复方案**
|
|
|
|
**1. 修改auth middleware**
|
|
|
|
```go
|
|
// internal/api/middleware/auth.go
|
|
func (m *AuthMiddleware) getUserPermissions(ctx context.Context, userID int64) ([]string, error) {
|
|
// 现状: 直接查询user_role_permissions表
|
|
|
|
// 修改: 调用roleService.GetRolePermissions(含继承)
|
|
userRoles, err := m.userRepo.GetRoles(ctx, userID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
var allPermissions []string
|
|
seen := make(map[string]bool)
|
|
|
|
for _, role := range userRoles {
|
|
permissions, err := m.roleService.GetRolePermissions(ctx, role.ID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
for _, perm := range permissions {
|
|
if !seen[perm.Code] {
|
|
seen[perm.Code] = true
|
|
allPermissions = append(allPermissions, perm.Code)
|
|
}
|
|
}
|
|
}
|
|
|
|
return allPermissions, nil
|
|
}
|
|
```
|
|
|
|
**2. 修改JWT生成逻辑**
|
|
|
|
```go
|
|
// internal/service/auth.go
|
|
func (s *AuthService) generateLoginResponse(ctx context.Context, user *domain.User, req *LoginRequest) (*LoginResponse, error) {
|
|
// ...
|
|
|
|
// 获取用户权限(含继承)
|
|
permissions, err := s.getUserPermissions(ctx, user.ID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
// 生成JWT时包含继承权限
|
|
token := jwt.NewWithClaims(jwt.SigningMethodHS256, jwt.MapClaims{
|
|
"user_id": user.ID,
|
|
"username": user.Username,
|
|
"email": user.Email,
|
|
"role_ids": user.RoleIDs,
|
|
"permissions": permissions,
|
|
"exp": time.Now().Add(tokenExpiry).Unix(),
|
|
"iat": time.Now().Unix(),
|
|
})
|
|
|
|
// ...
|
|
}
|
|
```
|
|
|
|
**验收标准**
|
|
- [ ] 用户持子角色能访问父角色权限
|
|
- [ ] JWT中的permissions包含继承权限
|
|
- [ ] auth middleware正确验证继承权限
|
|
- [ ] 单元测试覆盖角色继承场景
|
|
|
|
---
|
|
|
|
### 2.3 前端断链修复(Sprint 13)
|
|
|
|
**将在专家评审后详细设计前端页面**
|
|
|
|
---
|
|
|
|
## 三、修复验收标准
|
|
|
|
### 3.1 通用验收标准
|
|
|
|
- [ ] 代码审查通过
|
|
- [ ] 单元测试覆盖率 > 80%
|
|
- [ ] 集成测试通过
|
|
- [ ] API文档完整
|
|
- [ ] 无已知安全漏洞
|
|
- [ ] 性能测试达标
|
|
|
|
### 3.2 特定验收标准
|
|
|
|
**后端API修复**
|
|
- [ ] API符合RESTful规范
|
|
- [ ] 错误处理完整
|
|
- [ ] 输入验证完整
|
|
- [ ] 权限校验完整
|
|
- [ ] 数据库索引合理
|
|
|
|
**前端页面修复**
|
|
- [ ] UI/UX符合设计规范
|
|
- [ ] 交互流程顺畅
|
|
- [ ] 错误提示友好
|
|
- [ ] 加载状态清晰
|
|
- [ ] 响应式设计良好
|
|
|
|
---
|
|
|
|
## 四、风险与依赖
|
|
|
|
### 4.1 技术风险
|
|
|
|
| 风险 | 影响 | 概率 | 缓解措施 |
|
|
|------|------|------|---------|
|
|
| 系统设置API影响范围大 | 高 | 中 | 分阶段发布,先灰度 |
|
|
| 设备信任逻辑复杂 | 中 | 高 | 充分测试,回滚方案 |
|
|
| 角色继承权限链路长 | 中 | 中 | 详细测试,代码审查 |
|
|
|
|
### 4.2 资源风险
|
|
|
|
| 风险 | 影响 | 概率 | 缓解措施 |
|
|
|------|------|------|---------|
|
|
| 前端开发资源紧张 | 高 | 中 | 优先P0功能,延期P2 |
|
|
| 测试资源不足 | 中 | 中 | 自动化测试,专家评审 |
|
|
|
|
### 4.3 依赖项
|
|
|
|
- [ ] Sprint 12后端开发需要2名后端工程师
|
|
- [ ] Sprint 13前端开发需要1名前端工程师
|
|
- [ ] 专家评审需要各领域专家参与
|
|
|
|
---
|
|
|
|
## 五、进度跟踪
|
|
|
|
### 5.1 每日跟踪
|
|
|
|
```markdown
|
|
## 设计断链修复进度 - 2026-04-01
|
|
|
|
### 今日完成
|
|
- [x] 完成系统设置API设计
|
|
- [x] 完成设备信任检查设计
|
|
|
|
### 今日进行中
|
|
- [ ] 系统设置API实现 (30%)
|
|
- [ ] 角色继承权限修复 (20%)
|
|
|
|
### 今日计划
|
|
- [ ] 完成系统设置API Repository层
|
|
- [ ] 完成设备信任检查Handler层
|
|
- [ ] 开始角色继承权限修复
|
|
|
|
### 阻碍
|
|
- 无
|
|
|
|
### 明日计划
|
|
- [ ] 完成系统设置API Service层
|
|
- [ ] 完成系统设置API Handler层
|
|
- [ ] 完成角色继承权限修复
|
|
```
|
|
|
|
---
|
|
|
|
## 六、总结
|
|
|
|
本修复计划旨在:
|
|
1. ✅ **消除设计断链**: 修复12个设计断链问题
|
|
2. ✅ **确保功能完整**: 补齐缺失的页面和API
|
|
3. ✅ **提升用户体验**: 实现完整的设备信任和角色继承
|
|
4. ✅ **提高系统安全性**: 加强密码和登录安全
|
|
|
|
预期成果:
|
|
- 设计断链修复率: 100%
|
|
- 功能完整性: 95%+
|
|
- 用户满意度提升: 30%
|
|
|
|
---
|
|
|
|
*本文档由高级项目经理 Agent 编制,2026-04-01*
|