761 lines
24 KiB
Go
761 lines
24 KiB
Go
package doc
|
||
|
||
import (
|
||
"app/cfg"
|
||
M "app/models"
|
||
"bytes"
|
||
"context"
|
||
"encoding/json"
|
||
"fmt"
|
||
"log"
|
||
"os"
|
||
"path/filepath"
|
||
"strings"
|
||
"sync"
|
||
"time"
|
||
|
||
"github.com/ledongthuc/pdf"
|
||
"github.com/openai/openai-go"
|
||
"github.com/openai/openai-go/option"
|
||
"github.com/xeipuuv/gojsonschema"
|
||
|
||
"github.com/unidoc/unioffice/document"
|
||
)
|
||
|
||
// DemandTree 表示一个完整的需求树
|
||
type DemandTree struct {
|
||
Demands []DemandNode `json:"demands" jsonschema:"required,description=需求树列表"`
|
||
HasMore bool `json:"has_more" jsonschema:"required,description=是否还有更多需求需要继续在下一次输出中继续输出"`
|
||
AnalysisPercent int `json:"analysis_percent" jsonschema:"required,description=估计的分析进度百分比，范围是0-100，不一定递增，可以调整，比如发现增长过快的时候可以减少，只有全部解析完毕才可以到100"`
|
||
}
|
||
type DemandNode struct {
|
||
ReqID string `json:"id" jsonschema:"required,description=需求ID，格式为REQ-数字"`
|
||
Title string `json:"title" jsonschema:"required,description=需求标题"`
|
||
Description string `json:"description" jsonschema:"required,description=需求详细描述"`
|
||
Priority string `json:"priority" jsonschema:"enum=高,enum=中,enum=低,description=需求优先级"`
|
||
Type string `json:"type" jsonschema:"enum=功能需求,enum=非功能需求,enum=业务需求,description=需求类型"`
|
||
Status string `json:"status" jsonschema:"enum=待实现,enum=开发中,enum=已完成,enum=已验收,description=需求状态"`
|
||
ParentReqID string `json:"parent_req_id,omitempty" jsonschema:"description=父需求ID，如果是顶级需求则为空"`
|
||
Children []DemandNode `json:"children,omitempty" jsonschema:"description=子需求列表"`
|
||
}
|
||
|
||
// 同样修改 SimpleDemandNode
|
||
type SimpleDemandNode struct {
|
||
ReqID string `json:"id" jsonschema:"required,description=需求ID，格式为REQ-数字"`
|
||
Title string `json:"title" jsonschema:"required,description=需求标题"`
|
||
Description string `json:"description" jsonschema:"required,description=需求详细描述"`
|
||
Priority string `json:"priority" jsonschema:"enum=高,enum=中,enum=低,description=需求优先级"`
|
||
Type string `json:"type" jsonschema:"enum=功能需求,enum=非功能需求,enum=业务需求,description=需求类型"`
|
||
Status string `json:"status" jsonschema:"enum=待实现,enum=开发中,enum=已完成,enum=已验收,description=需求状态"`
|
||
ParentReqID string `json:"parent_req_id,omitempty" jsonschema:"description=父需求ID，如果是顶级需求则为空"`
|
||
Children []map[string]string `json:"children,omitempty" jsonschema:"description=子需求列表"`
|
||
}
|
||
|
||
// 简化的需求树结构，用于生成 Schema
|
||
type SimpleDemandTree struct {
|
||
Demands []SimpleDemandNode `json:"demands" jsonschema:"required,description=需求树列表"`
|
||
HasMore bool `json:"has_more" jsonschema:"required,description=是否还有更多需求需要继续在下一次输出中继续输出"`
|
||
AnalysisPercent int `json:"analysis_percent" jsonschema:"required,description=估计的分析进度百分比，范围是0-100，不一定递增，可以调整，比如发现增长过快的时候可以减少，只有全部解析完毕才可以到100"`
|
||
}
|
||
|
||
// DemandChatHistory 表示与大模型的对话历史
|
||
type DemandChatHistory struct {
|
||
Messages []openai.ChatCompletionMessageParamUnion
|
||
DocContent string
|
||
Schema string
|
||
}
|
||
|
||
// DemandAnalyzer 处理需求文档分析
|
||
type DemandAnalyzer struct {
|
||
client *openai.Client
|
||
logger *log.Logger
|
||
}
|
||
|
||
// NewDemandAnalyzer 创建一个新的需求分析器实例
|
||
func NewDemandAnalyzer() (*DemandAnalyzer, error) {
|
||
client := openai.NewClient(
|
||
option.WithAPIKey("sk-0213c70194624703a1d0d80e0f762b0e"),
|
||
option.WithBaseURL("https://dashscope.aliyuncs.com/compatible-mode/v1/"),
|
||
)
|
||
fmt.Println("需求分析器初始化成功")
|
||
return &DemandAnalyzer{
|
||
client: client,
|
||
logger: setupLogger(),
|
||
}, nil
|
||
}
|
||
|
||
// generateDemandJSONSchema 生成需求树的JSON Schema
|
||
// func generateDemandJSONSchema() ([]byte, error) {
|
||
// reflector := jsonschema.Reflector{
|
||
// RequiredFromJSONSchemaTags: true,
|
||
// AllowAdditionalProperties: true,
|
||
// DoNotReference: true,
|
||
// }
|
||
// schema := reflector.Reflect(&SimpleDemandTree{})
|
||
// // schema := reflector.Reflect(&DemandTree{})
|
||
|
||
// return json.MarshalIndent(schema, "", " ")
|
||
// }
|
||
func generateDemandJSONSchema() ([]byte, error) {
|
||
// 使用预定义的 JSON Schema 字符串，手动处理递归引用
|
||
schemaStr := `{
|
||
"type": "object",
|
||
"properties": {
|
||
"demands": {
|
||
"type": "array",
|
||
"description": "需求树列表",
|
||
"items": {
|
||
"$ref": "#/definitions/demandNode"
|
||
}
|
||
},
|
||
"has_more": {
|
||
"type": "boolean",
|
||
"description": "是否还有更多需求需要继续在下一次输出中继续输出"
|
||
},
|
||
"analysis_percent": {
|
||
"type": "integer",
|
||
"description": "估计的分析进度百分比，范围是0-100，不一定递增，可以调整，比如发现增长过快的时候可以减少，只有全部解析完毕才可以到100"
|
||
}
|
||
},
|
||
"required": ["demands", "has_more", "analysis_percent"],
|
||
"definitions": {
|
||
"demandNode": {
|
||
"type": "object",
|
||
"properties": {
|
||
"id": {
|
||
"type": "string",
|
||
"description": "需求ID，格式为REQ-数字"
|
||
},
|
||
"title": {
|
||
"type": "string",
|
||
"description": "需求标题"
|
||
},
|
||
"description": {
|
||
"type": "string",
|
||
"description": "需求详细描述"
|
||
},
|
||
"priority": {
|
||
"type": "string",
|
||
"enum": ["高", "中", "低"],
|
||
"description": "需求优先级"
|
||
},
|
||
"type": {
|
||
"type": "string",
|
||
"enum": ["功能需求","性能需求","安全需求", "合规性需求", "可靠性需求"],
|
||
"description": "需求类型"
|
||
},
|
||
"status": {
|
||
"type": "string",
|
||
"enum": ["待实现", "开发中", "已完成", "已测试"],
|
||
"description": "需求状态"
|
||
},
|
||
"parent_req_id": {
|
||
"type": "string",
|
||
"description": "父需求ID，如果是顶级需求则为空"
|
||
},
|
||
"children": {
|
||
"type": "array",
|
||
"description": "子需求列表，每个子需求也是一个demandNode，而且子需求也可能有自己的子需求列表，以此类推",
|
||
"items": {
|
||
"$ref": "#/definitions/demandNode"
|
||
}
|
||
}
|
||
},
|
||
"required": ["id", "title", "description"]
|
||
}
|
||
}
|
||
}`
|
||
|
||
// 解析 JSON 以确保格式正确
|
||
var schema interface{}
|
||
if err := json.Unmarshal([]byte(schemaStr), &schema); err != nil {
|
||
return nil, fmt.Errorf("解析预定义 Schema 失败: %v", err)
|
||
}
|
||
|
||
// 重新格式化为美观的 JSON
|
||
return json.MarshalIndent(schema, "", " ")
|
||
}
|
||
|
||
// validateDemandJSON 验证JSON响应是否符合Schema
|
||
func validateDemandJSON(data []byte) error {
|
||
schema, err := generateDemandJSONSchema()
|
||
if err != nil {
|
||
return fmt.Errorf("生成Schema失败: %v", err)
|
||
}
|
||
|
||
schemaLoader := gojsonschema.NewBytesLoader(schema)
|
||
documentLoader := gojsonschema.NewBytesLoader(data)
|
||
|
||
result, err := gojsonschema.Validate(schemaLoader, documentLoader)
|
||
if err != nil {
|
||
return fmt.Errorf("验证错误: %v", err)
|
||
}
|
||
|
||
if !result.Valid() {
|
||
var errors []string
|
||
for _, desc := range result.Errors() {
|
||
errors = append(errors, desc.String())
|
||
}
|
||
return fmt.Errorf("无效的JSON: %v", errors)
|
||
}
|
||
|
||
return nil
|
||
}
|
||
|
||
// cleanDemandJSONResponse 清理并验证LLM响应
|
||
func cleanDemandJSONResponse(response string) (string, error) {
|
||
// 查找第一个 { 和最后一个 }
|
||
start := 0
|
||
end := len(response)
|
||
|
||
for i := 0; i < len(response); i++ {
|
||
if response[i] == '{' {
|
||
start = i
|
||
break
|
||
}
|
||
}
|
||
|
||
for i := len(response) - 1; i >= 0; i-- {
|
||
if response[i] == '}' {
|
||
end = i + 1
|
||
break
|
||
}
|
||
}
|
||
|
||
if start >= end {
|
||
return "", fmt.Errorf("无效的JSON结构")
|
||
}
|
||
|
||
jsonStr := response[start:end]
|
||
|
||
// 验证JSON
|
||
if err := validateDemandJSON([]byte(jsonStr)); err != nil {
|
||
return "", fmt.Errorf("JSON验证失败: %v", err)
|
||
}
|
||
|
||
return jsonStr, nil
|
||
}
|
||
|
||
// repairDemandJSON 修复格式错误的JSON
|
||
// 修改 repairDemandJSON 方法
|
||
func (a *DemandAnalyzer) repairDemandJSON(ctx context.Context, response string, originalErr error) (string, error) {
|
||
prompt := fmt.Sprintf(`你是一个JSON修复专家。我有一个JSON字符串，但它存在一些问题无法解析。
|
||
|
||
原始JSON:
|
||
%s
|
||
|
||
错误信息:
|
||
%v
|
||
|
||
请修复这个JSON，使其符合以下要求：
|
||
1. 所有字段名必须使用双引号
|
||
2. 字符串值必须使用双引号
|
||
3. 不要添加或删除字段，只修复格式问题
|
||
4. 如果parent_req_id是null，替换为空字符串""
|
||
5. 确保demands是一个数组，即使为空也应为[]
|
||
6. 确保has_more是一个布尔值
|
||
7. 结果必须是有效的JSON
|
||
|
||
请只返回修复后的JSON，不要包含任何其他解释或评论。`, response, originalErr)
|
||
|
||
stream := a.client.Chat.Completions.NewStreaming(ctx, openai.ChatCompletionNewParams{
|
||
Messages: openai.F([]openai.ChatCompletionMessageParamUnion{
|
||
openai.UserMessage(prompt),
|
||
}),
|
||
Model: openai.F("qwen-plus"),
|
||
})
|
||
|
||
var responseBuilder strings.Builder
|
||
for stream.Next() {
|
||
chunk := stream.Current()
|
||
for _, choice := range chunk.Choices {
|
||
responseBuilder.WriteString(choice.Delta.Content)
|
||
}
|
||
}
|
||
|
||
if err := stream.Err(); err != nil {
|
||
return "", fmt.Errorf("JSON修复API调用失败: %v", err)
|
||
}
|
||
|
||
fixed := responseBuilder.String()
|
||
|
||
// 关键修复：移除可能的Markdown代码块标记
|
||
fixed = strings.TrimSpace(fixed)
|
||
|
||
// 检查并移除开头的Markdown标记
|
||
if strings.HasPrefix(fixed, "```") {
|
||
// 找到第一行结束位置
|
||
firstLineEnd := strings.Index(fixed, "\n")
|
||
if firstLineEnd != -1 {
|
||
// 跳过第一行（包含```json或```）
|
||
fixed = fixed[firstLineEnd+1:]
|
||
} else {
|
||
// 如果没有换行，可能整个字符串都是标记，返回错误
|
||
return "", fmt.Errorf("修复后的JSON格式异常")
|
||
}
|
||
}
|
||
|
||
// 检查并移除结尾的Markdown标记
|
||
if strings.HasSuffix(fixed, "```") {
|
||
fixed = fixed[:len(fixed)-3]
|
||
}
|
||
|
||
// 再次去除前后空白
|
||
fixed = strings.TrimSpace(fixed)
|
||
|
||
// 验证修复后的JSON是否有效
|
||
var testObj map[string]interface{}
|
||
if err := json.Unmarshal([]byte(fixed), &testObj); err != nil {
|
||
return "", fmt.Errorf("修复后的JSON仍然无效: %v", err)
|
||
}
|
||
|
||
return fixed, nil
|
||
}
|
||
|
||
// func (da *DemandAnalyzer) repairDemandJSON(ctx context.Context, malformedJSON string, originalError error) (string, error) {
|
||
// prompt := fmt.Sprintf(`修复这个格式错误的JSON，错误信息: %v
|
||
|
||
// 需要修复的JSON:
|
||
// %s
|
||
|
||
// 只返回修复后的JSON，不要有任何解释。`, originalError, malformedJSON)
|
||
|
||
// var responseBuilder strings.Builder
|
||
|
||
// stream := da.client.Chat.Completions.NewStreaming(ctx, openai.ChatCompletionNewParams{
|
||
// Messages: openai.F([]openai.ChatCompletionMessageParamUnion{
|
||
// openai.UserMessage(prompt),
|
||
// }),
|
||
// Model: openai.F("qwen-plus"),
|
||
// })
|
||
|
||
// for stream.Next() {
|
||
// chunk := stream.Current()
|
||
// for _, choice := range chunk.Choices {
|
||
// responseBuilder.WriteString(choice.Delta.Content)
|
||
// }
|
||
// }
|
||
|
||
// if err := stream.Err(); err != nil {
|
||
// return "", fmt.Errorf("发送消息失败: %v", err)
|
||
// }
|
||
|
||
// fixed := responseBuilder.String()
|
||
// if fixed == "" {
|
||
// return "", fmt.Errorf("没有修复响应")
|
||
// }
|
||
|
||
// return fixed, nil
|
||
// }
|
||
|
||
// extractDemands 从文档内容中提取需求信息
|
||
func (da *DemandAnalyzer) extractDemands(ctx context.Context, docContent string, doc *M.Doc) error {
|
||
schema, err := generateDemandJSONSchema()
|
||
if err != nil {
|
||
return fmt.Errorf("生成Schema失败: %v", err)
|
||
}
|
||
da.logger.Printf("需求JSON Schema:\n%s", schema)
|
||
|
||
// 初始化对话历史
|
||
history := &DemandChatHistory{
|
||
Messages: make([]openai.ChatCompletionMessageParamUnion, 0),
|
||
}
|
||
|
||
// 初始化对话，发送文档内容和schema
|
||
initialPrompt := fmt.Sprintf(`你是一个需求文档分析助手。你的任务是从文档中提取需求信息并构建需求树。
|
||
请从以下文档中提取所有需求信息，包括需求ID、标题、描述、优先级、类型和状态。
|
||
请确保完整提取每个需求的所有信息，并正确构建需求的层级关系。
|
||
|
||
如果文档内容较多，你可以分批次输出，每次输出一部分需求信息:
|
||
1. 如果还有更多需求未处理，设置 "has_more": true
|
||
2. 在后续输出中，继续提取剩余的需求，不要重复之前已输出的需求
|
||
3. 当所有需求都输出完成时，设置 "has_more": false
|
||
4. 每次输出时，设置 "analysis_percent" 表示估计的分析进度百分比
|
||
|
||
需求应该按照层级结构组织，主需求包含子需求，子需求可能还有更深层次的子需求，以此类推，需求树的深度没有限制。
|
||
对于每个子需求，请设置其 "parent_req_id" 为父需求的ID，这样可以明确表示需求之间的层级关系。
|
||
你可以在后续输出中继续为前面已输出的需求添加子需求，只需正确设置 "parent_req_id" 即可。
|
||
|
||
如果文档中包含多个独立的需求树或模块，请将它们作为独立的顶级需求节点输出。
|
||
每个需求都应该有一个唯一的req_id，格式为REQ-数字，例如REQ-001。
|
||
如果文档中没有明确的需求ID，请自动生成一个。
|
||
|
||
文档内容:
|
||
%s
|
||
|
||
JSON Schema:
|
||
%s
|
||
|
||
请严格按照schema格式输出，确保是有效的JSON格式。输出的JSON必须符合以上schema的规范。`, docContent, string(schema))
|
||
|
||
totalDemands := 0 // 用于跟踪总共处理的需求数量
|
||
maxRetries := 10
|
||
|
||
// 添加初始消息到历史记录
|
||
history.Messages = append(history.Messages, openai.UserMessage(initialPrompt))
|
||
|
||
maxInitRetries := 3
|
||
var responseBuilder strings.Builder
|
||
var streamErr error
|
||
|
||
// 发送初始消息并重试
|
||
for i := 0; i < maxInitRetries; i++ {
|
||
responseBuilder.Reset()
|
||
stream := da.client.Chat.Completions.NewStreaming(ctx, openai.ChatCompletionNewParams{
|
||
Messages: openai.F(history.Messages),
|
||
Model: openai.F("qwen-plus"),
|
||
})
|
||
|
||
for stream.Next() {
|
||
chunk := stream.Current()
|
||
for _, choice := range chunk.Choices {
|
||
responseBuilder.WriteString(choice.Delta.Content)
|
||
}
|
||
}
|
||
|
||
if streamErr = stream.Err(); streamErr == nil {
|
||
break
|
||
}
|
||
time.Sleep(time.Second)
|
||
}
|
||
|
||
if streamErr != nil {
|
||
da.logger.Printf("发送初始消息失败，已重试: %v", streamErr)
|
||
return fmt.Errorf("发送初始消息失败: %v", streamErr)
|
||
}
|
||
|
||
response := responseBuilder.String()
|
||
// 添加模型的响应到历史记录
|
||
history.Messages = append(history.Messages, openai.AssistantMessage(response))
|
||
|
||
for {
|
||
// 休眠30秒以避免速率限制
|
||
time.Sleep(time.Second * 30)
|
||
|
||
da.logger.Printf("LLM响应:\n%s", response)
|
||
|
||
// 清理并验证响应
|
||
cleanedJSON, err := cleanDemandJSONResponse(response)
|
||
if err != nil {
|
||
// 尝试修复JSON
|
||
da.logger.Printf("尝试修复JSON: %v", err)
|
||
fixed, repairErr := da.repairDemandJSON(ctx, response, err)
|
||
if repairErr != nil {
|
||
return fmt.Errorf("JSON修复失败: %v (原始错误: %v)", repairErr, err)
|
||
}
|
||
da.logger.Printf("JSON已修复:\n%s", fixed)
|
||
cleanedJSON, err = cleanDemandJSONResponse(fixed)
|
||
if err != nil {
|
||
return fmt.Errorf("JSON验证失败: %v", err)
|
||
}
|
||
}
|
||
// 解析响应
|
||
var result DemandTree
|
||
if err := json.Unmarshal([]byte(cleanedJSON), &result); err != nil {
|
||
return fmt.Errorf("解析LLM响应失败: %v", err)
|
||
}
|
||
|
||
// 处理这一批次的需求
|
||
for _, demand := range result.Demands {
|
||
totalDemands += da.processDemandNode(demand, doc.ID, "")
|
||
}
|
||
|
||
// 更新文档处理进度
|
||
progress := result.AnalysisPercent
|
||
if err := cfg.DB().Model(doc).Update("analysis_percent", progress).Error; err != nil {
|
||
da.logger.Printf("更新进度失败: %v", err)
|
||
}
|
||
|
||
// 如果没有更多需求要处理，退出循环
|
||
if !result.HasMore {
|
||
break
|
||
}
|
||
|
||
// 使用chat history继续对话
|
||
followUpPrompt := `请继续提取剩余的需求信息，保持相同的输出格式。
|
||
请记住：
|
||
1. 不要重复之前已输出的需求，如果你想给之前的需求添加子需求，你可以设置 "parent_req_id" 为父需求的ID
|
||
2. 如果还有更多内容，添加 "has_more": true
|
||
3. 如果已经输出完所有内容，添加 "has_more": false
|
||
4. 请严格按照schema格式输出，确保是有效、完整的JSON格式。输出的JSON必须符合以上schema的规范，比如string类型的值要注意转义字符的使用。`
|
||
|
||
history.Messages = append(history.Messages, openai.UserMessage(followUpPrompt))
|
||
|
||
// 重试逻辑
|
||
for retry := 0; retry < maxRetries; retry++ {
|
||
responseBuilder.Reset()
|
||
stream := da.client.Chat.Completions.NewStreaming(ctx, openai.ChatCompletionNewParams{
|
||
Messages: openai.F(history.Messages),
|
||
Model: openai.F("qwen-plus"),
|
||
})
|
||
|
||
for stream.Next() {
|
||
chunk := stream.Current()
|
||
for _, choice := range chunk.Choices {
|
||
responseBuilder.WriteString(choice.Delta.Content)
|
||
}
|
||
}
|
||
|
||
if streamErr = stream.Err(); streamErr == nil {
|
||
response = responseBuilder.String()
|
||
history.Messages = append(history.Messages, openai.AssistantMessage(response))
|
||
break
|
||
}
|
||
|
||
da.logger.Printf("尝试 %d 失败: %v, 重试中...", retry+1, streamErr)
|
||
time.Sleep(time.Second * 30)
|
||
}
|
||
|
||
if streamErr != nil {
|
||
return fmt.Errorf("发送后续消息失败，已重试 %d 次: %v", maxRetries, streamErr)
|
||
}
|
||
}
|
||
|
||
return nil
|
||
}
|
||
|
||
// processDemandNode 递归处理需求节点及其子节点
|
||
func (da *DemandAnalyzer) processDemandNode(node DemandNode, docID string, parentID string) int {
|
||
count := 1 // 当前节点计数为1
|
||
var existingDemand M.Demand
|
||
if err := cfg.DB().Where("req_id = ? AND doc_id = ?", node.ReqID, docID).First(&existingDemand).Error; err == nil {
|
||
// 如果需求已存在，直接使用现有需求处理子节点
|
||
for _, child := range node.Children {
|
||
count += da.processDemandNode(child, docID, existingDemand.ID)
|
||
}
|
||
return count
|
||
}
|
||
|
||
// 计算当前节点的层级
|
||
level := 0
|
||
if parentID != "" {
|
||
// 如果有父节点，查询父节点的层级并加1
|
||
var parentDemand M.Demand
|
||
if err := cfg.DB().Where("id = ?", parentID).First(&parentDemand).Error; err == nil {
|
||
level = parentDemand.Level + 1
|
||
}
|
||
} else if node.ParentReqID != "" {
|
||
// 如果没有直接的父节点ID但有父需求ID，尝试通过ReqID查找父节点
|
||
var parentDemand M.Demand
|
||
if err := cfg.DB().Where("req_id = ? AND doc_id = ?", node.ParentReqID, docID).First(&parentDemand).Error; err == nil {
|
||
parentID = parentDemand.ID // 设置父节点ID
|
||
level = parentDemand.Level + 1
|
||
} else {
|
||
da.logger.Printf("通过ReqID查找父节点失败: %v, ReqID: %s", err, node.ParentReqID)
|
||
}
|
||
}
|
||
|
||
// 创建需求记录
|
||
demand := &M.Demand{
|
||
DocID: docID,
|
||
Description: node.Description,
|
||
ReqID: node.ReqID,
|
||
Priority: node.Priority,
|
||
Type: node.Type,
|
||
Status: node.Status,
|
||
ParentReqID: node.ParentReqID, // 添加父需求ID
|
||
Tree: M.Tree{
|
||
Name: node.Title,
|
||
ParentID: parentID,
|
||
Level: level,
|
||
},
|
||
}
|
||
|
||
if err := cfg.DB().Create(demand).Error; err != nil {
|
||
da.logger.Printf("创建需求记录失败: %v", err)
|
||
return count
|
||
}
|
||
|
||
// 递归处理子需求
|
||
for _, child := range node.Children {
|
||
count += da.processDemandNode(child, docID, demand.ID)
|
||
}
|
||
|
||
return count
|
||
}
|
||
|
||
// readDocContent 从文件中读取文档内容
|
||
func (da *DemandAnalyzer) readDocContent(filePath string) (string, error) {
|
||
ext := strings.ToLower(filepath.Ext(filePath))
|
||
|
||
switch ext {
|
||
case ".pdf":
|
||
return da.readPDF(filePath)
|
||
case ".txt":
|
||
return da.readTXT(filePath)
|
||
case ".docx":
|
||
return da.readDOCX(filePath)
|
||
default:
|
||
return "", fmt.Errorf("不支持的文件类型: %s", ext)
|
||
}
|
||
}
|
||
|
||
// readPDF 读取PDF文件内容
|
||
func (da *DemandAnalyzer) readPDF(filePath string) (string, error) {
|
||
f, r, err := pdf.Open(filePath)
|
||
if err != nil {
|
||
return "", fmt.Errorf("打开PDF文件失败: %v", err)
|
||
}
|
||
defer f.Close()
|
||
|
||
var buf bytes.Buffer
|
||
b, err := r.GetPlainText()
|
||
if err != nil {
|
||
return "", fmt.Errorf("读取PDF文本失败: %v", err)
|
||
}
|
||
|
||
buf.ReadFrom(b)
|
||
return buf.String(), nil
|
||
}
|
||
|
||
// readTXT 读取TXT文件内容
|
||
func (da *DemandAnalyzer) readTXT(filePath string) (string, error) {
|
||
content, err := os.ReadFile(filePath)
|
||
if err != nil {
|
||
return "", fmt.Errorf("读取TXT文件失败: %v", err)
|
||
}
|
||
return string(content), nil
|
||
}
|
||
|
||
// readDOCX 读取DOCX文件内容
|
||
func (da *DemandAnalyzer) readDOCX(filePath string) (string, error) {
|
||
// 使用 unidoc/unioffice 库读取 DOCX 文件
|
||
doc, err := document.Open(filePath)
|
||
if err != nil {
|
||
return "", fmt.Errorf("打开DOCX文件失败: %v", err)
|
||
}
|
||
|
||
var content strings.Builder
|
||
|
||
// 遍历所有段落并提取文本
|
||
for _, para := range doc.Paragraphs() {
|
||
for _, run := range para.Runs() {
|
||
content.WriteString(run.Text())
|
||
}
|
||
content.WriteString("\n") // 段落结束添加换行
|
||
}
|
||
|
||
return content.String(), nil
|
||
}
|
||
|
||
// DemandProcessor 处理需求文档的处理器
|
||
type DemandProcessor struct {
|
||
analyzer *DemandAnalyzer
|
||
tasks map[string]*M.Doc
|
||
processingDoc map[string]context.CancelFunc
|
||
mutex sync.Mutex
|
||
logger *log.Logger
|
||
}
|
||
|
||
var demandProcessor *DemandProcessor
|
||
var demandProcessorOnce sync.Once
|
||
|
||
// GetDemandProcessor 获取需求处理器单例
|
||
func GetDemandProcessor() *DemandProcessor {
|
||
demandProcessorOnce.Do(func() {
|
||
analyzer, err := NewDemandAnalyzer()
|
||
if err != nil {
|
||
log.Fatalf("初始化需求分析器失败: %v", err)
|
||
}
|
||
|
||
demandProcessor = &DemandProcessor{
|
||
analyzer: analyzer,
|
||
tasks: make(map[string]*M.Doc),
|
||
processingDoc: make(map[string]context.CancelFunc),
|
||
mutex: sync.Mutex{},
|
||
logger: setupLogger(),
|
||
}
|
||
})
|
||
return demandProcessor
|
||
}
|
||
|
||
// AddTask 添加需求文档处理任务
|
||
func (dp *DemandProcessor) AddTask(doc *M.Doc, filePath string) {
|
||
dp.mutex.Lock()
|
||
defer dp.mutex.Unlock()
|
||
|
||
dp.tasks[doc.ID] = doc
|
||
go dp.processDoc(doc, filePath)
|
||
}
|
||
|
||
// CancelDocProcessing 取消文档处理
|
||
func (dp *DemandProcessor) CancelDocProcessing(docID string) {
|
||
dp.mutex.Lock()
|
||
defer dp.mutex.Unlock()
|
||
|
||
if cancel, exists := dp.processingDoc[docID]; exists {
|
||
cancel()
|
||
delete(dp.processingDoc, docID)
|
||
}
|
||
}
|
||
|
||
// processDoc 处理需求文档
|
||
func (dp *DemandProcessor) processDoc(doc *M.Doc, filePath string) {
|
||
dp.logger.Printf("开始处理需求文档: %s", doc.Name)
|
||
|
||
// 创建可取消的上下文
|
||
ctx, cancel := context.WithCancel(context.Background())
|
||
|
||
dp.mutex.Lock()
|
||
dp.processingDoc[doc.ID] = cancel
|
||
dp.mutex.Unlock()
|
||
|
||
defer func() {
|
||
dp.mutex.Lock()
|
||
delete(dp.processingDoc, doc.ID)
|
||
dp.mutex.Unlock()
|
||
}()
|
||
|
||
// 更新文档状态为处理中
|
||
if err := cfg.DB().Model(doc).Updates(map[string]interface{}{
|
||
"analysis_completed": false,
|
||
"analysis_percent": 0,
|
||
"analysis_error": "",
|
||
}).Error; err != nil {
|
||
dp.logger.Printf("更新文档状态失败: %v", err)
|
||
return
|
||
}
|
||
|
||
// 读取文档内容
|
||
content, err := dp.analyzer.readDocContent(filePath)
|
||
if err != nil {
|
||
errMsg := fmt.Sprintf("读取文档内容失败: %v", err)
|
||
dp.logger.Printf(errMsg)
|
||
|
||
// 更新文档状态为失败
|
||
if dbErr := cfg.DB().Model(doc).Updates(map[string]interface{}{
|
||
"analysis_completed": true,
|
||
"analysis_error": errMsg,
|
||
}).Error; dbErr != nil {
|
||
dp.logger.Printf("更新文档状态失败: %v", dbErr)
|
||
}
|
||
return
|
||
}
|
||
|
||
// 提取需求
|
||
if err := dp.analyzer.extractDemands(ctx, content, doc); err != nil {
|
||
errMsg := fmt.Sprintf("提取需求失败: %v", err)
|
||
dp.logger.Printf(errMsg)
|
||
|
||
// 更新文档状态为失败
|
||
if dbErr := cfg.DB().Model(doc).Updates(map[string]interface{}{
|
||
"analysis_completed": true,
|
||
"analysis_error": errMsg,
|
||
}).Error; dbErr != nil {
|
||
dp.logger.Printf("更新文档状态失败: %v", dbErr)
|
||
}
|
||
return
|
||
}
|
||
|
||
// 更新文档状态为完成
|
||
if err := cfg.DB().Model(doc).Updates(map[string]interface{}{
|
||
"analysis_completed": true,
|
||
"analysis_percent": 100,
|
||
}).Error; err != nil {
|
||
dp.logger.Printf("更新文档状态失败: %v", err)
|
||
return
|
||
}
|
||
|
||
dp.logger.Printf("需求文档处理完成: %s", doc.Name)
|
||
}
|