This commit is contained in:
lychang
2026-05-21 01:57:25 +08:00
parent 7f5350db62
commit 10905c0acc
15 changed files with 7271 additions and 6387 deletions

View File

@@ -6,6 +6,7 @@ import (
"os"
"strings"
"time"
prompt2 "wasm-go/internal/prompt"
"wasm-go/internal/api"
"wasm-go/internal/excel"
@@ -73,13 +74,7 @@ func main() {
fmt.Println("\n✅ 所有工作表已转换为Markdown格式!")
// 读取quarterly1.txt的prompt
promptBytes, err := os.ReadFile("./quarterly1.txt")
if err != nil {
fmt.Printf("❌ 读取quarterly1.txt失败: %v\n", err)
return
}
prompt := string(promptBytes)
prompt := prompt2.Quarterly1Prompt
// 合并prompt和markdown表格
finalPrompt := fmt.Sprintf("%s\n\n%s", prompt, allMarkdownTables.String())
@@ -117,7 +112,7 @@ func main() {
// 创建税务健康服务客户端
// 注意:这里需要替换为实际的用户ID和私钥
taxHealthService := api.NewTaxHealthService("1560142251348287489", "")
taxHealthService := api.NewTaxHealthService("1554047490758508546", "00d502fcac7a2b0e227751cd6d8b0c725c55f71adcaccc6a50c4d63c73db6c8add")
// 将解析的JSON解析为map结构
var companyData map[string]interface{}
@@ -125,13 +120,14 @@ func main() {
fmt.Printf("❌ 解析JSON数据失败: %v\n", err)
return
}
// 构建税务评估请求
request := api.TaxEvalRequest{
ReqNo: fmt.Sprintf("REQ%v", time.Now().Unix()), // 使用时间戳生成请求号
Detail: api.TaxEvalDetail{
CompanyName: "企业名称", // 可以从数据中提取公司名称
CompanyName: "郑州惠兴", // 可以从数据中提取公司名称
Data: companyData,
Period: "Q1",
Year: "2024",
},
}
@@ -145,6 +141,70 @@ func main() {
fmt.Println("\n========== 税务健康API反馈结果 ==========")
fmt.Printf("API响应: %+v\n", taxResponse)
fmt.Println("======================================")
// 检查是否成功获取订单号
if taxResponse.Code != 200 || taxResponse.Data.OrderNo == "" {
fmt.Printf("❌ 税务健康API调用失败或未返回订单号: %+v\n", taxResponse)
return
}
orderNo := taxResponse.Data.OrderNo
fmt.Printf("\n🔄 获取到订单号: %s,开始轮询查询结果...\n", orderNo)
// 轮询查询结果,最多等待5分钟(60次 * 5秒)
maxAttempts := 60
attempt := 0
for attempt < maxAttempts {
// 查询税务评估结果
queryResponse, err := taxHealthService.QueryTaxEvalResult(orderNo)
if err != nil {
fmt.Printf("❌ 查询税务评估结果失败: %v\n", err)
return
}
fmt.Printf("\n========== 查询结果响应 ==========\n")
fmt.Printf("状态码: %d\n", queryResponse.Code)
fmt.Printf("消息: %s\n", queryResponse.Message)
fmt.Printf("订单状态: %d\n", queryResponse.Data.Status)
fmt.Printf("================================\n")
// 根据状态码判断处理结果
switch queryResponse.Data.Status {
case 99: // 执行成功
fmt.Println("\n✅ 税务评估已完成!")
fmt.Printf("结果文件地址: %v\n", queryResponse.Data.Detail.Files)
// 如果有错误信息也显示
if queryResponse.Data.Detail.Error != "" {
fmt.Printf("警告信息: %s\n", queryResponse.Data.Detail.Error)
}
// 这里可以进一步处理结果文件,比如下载文件
for _, fileURL := range queryResponse.Data.Detail.Files {
fmt.Printf("文件URL: %s\n", fileURL)
// TODO: 实现文件下载逻辑
}
return // 完成任务,退出程序
case 0: // 正在执行
fmt.Printf("⏳ 任务仍在处理中... (%d/%d)\n", attempt+1, maxAttempts)
time.Sleep(5 * time.Second) // 等待5秒后再次查询
attempt++
case -1: // 无效订单
fmt.Printf("❌ 订单无效: %s\n", queryResponse.Data.Detail.Error)
return
case 98: // 执行失败
fmt.Printf("❌ 任务执行失败: %s\n", queryResponse.Data.Detail.Error)
return
default:
fmt.Printf("⚠️ 未知状态码: %d\n", queryResponse.Data.Status)
time.Sleep(5 * time.Second)
attempt++
}
}
fmt.Println("\n⏰ 查询超时,建议稍后手动查询结果")
}
// extractJSONFromResponse 从LLM响应中提取JSON内容

View File

@@ -1,55 +0,0 @@
package main
import (
"fmt"
"log"
"wasm-go/internal/api"
)
func main() {
fmt.Println("=== 企业行业分类示例 ===")
// 创建LLM客户端 - 这里使用Ollama作为示例
// 如果Ollama不可用,也可以使用OpenAI
var llmClient *api.LLMClient
// 尝试连接到Ollama
fmt.Println("尝试连接到Ollama服务...")
llmClient = api.NewOllamaClient("http://localhost:11434", "qwen3.5:9b")
// 如果需要使用OpenAI,取消下面的注释并替换API KEY
/*
llmClient = api.NewOpenAIClient("your-openai-api-key", "gpt-3.5-turbo")
*/
// 创建企业行业分类器
classifier := api.NewCompanyIndustryClassifier(llmClient)
// 示例公司名称 - 可以从命令行参数获取
companyName := "深圳市致远速联信息技术有限公司"
fmt.Printf("正在分析公司: %s\n", companyName)
// 分析企业行业
result, err := classifier.ClassifyCompany(companyName)
if err != nil {
log.Printf("分析失败: %v", err)
return
}
// 输出结果
fmt.Printf("\n✅ 企业行业分析完成!\n")
fmt.Printf("公司名称: %s\n", result.CompanyName)
fmt.Printf("主要行业: %s - %s\n", result.Primary.Code, result.Primary.Name)
fmt.Printf("判断依据: %s\n", result.Primary.Reason)
if len(result.Secondary) > 0 {
fmt.Printf("次要行业:\n")
for _, sec := range result.Secondary {
fmt.Printf(" %s - %s\n", sec.Code, sec.Name)
fmt.Printf(" 判断依据: %s\n", sec.Reason)
}
} else {
fmt.Printf("次要行业: 无\n")
}
}

View File

@@ -3,17 +3,21 @@ package main
import (
"encoding/json"
"fmt"
"strings"
"syscall/js"
"wasm-go/internal/api"
"wasm-go/internal/excel"
"wasm-go/internal/prompt"
)
func main() {
// 注册各种功能函数
js.Global().Set("analyzeCompanyIndustryAsync", js.FuncOf(analyzeCompanyIndustryAsync))
js.Global().Set("parseExcelAsync", js.FuncOf(parseExcelAsync))
js.Global().Set("convertExcelToJsonViaLLM", js.FuncOf(convertExcelToJsonViaLLM))
js.Global().Set("callLLMAsync", js.FuncOf(callLLMAsync))
js.Global().Set("callTaxHealthAsync", js.FuncOf(callTaxHealthAsync))
js.Global().Set("queryTaxResultAsync", js.FuncOf(queryTaxResultAsync))
// 保持程序运行
select {} // 无限循环,保持程序运行
@@ -21,8 +25,9 @@ func main() {
// analyzeCompanyIndustryAsync 异步版本的函数,返回Promise
func analyzeCompanyIndustryAsync(this js.Value, args []js.Value) interface{} {
// 获取公司名称参数
// 获取公司名称参数和配置参数
companyName := args[0].String()
configJSON := args[1].String() // 配置参数,可选
// 创建一个通道来处理结果
resultChan := make(chan interface{}, 1)
@@ -30,8 +35,26 @@ func analyzeCompanyIndustryAsync(this js.Value, args []js.Value) interface{} {
// 在goroutine中执行异步操作
go func() {
// 创建LLM客户端
llmClient := api.NewOllamaClient("http://localhost:11434", "qwen3.5:9b")
var config LLMConfig
// 如果提供了配置参数,则解析它;否则使用默认配置
if configJSON != "" {
if err := json.Unmarshal([]byte(configJSON), &config); err != nil {
errorChan <- fmt.Errorf("解析LLM配置失败: %v", err)
return
}
} else {
// 使用默认配置
config = LLMConfig{
Provider: "ollama",
BaseURL: "http://localhost:11434",
Model: "qwen3.5:9b",
APIKey: "",
}
}
// 创建可配置的LLM客户端
llmClient := createConfigurableLLMClient(config)
// 创建企业行业分类器
classifier := api.NewCompanyIndustryClassifier(llmClient)
@@ -42,8 +65,12 @@ func analyzeCompanyIndustryAsync(this js.Value, args []js.Value) interface{} {
// 发送错误到错误通道
errorChan <- err
} else {
// 发送结果到结果通道
resultChan <- result
// 发送结果到结果通道,包含使用的配置信息
resultWithConfig := map[string]interface{}{
"data": result,
"config": config,
}
resultChan <- resultWithConfig
}
}()
@@ -185,10 +212,37 @@ func parseExcelAsync(this js.Value, args []js.Value) interface{} {
return promise
}
// callLLMAsync 调用大模型的异步函数
func callLLMAsync(this js.Value, args []js.Value) interface{} {
// 获取提示词参数
prompt := args[0].String()
// convertExcelToJsonViaLLM 将Excel数据通过LLM转换为JSON格式的函数
func convertExcelToJsonViaLLM(this js.Value, args []js.Value) interface{} {
// 获取Excel文件的ArrayBuffer和参数
arrayBuffer := args[0]
period := args[1].String() // 期间参数 (Q1, Q2, Q3, Q4, 年度等)
configJSON := args[2].String() // 配置参数,可选
// 根据period映射相应的prompt
var pmt string
switch period {
case "Q1", "第一季度":
pmt = prompt.Quarterly2Prompt
case "Q2", "第二季度":
pmt = prompt.Quarterly2Prompt
case "Q3", "第三季度":
pmt = prompt.Quarterly2Prompt
case "年度":
pmt = prompt.AnnualPrompt
default:
pmt = `你是一个专业的财务数据分析师。请分析以下财务报表数据,并将其转换为适合税务健康评估的JSON格式。只需要返回JSON数据,不要包含其他解释文字。返回格式应该是一个包含财务指标及其数值的对象,例如:{"LC0000003E_T0I0331": 741213833.14, "LC0000003E_T0I0101": 578064138.06}`
}
// 创建字节切片
uint8Array := js.Global().Get("Uint8Array").New(arrayBuffer)
length := uint8Array.Get("length").Int()
excelBytes := make([]byte, length)
// 将数据复制到Go字节切片
for i := 0; i < length; i++ {
excelBytes[i] = byte(uint8Array.Index(i).Int())
}
// 创建一个通道来处理结果
resultChan := make(chan interface{}, 1)
@@ -196,18 +250,263 @@ func callLLMAsync(this js.Value, args []js.Value) interface{} {
// 在goroutine中执行异步操作
go func() {
// 创建LLM客户端(可以根据需要选择不同的模型)
llmClient := api.NewOllamaClient("http://localhost:11434", "qwen3.5:9b")
// 调用大模型
response, err := llmClient.SimpleChat(prompt)
// 创建Excel读取器
reader, err := excel.NewXLSXReaderFromBytes(excelBytes)
if err != nil {
errorChan <- err
return
}
result := map[string]string{
"response": response,
// 读取所有工作表
sheetNames, err := reader.GetSheetNames()
if err != nil {
errorChan <- err
return
}
// 创建一个map来存储所有工作表的数据
sheets := make(map[string][][]string)
// 读取每个工作表的数据
for _, sheetName := range sheetNames {
sheetData, err := reader.GetSheetData(sheetName)
if err != nil {
// 记录错误但继续处理其他工作表
continue
}
sheets[sheetName] = sheetData
}
// 将Excel数据转换为markdown格式,便于LLM理解
var allMarkdownTables strings.Builder
allMarkdownTables.WriteString("以下是Excel表格的数据:\n\n")
for sheetName, data := range sheets {
if len(data) == 0 {
continue
}
allMarkdownTables.WriteString(fmt.Sprintf("## 工作表: %s\n", sheetName))
markdown := excel.ConvertToMarkdown(data)
allMarkdownTables.WriteString(markdown)
allMarkdownTables.WriteString("\n\n")
}
// 合并提示词和表格数据
finalPrompt := fmt.Sprintf("%s\n\n%s", pmt, allMarkdownTables.String())
var config LLMConfig
// 如果提供了配置参数,则解析它;否则使用默认配置
if configJSON != "" {
if err := json.Unmarshal([]byte(configJSON), &config); err != nil {
errorChan <- fmt.Errorf("解析LLM配置失败: %v", err)
return
}
} else {
// 使用默认配置
config = LLMConfig{
Provider: "ollama",
BaseURL: "http://localhost:11434",
Model: "qwen3.5:9b",
APIKey: "",
}
}
// 创建可配置的LLM客户端
llmClient := createConfigurableLLMClient(config)
// 调用大模型
response, err := llmClient.Chat([]api.ChatMessage{
{Role: "user", Content: finalPrompt},
})
if err != nil {
errorChan <- err
return
}
if response == nil {
errorChan <- fmt.Errorf("LLM响应为空")
return
}
// 解析LLM返回的响应,提取JSON内容
parsedJSON := extractJSONFromResponse(response.Choices[0].Message.Content)
// 尝试将解析的JSON字符串转换为map结构
var jsonData map[string]interface{}
if err := json.Unmarshal([]byte(parsedJSON), &jsonData); err != nil {
// 如果解析失败,返回原始字符串
result := map[string]interface{}{
"raw_response": response.Choices[0].Message.Content,
"parsed_json": parsedJSON,
"conversion": "success",
"parse_error": err.Error(),
"config": config,
}
resultChan <- result
} else {
// 成功解析为JSON对象
result := map[string]interface{}{
"json_data": jsonData,
"raw_response": response.Choices[0].Message.Content,
"conversion": "success",
"config": config,
}
resultChan <- result
}
}()
// 创建Promise
promise := js.Global().Get("Promise").New(js.FuncOf(func(this js.Value, promiseArgs []js.Value) interface{} {
if len(promiseArgs) < 2 {
// 如果参数不足,返回一个立即拒绝的Promise
return nil
}
resolve := promiseArgs[0]
reject := promiseArgs[1]
// 启动一个goroutine来处理结果
go func() {
select {
case result := <-resultChan:
// 将复杂结构体序列化为JSON
jsonResult, err := json.Marshal(result)
if err != nil {
// 序列化失败,返回错误
reject.Invoke(js.ValueOf(map[string]string{
"error": "JSON序列化失败: " + err.Error(),
}))
return
}
// 将JSON字符串解析为JavaScript对象
jsResult := js.Global().Get("JSON").Call("parse", string(jsonResult))
resolve.Invoke(jsResult)
case err := <-errorChan:
// 将错误转换为JavaScript值
reject.Invoke(js.ValueOf(map[string]string{
"error": err.Error(),
}))
}
}()
return nil
}))
return promise
}
// LLMConfig 定义大模型客户端配置
type LLMConfig struct {
Provider string `json:"provider"` // "ollama" 或 "openai"
BaseURL string `json:"base_url"`
Model string `json:"model"`
APIKey string `json:"api_key,omitempty"`
}
// createConfigurableLLMClient 创建可配置的大模型客户端
func createConfigurableLLMClient(config LLMConfig) *api.LLMClient {
switch strings.ToLower(config.Provider) {
case "ollama":
return api.NewOllamaClient(config.BaseURL, config.Model)
case "openai":
return api.NewOpenAIClient(config.APIKey, config.Model, config.BaseURL)
default:
// 默认使用Ollama
return api.NewOllamaClient(config.BaseURL, config.Model)
}
}
// extractJSONFromResponse 从LLM响应中提取JSON内容
// 查找并提取 ```json {...} ``` 或 ``` {...} ``` 中的内容
func extractJSONFromResponse(response string) string {
// 首先尝试匹配 ```json 开头的代码块
start := strings.Index(response, "```json")
if start != -1 {
start += 7 // 跳过 "```json"
end := strings.Index(response[start:], "```")
if end != -1 {
jsonContent := strings.TrimSpace(response[start : start+end])
return jsonContent
}
}
// 然后尝试匹配 ``` 开头的代码块(假设是JSON)
start = strings.Index(response, "```")
if start != -1 {
start += 3 // 跳过 "```"
end := strings.Index(response[start:], "```")
if end != -1 {
jsonContent := strings.TrimSpace(response[start : start+end])
// 检查是否看起来像JSON
jsonContent = strings.TrimSpace(jsonContent)
if strings.HasPrefix(jsonContent, "{") || strings.HasPrefix(jsonContent, "[") {
return jsonContent
}
}
}
// 如果没有找到代码块,尝试直接解析整个响应是否为JSON
response = strings.TrimSpace(response)
if strings.HasPrefix(response, "{") && strings.HasSuffix(response, "}") ||
strings.HasPrefix(response, "[") && strings.HasSuffix(response, "]") {
return response
}
// 如果以上都失败,返回原内容
return response
}
// callLLMAsync 调用大模型的异步函数
func callLLMAsync(this js.Value, args []js.Value) interface{} {
// 获取提示词参数和配置参数
prompt := args[0].String()
configJSON := args[1].String() // 配置参数,可选
// 创建一个通道来处理结果
resultChan := make(chan interface{}, 1)
errorChan := make(chan error, 1)
// 在goroutine中执行异步操作
go func() {
var config LLMConfig
// 如果提供了配置参数,则解析它;否则使用默认配置
if configJSON != "" {
if err := json.Unmarshal([]byte(configJSON), &config); err != nil {
errorChan <- fmt.Errorf("解析LLM配置失败: %v", err)
return
}
} else {
// 使用默认配置
config = LLMConfig{
Provider: "ollama",
BaseURL: "http://localhost:11434",
Model: "qwen3.5:9b",
APIKey: "",
}
}
// 创建可配置的LLM客户端
llmClient := createConfigurableLLMClient(config)
// 调用大模型
response, err := llmClient.Chat([]api.ChatMessage{
{Role: "user", Content: prompt},
})
if response == nil {
errorChan <- fmt.Errorf("LLM响应为空")
return
}
if err != nil {
errorChan <- err
return
}
result := map[string]interface{}{
"response": response.Choices[0].Message.Content,
"config": config,
}
resultChan <- result
@@ -255,7 +554,7 @@ func callLLMAsync(this js.Value, args []js.Value) interface{} {
}
// callTaxHealthAsync 调用税务健康API的异步函数
// 注意:由于WASM环境的CORS限制,我们在这里提供模拟实现
// 注意:由于WASM环境的CORS限制,我们需要通过后端代理调用真实API
func callTaxHealthAsync(this js.Value, args []js.Value) interface{} {
// 获取公司信息参数
companyInfoJSON := args[0].String()
@@ -266,30 +565,177 @@ func callTaxHealthAsync(this js.Value, args []js.Value) interface{} {
// 在goroutine中执行异步操作
go func() {
// 由于WASM环境无法直接调用外部API(CORS限制)
// 我们返回一个模拟的响应
simulatedResponse := map[string]interface{}{
"code": 200,
"msg": "success",
"data": map[string]interface{}{
"req_no": "REQ" + fmt.Sprint(js.Global().Get("Date").New().Call("getTime").Int()),
"order_no": "ORDER" + fmt.Sprint(js.Global().Get("Date").New().Call("getTime").Int()),
},
"message": "模拟的税务健康评估结果",
}
// 解析输入的JSON以获取一些信息用于模拟
var companyInfo map[string]interface{}
err := json.Unmarshal([]byte(companyInfoJSON), &companyInfo)
// 解析输入的JSON参数
var requestData map[string]interface{}
err := json.Unmarshal([]byte(companyInfoJSON), &requestData)
if err != nil {
errorChan <- err
return
}
// 根据输入数据添加一些模拟的评估结果
simulatedResponse["company_data"] = companyInfo
// 从输入数据中提取各个字段
reqNo, _ := requestData["req_no"].(string)
callback, _ := requestData["callback"].(string)
companyName, _ := requestData["company_name"].(string)
period, _ := requestData["period"].(string)
year, _ := requestData["year"].(string)
isVerify, _ := requestData["is_verify"].(bool)
cit, _ := requestData["cit"].(float64)
vat, _ := requestData["vat"].(float64)
inputVat, _ := requestData["input_vat"].(float64)
outputVat, _ := requestData["output_vat"].(float64)
preCIT, _ := requestData["pre_cit"].(float64)
preVAT, _ := requestData["pre_vat"].(float64)
preInputVat, _ := requestData["pre_input_vat"].(float64)
preOutputVat, _ := requestData["pre_output_vat"].(float64)
resultChan <- simulatedResponse
// 检查是否提供了Excel文件URL
fileUrl, hasFileUrl := requestData["file_url"].(string)
// 从requestData中获取data字段
data, hasData := requestData["data"].(map[string]interface{})
if !hasData {
// 尝试将整个 requestData 的 data 部分作为map
if dataSlice, ok := requestData["data"].([]interface{}); ok {
// 转换slice为map
data = make(map[string]interface{})
for _, item := range dataSlice {
if itemMap, ok := item.(map[string]interface{}); ok {
for k, v := range itemMap {
data[k] = v
}
}
}
hasData = true
}
}
// 创建税务健康服务客户端
// 注意:在真实的实现中,这些应该是安全存储的
taxHealthService := api.NewTaxHealthService("1560142251348287489", "00d502fcac7a2b0e227751cd6d8b0c725c55f71adcaccc6a50c4d63c73db6c8add")
// 构建税务评估请求
request := api.TaxEvalRequest{
ReqNo: reqNo,
Callback: callback,
Detail: api.TaxEvalDetail{
CompanyName: companyName,
Period: period,
Year: year,
IsVerify: isVerify,
CIT: cit,
VAT: vat,
InputVAT: inputVat,
OutputVAT: outputVat,
PreCIT: preCIT,
PreVAT: preVAT,
PreInputVAT: preInputVat,
PreOutputVAT: preOutputVat,
},
}
// 如果有文件URL,则使用文件URL;否则使用数据
if hasFileUrl && fileUrl != "" {
request.Detail.FileURL = fileUrl
} else if hasData {
request.Detail.Data = data
}
// 调用税务健康API
taxResponse, err := taxHealthService.EvaluateTaxHealth(request)
if err != nil {
errorChan <- err
return
}
// 检查是否成功获取订单号
if taxResponse.Code != 200 || taxResponse.Data.OrderNo == "" {
errorChan <- fmt.Errorf("税务健康API调用失败或未返回订单号: %+v", taxResponse)
return
}
orderNo := taxResponse.Data.OrderNo
// 轮询查询结果,最多等待5分钟(60次 * 5秒)
// 注意:在WASM环境中,我们不能使用长时间阻塞操作
// 因此这里只是返回订单号,轮询应该在前端JavaScript中处理
result := map[string]interface{}{
"initial_response": taxResponse,
"order_no": orderNo,
"message": "税务评估已提交,正在处理中,请使用订单号查询结果",
}
resultChan <- result
}()
// 创建Promise
promise := js.Global().Get("Promise").New(js.FuncOf(func(this js.Value, promiseArgs []js.Value) interface{} {
if len(promiseArgs) < 2 {
// 如果参数不足,返回一个立即拒绝的Promise
return nil
}
resolve := promiseArgs[0]
reject := promiseArgs[1]
// 启动一个goroutine来处理结果
go func() {
select {
case result := <-resultChan:
// 将复杂结构体序列化为JSON
jsonResult, err := json.Marshal(result)
if err != nil {
// 序列化失败,返回错误
reject.Invoke(js.ValueOf(map[string]string{
"error": "JSON序列化失败: " + err.Error(),
}))
return
}
// 将JSON字符串解析为JavaScript对象
jsResult := js.Global().Get("JSON").Call("parse", string(jsonResult))
resolve.Invoke(jsResult)
case err := <-errorChan:
// 将错误转换为JavaScript值
reject.Invoke(js.ValueOf(map[string]string{
"error": err.Error(),
}))
}
}()
return nil
}))
return promise
}
// queryTaxResultAsync 查询税务评估结果的异步函数
func queryTaxResultAsync(this js.Value, args []js.Value) interface{} {
// 获取订单号参数
orderNo := args[0].String()
// 创建一个通道来处理结果
resultChan := make(chan interface{}, 1)
errorChan := make(chan error, 1)
// 在goroutine中执行异步操作
go func() {
// 创建税务健康服务客户端
taxHealthService := api.NewTaxHealthService("1560142251348287489", "00d502fcac7a2b0e227751cd6d8b0c725c55f71adcaccc6a50c4d63c73db6c8add")
// 查询税务评估结果
queryResponse, err := taxHealthService.QueryTaxEvalResult(orderNo)
if err != nil {
errorChan <- err
return
}
result := map[string]interface{}{
"query_response": queryResponse,
"message": "查询税务评估结果成功",
}
resultChan <- result
}()
// 创建Promise