new

app/main/api/internal/logic/query/querydetailbyorderidlogic.go

@@ -0,0 +1,261 @@
+package query
+
+import (
+	"context"
+	"database/sql"
+	"encoding/hex"
+	"encoding/json"
+	"fmt"
+	"time"
+	"tyc-server/common/xerr"
+	"tyc-server/pkg/lzkit/crypto"
+	"tyc-server/pkg/lzkit/delay"
+	"tyc-server/pkg/lzkit/lzUtils"
+
+	"github.com/jinzhu/copier"
+	"github.com/pkg/errors"
+
+	"tyc-server/app/main/api/internal/svc"
+	"tyc-server/app/main/api/internal/types"
+	"tyc-server/app/main/model"
+
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type QueryDetailByOrderIdLogic struct {
+	logx.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+func NewQueryDetailByOrderIdLogic(ctx context.Context, svcCtx *svc.ServiceContext) *QueryDetailByOrderIdLogic {
+	return &QueryDetailByOrderIdLogic{
+		Logger: logx.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *QueryDetailByOrderIdLogic) QueryDetailByOrderId(req *types.QueryDetailByOrderIdReq) (resp *types.QueryDetailByOrderIdResp, err error) {
+	// 获取当前用户ID
+	// userId, err := ctxdata.GetUidFromCtx(l.ctx)
+	// if err != nil {
+	// 	return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "获取用户ID失败: %v", err)
+	// }
+
+	// 获取订单信息
+	order, err := l.svcCtx.OrderModel.FindOne(l.ctx, req.OrderId)
+	if err != nil {
+		if errors.Is(err, model.ErrNotFound) {
+			return nil, errors.Wrapf(xerr.NewErrCode(xerr.LOGIC_QUERY_NOT_FOUND), "报告查询, 订单不存在: %v", err)
+		}
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DB_ERROR), "报告查询, 查找报告错误: %+v", err)
+	}
+	// 安全验证：确保订单属于当前用户
+	// if order.UserId != userId {
+	// 	return nil, errors.Wrapf(xerr.NewErrCode(xerr.LOGIC_QUERY_NOT_FOUND), "无权查看此订单报告")
+	// }
+	// 创建渐进式延迟策略实例
+	progressiveDelayOrder, err := delay.New(200*time.Millisecond, 3*time.Second, 10*time.Second, 1.5)
+	if err != nil {
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "初始化渐进式延迟策略失败: %+v", err)
+	}
+
+	// 等待订单状态变为 "paid"
+	startTime := time.Now()
+	for order.Status == "pending" {
+		if time.Since(startTime) > 10*time.Second {
+			return nil, errors.Wrapf(xerr.NewErrCodeMsg(xerr.LOGIC_QUERY_WAIT, ""), "")
+		}
+
+		// 使用渐进式延迟，获取下次延迟时间
+		nextDelay, _ := progressiveDelayOrder.NextDelay()
+
+		// 等待一段时间后再查一次订单状态
+		time.Sleep(nextDelay)
+
+		// 再次查找订单
+		order, err = l.svcCtx.OrderModel.FindOne(l.ctx, req.OrderId)
+		if err != nil {
+			return nil, errors.Wrapf(xerr.NewErrCode(xerr.DB_ERROR), "报告查询, 查找订单错误: %+v", err)
+		}
+	}
+	if order.Status != "paid" {
+		return nil, errors.Wrapf(xerr.NewErrCodeMsg(xerr.LOGIC_QUERY_ERROR, ""), "")
+	}
+	// 获取报告信息
+	queryModel, err := l.svcCtx.QueryModel.FindOneByOrderId(l.ctx, req.OrderId)
+	if err != nil {
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DB_ERROR), "报告查询, 查找报告错误: %+v", err)
+	}
+
+	// 创建渐进式延迟实例
+	progressiveDelayQuery, err := delay.New(200*time.Millisecond, 3*time.Second, 10*time.Second, 1.5)
+	if err != nil {
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "初始化渐进式延迟策略失败: %+v", err)
+	}
+
+	// 等待 queryModel.QueryState 不再是 "pending"
+	startTime = time.Now()
+	for queryModel.QueryState == "pending" {
+		if time.Since(startTime) > 10*time.Second {
+			return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "报告查询超时，查询状态长时间为 'pending'")
+		}
+
+		// 使用渐进式延迟，获取下次延迟时间
+		nextDelay, _ := progressiveDelayQuery.NextDelay()
+
+		// 每隔一段时间检查一次查询状态
+		time.Sleep(nextDelay)
+
+		// 再次查询 report 状态
+		queryModel, err = l.svcCtx.QueryModel.FindOneByOrderId(l.ctx, req.OrderId)
+		if err != nil {
+			return nil, errors.Wrapf(xerr.NewErrCode(xerr.DB_ERROR), "报告查询, 查找报告错误: %+v", err)
+		}
+	}
+
+	// 根据 QueryState 做后续处理
+	if queryModel.QueryState == "failed" {
+		return nil, errors.Wrapf(xerr.NewErrCodeMsg(xerr.LOGIC_QUERY_ERROR, ""), "")
+	}
+
+	var query types.Query
+	query.CreateTime = queryModel.CreateTime.Format("2006-01-02 15:04:05")
+	query.UpdateTime = queryModel.UpdateTime.Format("2006-01-02 15:04:05")
+
+	// 解密查询数据
+	secretKey := l.svcCtx.Config.Encrypt.SecretKey
+	key, decodeErr := hex.DecodeString(secretKey)
+	if decodeErr != nil {
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "报告查询, 获取AES解密解药失败, %+v", err)
+	}
+	processParamsErr := ProcessQueryParams(queryModel.QueryParams, &query.QueryParams, key)
+	if processParamsErr != nil {
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "报告查询, 报告参数处理失败: %v", processParamsErr)
+	}
+	processErr := ProcessQueryData(queryModel.QueryData, &query.QueryData, key)
+	if processErr != nil {
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "报告查询, 报告结果处理失败: %v", processErr)
+	}
+	updateFeatureAndProductFeatureErr := l.UpdateFeatureAndProductFeature(queryModel.ProductId, &query.QueryData)
+	if updateFeatureAndProductFeatureErr != nil {
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "报告查询, 报告结果处理失败: %v", updateFeatureAndProductFeatureErr)
+	}
+	// 复制报告数据
+	err = copier.Copy(&query, queryModel)
+	if err != nil {
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "报告查询, 报告结构体复制失败, %v", err)
+	}
+	product, err := l.svcCtx.ProductModel.FindOne(l.ctx, queryModel.ProductId)
+	if err != nil {
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "报告查询, 获取商品信息失败, %v", err)
+	}
+	query.ProductName = product.ProductName
+	return &types.QueryDetailByOrderIdResp{
+		Query: query,
+	}, nil
+}
+
+// ProcessQueryData 解密和反序列化 QueryData
+func ProcessQueryData(queryData sql.NullString, target *[]types.QueryItem, key []byte) error {
+	queryDataStr := lzUtils.NullStringToString(queryData)
+	if queryDataStr == "" {
+		return nil
+	}
+
+	// 解密数据
+	decryptedData, decryptErr := crypto.AesDecrypt(queryDataStr, key)
+	if decryptErr != nil {
+		return decryptErr
+	}
+
+	// 解析 JSON 数组
+	var decryptedArray []map[string]interface{}
+	unmarshalErr := json.Unmarshal(decryptedData, &decryptedArray)
+	if unmarshalErr != nil {
+		return unmarshalErr
+	}
+
+	// 确保 target 具有正确的长度
+	if len(*target) == 0 {
+		*target = make([]types.QueryItem, len(decryptedArray))
+	}
+
+	// 填充解密后的数据到 target
+	for i := 0; i < len(decryptedArray); i++ {
+		// 直接填充解密数据到 Data 字段
+		(*target)[i].Data = decryptedArray[i]
+	}
+	return nil
+}
+
+// ProcessQueryParams解密和反序列化 QueryParams
+func ProcessQueryParams(QueryParams string, target *map[string]interface{}, key []byte) error {
+	// 解密 QueryParams
+	decryptedData, decryptErr := crypto.AesDecrypt(QueryParams, key)
+	if decryptErr != nil {
+		return decryptErr
+	}
+
+	// 反序列化解密后的数据
+	unmarshalErr := json.Unmarshal(decryptedData, target)
+	if unmarshalErr != nil {
+		return unmarshalErr
+	}
+
+	return nil
+}
+func (l *QueryDetailByOrderIdLogic) UpdateFeatureAndProductFeature(productID int64, target *[]types.QueryItem) error {
+	// 遍历 target 数组，使用倒序遍历，以便删除元素时不影响索引
+	for i := len(*target) - 1; i >= 0; i-- {
+		queryItem := &(*target)[i]
+
+		// 确保 Data 为 map 类型
+		data, ok := queryItem.Data.(map[string]interface{})
+		if !ok {
+			return fmt.Errorf("queryItem.Data 必须是 map[string]interface{} 类型")
+		}
+
+		// 从 Data 中获取 apiID
+		apiID, ok := data["apiID"].(string)
+		if !ok {
+			return fmt.Errorf("queryItem.Data 中的 apiID 必须是字符串类型")
+		}
+
+		// 查询 Feature
+		feature, err := l.svcCtx.FeatureModel.FindOneByApiId(l.ctx, apiID)
+		if err != nil {
+			// 如果 Feature 查不到，也要删除当前 QueryItem
+			*target = append((*target)[:i], (*target)[i+1:]...)
+			continue
+		}
+
+		// 查询 ProductFeatureModel
+		builder := l.svcCtx.ProductFeatureModel.SelectBuilder().Where("product_id = ?", productID)
+		productFeatures, err := l.svcCtx.ProductFeatureModel.FindAll(l.ctx, builder, "")
+		if err != nil {
+			return fmt.Errorf("查询 ProductFeatureModel 错误: %v", err)
+		}
+
+		// 遍历 productFeatures，找到与 feature.ID 关联且 enable == 1 的项
+		var featureData map[string]interface{}
+		// foundFeature := false
+		sort := 0
+		for _, pf := range productFeatures {
+			if pf.FeatureId == feature.Id { // 确保和 Feature 关联
+				sort = int(pf.Sort)
+				break // 找到第一个符合条件的就退出循环
+			}
+		}
+		featureData = map[string]interface{}{
+			"featureName": feature.Name,
+			"sort":        sort,
+		}
+
+		// 更新 queryItem 的 Feature 字段（不是数组）
+		queryItem.Feature = featureData
+	}
+
+	return nil
+}

app/main/api/internal/logic/query/querydetailbyordernologic.go

@@ -0,0 +1,209 @@
+package query
+
+import (
+	"context"
+	"encoding/hex"
+	"fmt"
+	"time"
+	"tyc-server/common/ctxdata"
+	"tyc-server/common/xerr"
+	"tyc-server/pkg/lzkit/delay"
+
+	"github.com/jinzhu/copier"
+	"github.com/pkg/errors"
+
+	"tyc-server/app/main/api/internal/svc"
+	"tyc-server/app/main/api/internal/types"
+	"tyc-server/app/main/model"
+
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type QueryDetailByOrderNoLogic struct {
+	logx.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+func NewQueryDetailByOrderNoLogic(ctx context.Context, svcCtx *svc.ServiceContext) *QueryDetailByOrderNoLogic {
+	return &QueryDetailByOrderNoLogic{
+		Logger: logx.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *QueryDetailByOrderNoLogic) QueryDetailByOrderNo(req *types.QueryDetailByOrderNoReq) (resp *types.QueryDetailByOrderNoResp, err error) {
+	// 获取当前用户ID
+	userId, err := ctxdata.GetUidFromCtx(l.ctx)
+	if err != nil {
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "获取用户ID失败: %v", err)
+	}
+
+	// 获取订单信息
+	order, err := l.svcCtx.OrderModel.FindOneByOrderNo(l.ctx, req.OrderNo)
+	if err != nil {
+		if errors.Is(err, model.ErrNotFound) {
+			return nil, errors.Wrapf(xerr.NewErrCode(xerr.LOGIC_QUERY_NOT_FOUND), "报告查询, 订单不存在: %v", err)
+		}
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DB_ERROR), "报告查询, 查找报告错误: %+v", err)
+	}
+
+	// 安全验证：确保订单属于当前用户
+	if order.UserId != userId {
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.LOGIC_QUERY_NOT_FOUND), "无权查看此订单报告")
+	}
+	// 创建渐进式延迟策略实例
+	progressiveDelayOrder, err := delay.New(200*time.Millisecond, 3*time.Second, 10*time.Second, 1.5)
+	if err != nil {
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "初始化渐进式延迟策略失败: %+v", err)
+	}
+
+	// 等待订单状态变为 "paid"
+	startTime := time.Now()
+	for order.Status == "pending" {
+		if time.Since(startTime) > 10*time.Second {
+			return nil, errors.Wrapf(xerr.NewErrCodeMsg(xerr.LOGIC_QUERY_WAIT, ""), "")
+		}
+
+		// 使用渐进式延迟，获取下次延迟时间
+		nextDelay, _ := progressiveDelayOrder.NextDelay()
+
+		// 等待一段时间后再查一次订单状态
+		time.Sleep(nextDelay)
+
+		// 再次查找订单
+		order, err = l.svcCtx.OrderModel.FindOneByOrderNo(l.ctx, req.OrderNo)
+		if err != nil {
+			return nil, errors.Wrapf(xerr.NewErrCode(xerr.DB_ERROR), "报告查询, 查找订单错误: %+v", err)
+		}
+	}
+	if order.Status != "paid" {
+		return nil, errors.Wrapf(xerr.NewErrCodeMsg(xerr.LOGIC_QUERY_ERROR, ""), "")
+	}
+	// 获取报告信息
+	queryModel, err := l.svcCtx.QueryModel.FindOneByOrderId(l.ctx, order.Id)
+	if err != nil {
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DB_ERROR), "报告查询, 查找报告错误: %+v", err)
+	}
+
+	// 创建渐进式延迟实例
+	progressiveDelayQuery, err := delay.New(200*time.Millisecond, 3*time.Second, 10*time.Second, 1.5)
+	if err != nil {
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "初始化渐进式延迟策略失败: %+v", err)
+	}
+
+	// 等待 queryModel.QueryState 不再是 "pending"
+	startTime = time.Now()
+	for queryModel.QueryState == "pending" {
+		if time.Since(startTime) > 10*time.Second {
+			return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "报告查询超时，查询状态长时间为 'pending'")
+		}
+
+		// 使用渐进式延迟，获取下次延迟时间
+		nextDelay, _ := progressiveDelayQuery.NextDelay()
+
+		// 每隔一段时间检查一次查询状态
+		time.Sleep(nextDelay)
+
+		// 再次查询 report 状态
+		queryModel, err = l.svcCtx.QueryModel.FindOneByOrderId(l.ctx, order.Id)
+		if err != nil {
+			return nil, errors.Wrapf(xerr.NewErrCode(xerr.DB_ERROR), "报告查询, 查找报告错误: %+v", err)
+		}
+	}
+
+	// 根据 QueryState 做后续处理
+	if queryModel.QueryState == "failed" {
+		return nil, errors.Wrapf(xerr.NewErrCodeMsg(xerr.LOGIC_QUERY_ERROR, ""), "")
+	}
+
+	var query types.Query
+	query.CreateTime = queryModel.CreateTime.Format("2006-01-02 15:04:05")
+	query.UpdateTime = queryModel.UpdateTime.Format("2006-01-02 15:04:05")
+
+	// 解密查询数据
+	secretKey := l.svcCtx.Config.Encrypt.SecretKey
+	key, decodeErr := hex.DecodeString(secretKey)
+	if decodeErr != nil {
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "报告查询, 获取AES解密解药失败, %+v", err)
+	}
+	processParamsErr := ProcessQueryParams(queryModel.QueryParams, &query.QueryParams, key)
+	if processParamsErr != nil {
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "报告查询, 报告参数处理失败: %v", processParamsErr)
+	}
+	processErr := ProcessQueryData(queryModel.QueryData, &query.QueryData, key)
+	if processErr != nil {
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "报告查询, 报告结果处理失败: %v", processErr)
+	}
+	updateFeatureAndProductFeatureErr := l.UpdateFeatureAndProductFeature(queryModel.ProductId, &query.QueryData)
+	if updateFeatureAndProductFeatureErr != nil {
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "报告查询, 报告结果处理失败: %v", updateFeatureAndProductFeatureErr)
+	}
+	// 复制报告数据
+	err = copier.Copy(&query, queryModel)
+	if err != nil {
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "报告查询, 报告结构体复制失败, %v", err)
+	}
+	product, err := l.svcCtx.ProductModel.FindOne(l.ctx, queryModel.ProductId)
+	if err != nil {
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "报告查询, 获取商品信息失败, %v", err)
+	}
+	query.ProductName = product.ProductName
+	return &types.QueryDetailByOrderNoResp{
+		Query: query,
+	}, nil
+}
+func (l *QueryDetailByOrderNoLogic) UpdateFeatureAndProductFeature(productID int64, target *[]types.QueryItem) error {
+	// 遍历 target 数组，使用倒序遍历，以便删除元素时不影响索引
+	for i := len(*target) - 1; i >= 0; i-- {
+		queryItem := &(*target)[i]
+
+		// 确保 Data 为 map 类型
+		data, ok := queryItem.Data.(map[string]interface{})
+		if !ok {
+			return fmt.Errorf("queryItem.Data 必须是 map[string]interface{} 类型")
+		}
+
+		// 从 Data 中获取 apiID
+		apiID, ok := data["apiID"].(string)
+		if !ok {
+			return fmt.Errorf("queryItem.Data 中的 apiID 必须是字符串类型")
+		}
+
+		// 查询 Feature
+		feature, err := l.svcCtx.FeatureModel.FindOneByApiId(l.ctx, apiID)
+		if err != nil {
+			// 如果 Feature 查不到，也要删除当前 QueryItem
+			*target = append((*target)[:i], (*target)[i+1:]...)
+			continue
+		}
+
+		// 查询 ProductFeatureModel
+		builder := l.svcCtx.ProductFeatureModel.SelectBuilder().Where("product_id = ?", productID)
+		productFeatures, err := l.svcCtx.ProductFeatureModel.FindAll(l.ctx, builder, "")
+		if err != nil {
+			return fmt.Errorf("查询 ProductFeatureModel 错误: %v", err)
+		}
+
+		// 遍历 productFeatures，找到与 feature.ID 关联且 enable == 1 的项
+		var featureData map[string]interface{}
+		// foundFeature := false
+		sort := 0
+		for _, pf := range productFeatures {
+			if pf.FeatureId == feature.Id { // 确保和 Feature 关联
+				sort = int(pf.Sort)
+				break // 找到第一个符合条件的就退出循环
+			}
+		}
+		featureData = map[string]interface{}{
+			"featureName": feature.Name,
+			"sort":        sort,
+		}
+
+		// 更新 queryItem 的 Feature 字段（不是数组）
+		queryItem.Feature = featureData
+	}
+
+	return nil
+}

app/main/api/internal/logic/query/querydetaillogic.go

@@ -0,0 +1,70 @@
+package query
+
+import (
+	"context"
+	"encoding/hex"
+	"encoding/json"
+	"tyc-server/common/xerr"
+	"tyc-server/pkg/lzkit/crypto"
+	"tyc-server/pkg/lzkit/lzUtils"
+
+	"github.com/jinzhu/copier"
+	"github.com/pkg/errors"
+
+	"tyc-server/app/main/api/internal/svc"
+	"tyc-server/app/main/api/internal/types"
+
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type QueryDetailLogic struct {
+	logx.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+func NewQueryDetailLogic(ctx context.Context, svcCtx *svc.ServiceContext) *QueryDetailLogic {
+	return &QueryDetailLogic{
+		Logger: logx.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *QueryDetailLogic) QueryDetail(req *types.QueryDetailReq) (resp *types.QueryDetailResp, err error) {
+	queryModel, err := l.svcCtx.QueryModel.FindOne(l.ctx, req.Id)
+	if err != nil {
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DB_ERROR), "报告查询, 查找报告错误: %+v", err)
+	}
+
+	var query types.Query
+	query.CreateTime = queryModel.CreateTime.Format("2006-01-02 15:04:05")
+	query.UpdateTime = queryModel.UpdateTime.Format("2006-01-02 15:04:05")
+	secretKey := l.svcCtx.Config.Encrypt.SecretKey
+	key, decodeErr := hex.DecodeString(secretKey)
+	if decodeErr != nil {
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "报告查询, 获取AES解密解药失败, %+v", err)
+	}
+	if lzUtils.NullStringToString(queryModel.QueryData) != "" {
+		queryData, decryptErr := crypto.AesDecrypt(lzUtils.NullStringToString(queryModel.QueryData), key)
+		if decryptErr != nil {
+			return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "报告查询, 报告结果解密失败, %+v", decryptErr)
+		}
+		unmarshalErr := json.Unmarshal(queryData, &query.QueryData)
+		if unmarshalErr != nil {
+			return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "报告查询, 报告结构体处理失败, %+v", unmarshalErr)
+		}
+	}
+	err = copier.Copy(&query, queryModel)
+	if err != nil {
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "报告查询, 报告结构体复制失败, %+v", err)
+	}
+	product, err := l.svcCtx.ProductModel.FindOne(l.ctx, queryModel.ProductId)
+	if err != nil {
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "报告查询, 获取商品信息失败, %+v", err)
+	}
+	query.ProductName = product.ProductName
+	return &types.QueryDetailResp{
+		Query: query,
+	}, nil
+}

app/main/api/internal/logic/query/queryexamplelogic.go

@@ -0,0 +1,118 @@
+package query
+
+import (
+	"context"
+	"encoding/hex"
+	"tyc-server/app/main/api/internal/svc"
+	"tyc-server/app/main/api/internal/types"
+	"tyc-server/common/xerr"
+	"tyc-server/pkg/lzkit/crypto"
+
+	"github.com/bytedance/sonic"
+	"github.com/pkg/errors"
+
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type QueryExampleLogic struct {
+	logx.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+func NewQueryExampleLogic(ctx context.Context, svcCtx *svc.ServiceContext) *QueryExampleLogic {
+	return &QueryExampleLogic{
+		Logger: logx.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *QueryExampleLogic) QueryExample(req *types.QueryExampleReq) (resp *types.QueryExampleResp, err error) {
+	// 根据产品特性标识获取产品信息
+	product, err := l.svcCtx.ProductModel.FindOneByProductEn(l.ctx, req.Feature)
+	if err != nil {
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "示例报告, 获取商品信息失败, %v", err)
+	}
+
+	// 创建一个空的Query结构体来存储结果
+	query := types.Query{
+		ProductName: product.ProductName,
+		QueryData:   make([]types.QueryItem, 0),
+		QueryParams: make(map[string]interface{}),
+	}
+	exampleParams, err := l.svcCtx.ExampleParamsModel.FindOneByProductId(l.ctx, product.Id)
+	if err != nil {
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "示例报告, 获取示例参数失败, %v", err)
+	}
+	secretKey := l.svcCtx.Config.Encrypt.SecretKey
+	key, decodeErr := hex.DecodeString(secretKey)
+	if decodeErr != nil {
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "示例报告, 获取AES解密解药失败, %+v", err)
+	}
+	processParamsErr := ProcessQueryParams(exampleParams.QueryParams, &query.QueryParams, key)
+	if processParamsErr != nil {
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "示例报告, 报告参数处理失败: %v", processParamsErr)
+	}
+	// 查询ProductFeatureModel获取产品相关的功能列表
+	builder := l.svcCtx.ProductFeatureModel.SelectBuilder().Where("product_id = ?", product.Id)
+	productFeatures, err := l.svcCtx.ProductFeatureModel.FindAll(l.ctx, builder, "")
+	if err != nil {
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "示例报告, 查询 ProductFeatureModel 错误: %v", err)
+	}
+	// 从每个启用的特性获取示例数据并合并
+	for _, pf := range productFeatures {
+		if pf.Enable != 1 {
+			continue // 跳过未启用的特性
+		}
+
+		// 根据特性ID查找示例数据
+		example, err := l.svcCtx.ExampleModel.FindOneByFeatureId(l.ctx, pf.FeatureId)
+		if err != nil {
+			logx.Infof("示例报告, 特性ID %d 无示例数据: %v", pf.FeatureId, err)
+			continue // 如果没有示例数据就跳过
+		}
+
+		// 获取对应的Feature信息
+		feature, err := l.svcCtx.FeatureModel.FindOne(l.ctx, pf.FeatureId)
+		if err != nil {
+			logx.Infof("示例报告, 无法获取特性ID %d 的信息: %v", pf.FeatureId, err)
+			continue
+		}
+
+		var queryItem types.QueryItem
+
+		// 解密查询数据
+		secretKey := l.svcCtx.Config.Encrypt.SecretKey
+		key, decodeErr := hex.DecodeString(secretKey)
+		if decodeErr != nil {
+			return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "示例报告, 获取AES解密解药失败, %v", err)
+		}
+		// 解析示例内容
+		if example.Content == "000" {
+			queryItem.Data = example.Content
+		} else {
+			// 解密数据
+			decryptedData, decryptErr := crypto.AesDecrypt(example.Content, key)
+			if decryptErr != nil {
+				return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "示例报告, 解密数据失败: %v", decryptErr)
+			}
+			err = sonic.Unmarshal([]byte(decryptedData), &queryItem.Data)
+			if err != nil {
+				return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "示例报告, 解析示例内容失败: %v", err)
+			}
+		}
+
+		// 添加特性信息
+		queryItem.Feature = map[string]interface{}{
+			"featureName": feature.Name,
+			"sort":        pf.Sort,
+		}
+		// 添加到查询数据中
+		query.QueryData = append(query.QueryData, queryItem)
+	}
+
+	return &types.QueryExampleResp{
+		Query: query,
+	}, nil
+}

app/main/api/internal/logic/query/querylistlogic.go

@@ -0,0 +1,70 @@
+package query
+
+import (
+	"context"
+	"tyc-server/app/main/api/internal/svc"
+	"tyc-server/app/main/api/internal/types"
+	"tyc-server/common/ctxdata"
+	"tyc-server/common/xerr"
+
+	"github.com/Masterminds/squirrel"
+	"github.com/jinzhu/copier"
+	"github.com/pkg/errors"
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type QueryListLogic struct {
+	logx.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+func NewQueryListLogic(ctx context.Context, svcCtx *svc.ServiceContext) *QueryListLogic {
+	return &QueryListLogic{
+		Logger: logx.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *QueryListLogic) QueryList(req *types.QueryListReq) (resp *types.QueryListResp, err error) {
+	userID, getUidErr := ctxdata.GetUidFromCtx(l.ctx)
+	if getUidErr != nil {
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DB_ERROR), "报告列表查询, 获取用户信息失败, %+v", getUidErr)
+	}
+
+	// 直接构建查询query表的条件
+	build := l.svcCtx.QueryModel.SelectBuilder().Where(squirrel.Eq{
+		"user_id": userID,
+	})
+
+	// 直接从query表分页查询
+	queryList, total, err := l.svcCtx.QueryModel.FindPageListByPageWithTotal(l.ctx, build, req.Page, req.PageSize, "create_time DESC")
+	if err != nil {
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DB_ERROR), "报告列表查询, 查找报告列表错误, %+v", err)
+	}
+
+	var list []types.Query
+	if len(queryList) > 0 {
+		for _, queryModel := range queryList {
+			var query types.Query
+			query.CreateTime = queryModel.CreateTime.Format("2006-01-02 15:04:05")
+			query.UpdateTime = queryModel.UpdateTime.Format("2006-01-02 15:04:05")
+			copyErr := copier.Copy(&query, queryModel)
+			if copyErr != nil {
+				return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "报告列表查询, 报告结构体复制失败, %+v", err)
+			}
+			product, findProductErr := l.svcCtx.ProductModel.FindOne(l.ctx, queryModel.ProductId)
+			if findProductErr != nil {
+				return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "报告列表查询, 获取商品信息失败, %+v", err)
+			}
+			query.ProductName = product.ProductName
+			list = append(list, query)
+		}
+	}
+
+	return &types.QueryListResp{
+		Total: total,
+		List:  list,
+	}, nil
+}

app/main/api/internal/logic/query/queryprovisionalorderlogic.go

@@ -0,0 +1,77 @@
+package query
+
+import (
+	"context"
+	"encoding/hex"
+	"encoding/json"
+	"fmt"
+	"tyc-server/app/main/api/internal/svc"
+	"tyc-server/app/main/api/internal/types"
+	"tyc-server/common/ctxdata"
+	"tyc-server/common/xerr"
+	"tyc-server/pkg/lzkit/crypto"
+
+	"github.com/jinzhu/copier"
+	"github.com/pkg/errors"
+
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type QueryProvisionalOrderLogic struct {
+	logx.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+func NewQueryProvisionalOrderLogic(ctx context.Context, svcCtx *svc.ServiceContext) *QueryProvisionalOrderLogic {
+	return &QueryProvisionalOrderLogic{
+		Logger: logx.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *QueryProvisionalOrderLogic) QueryProvisionalOrder(req *types.QueryProvisionalOrderReq) (resp *types.QueryProvisionalOrderResp, err error) {
+	userID, getUidErr := ctxdata.GetUidFromCtx(l.ctx)
+	if getUidErr != nil {
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "获取临时订单, 获取用户信息失败, %+v", getUidErr)
+	}
+	redisKey := fmt.Sprintf("%d:%s", userID, req.Id)
+	cache, cacheErr := l.svcCtx.Redis.GetCtx(l.ctx, redisKey)
+	if cacheErr != nil {
+		return nil, cacheErr
+	}
+	var data types.QueryCacheLoad
+	err = json.Unmarshal([]byte(cache), &data)
+	if err != nil {
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "获取临时订单, 解析缓存内容失败, %+v", err)
+	}
+
+	productModel, err := l.svcCtx.ProductModel.FindOneByProductEn(l.ctx, data.Product)
+	if err != nil {
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "获取临时订单, 查找产品错误: %+v", err)
+	}
+	var product types.Product
+	err = copier.Copy(&product, productModel)
+	if err != nil {
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "获取临时订单, 用户信息结构体复制失败: %+v", err)
+	}
+	secretKey := l.svcCtx.Config.Encrypt.SecretKey
+	key, decodeErr := hex.DecodeString(secretKey)
+	if decodeErr != nil {
+		return nil, fmt.Errorf("获取AES密钥失败: %+v", decodeErr)
+	}
+	decryptData, aesdecryptErr := crypto.AesDecrypt(data.Params, key)
+	if aesdecryptErr != nil {
+		return nil, fmt.Errorf("解密参数失败: %+v", aesdecryptErr)
+	}
+	queryParams := make(map[string]interface{})
+	err = json.Unmarshal(decryptData, &queryParams)
+	if err != nil {
+		return nil, fmt.Errorf("解析解密数据失败: %+v", err)
+	}
+	return &types.QueryProvisionalOrderResp{
+		QueryParams: queryParams,
+		Product:     product,
+	}, nil
+}

app/main/api/internal/logic/query/queryretrylogic.go

@@ -0,0 +1,44 @@
+package query
+
+import (
+	"context"
+	"tyc-server/common/xerr"
+
+	"github.com/pkg/errors"
+
+	"tyc-server/app/main/api/internal/svc"
+	"tyc-server/app/main/api/internal/types"
+
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type QueryRetryLogic struct {
+	logx.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+func NewQueryRetryLogic(ctx context.Context, svcCtx *svc.ServiceContext) *QueryRetryLogic {
+	return &QueryRetryLogic{
+		Logger: logx.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *QueryRetryLogic) QueryRetry(req *types.QueryRetryReq) (resp *types.QueryRetryResp, err error) {
+
+	query, err := l.svcCtx.QueryModel.FindOne(l.ctx, req.Id)
+	if err != nil {
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DB_ERROR), "报告查询重试, 查找报告失败, %+v", err)
+	}
+	if query.QueryState == "success" {
+		return nil, errors.Wrapf(xerr.NewErrCodeMsg(xerr.LOGIN_FAILED, "该报告不能重试"), "报告查询重试, 该报告不能重试, %d", query.Id)
+	}
+
+	if asyncErr := l.svcCtx.AsynqService.SendQueryTask(query.OrderId); asyncErr != nil {
+		logx.Errorf("异步任务调度失败: %v", asyncErr)
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DB_ERROR), "报告查询重试, 异步任务调度失败, %+v", asyncErr)
+	}
+	return
+}

app/main/api/internal/logic/query/querysingletestlogic.go

@@ -0,0 +1,60 @@
+package query
+
+import (
+	"context"
+	"encoding/json"
+	"time"
+	"tyc-server/common/xerr"
+
+	"github.com/pkg/errors"
+
+	"tyc-server/app/main/api/internal/svc"
+	"tyc-server/app/main/api/internal/types"
+
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type QuerySingleTestLogic struct {
+	logx.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+func NewQuerySingleTestLogic(ctx context.Context, svcCtx *svc.ServiceContext) *QuerySingleTestLogic {
+	return &QuerySingleTestLogic{
+		Logger: logx.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *QuerySingleTestLogic) QuerySingleTest(req *types.QuerySingleTestReq) (resp *types.QuerySingleTestResp, err error) {
+	// _, err = l.svcCtx.FeatureModel.FindOneByApiId(l.ctx, req.Api)
+	// if err != nil {
+	// 	return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "单查测试, 获取接口失败 : %d", err)
+	// }
+
+	marshalParams, err := json.Marshal(req.Params)
+	if err != nil {
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "单查测试, 序列化参数失败 : %d", err)
+	}
+
+	// 创建一个30分钟超时的上下文
+	timeoutCtx, cancel := context.WithTimeout(l.ctx, 30*time.Minute)
+	defer cancel() // 确保在函数返回时取消上下文，防止资源泄漏
+
+	// 使用新的超时上下文
+	apiResp, err := l.svcCtx.ApiRequestService.PreprocessRequestApi(timeoutCtx, marshalParams, req.Api)
+	if err != nil {
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "单查测试, 接口请求失败 : %d", err)
+	}
+	var respData interface{}
+	err = json.Unmarshal(apiResp.Data, &respData)
+	if err != nil {
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "单查测试, 反序列化接口失败 : %d", err)
+	}
+	return &types.QuerySingleTestResp{
+		Data: respData,
+		Api:  req.Api,
+	}, nil
+}

app/main/api/internal/logic/query/updatequerydatalogic.go

@@ -0,0 +1,70 @@
+package query
+
+import (
+	"context"
+	"database/sql"
+	"encoding/hex"
+
+	"tyc-server/app/main/api/internal/svc"
+	"tyc-server/app/main/api/internal/types"
+	"tyc-server/app/main/model"
+	"tyc-server/common/xerr"
+	"tyc-server/pkg/lzkit/crypto"
+
+	"github.com/pkg/errors"
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type UpdateQueryDataLogic struct {
+	logx.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+func NewUpdateQueryDataLogic(ctx context.Context, svcCtx *svc.ServiceContext) *UpdateQueryDataLogic {
+	return &UpdateQueryDataLogic{
+		Logger: logx.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *UpdateQueryDataLogic) UpdateQueryData(req *types.UpdateQueryDataReq) (resp *types.UpdateQueryDataResp, err error) {
+	// 1. 从数据库中获取查询记录
+	query, err := l.svcCtx.QueryModel.FindOne(l.ctx, req.Id)
+	if err != nil {
+		if err == model.ErrNotFound {
+			return nil, errors.Wrapf(xerr.NewErrCode(xerr.DB_ERROR), "查询记录不存在, 查询ID: %d", req.Id)
+		}
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DB_ERROR), "查询数据库失败, 查询ID: %d, err: %v", req.Id, err)
+	}
+
+	// 2. 获取加密密钥
+	secretKey := l.svcCtx.Config.Encrypt.SecretKey
+	key, decodeErr := hex.DecodeString(secretKey)
+	if decodeErr != nil {
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "获取AES密钥失败: %v", decodeErr)
+	}
+
+	// 3. 加密数据 - 传入的是JSON，需要加密处理
+	encryptData, aesEncryptErr := crypto.AesEncrypt([]byte(req.QueryData), key)
+	if aesEncryptErr != nil {
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "加密查询数据失败: %v", aesEncryptErr)
+	}
+
+	// 4. 更新数据库记录
+	query.QueryData = sql.NullString{
+		String: encryptData,
+		Valid:  true,
+	}
+	updateErr := l.svcCtx.QueryModel.UpdateWithVersion(l.ctx, nil, query)
+	if updateErr != nil {
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DB_ERROR), "更新查询数据失败: %v", updateErr)
+	}
+
+	// 5. 返回结果
+	return &types.UpdateQueryDataResp{
+		Id:        query.Id,
+		UpdatedAt: query.UpdateTime.Format("2006-01-02 15:04:05"),
+	}, nil
+}