qnc-server-old/api/ent.go

package api

import (
	"encoding/json"
	"errors"
	"github.com/gin-gonic/gin"
	"gorm.io/gorm"
	"log"
	"net/http"
	"qnc-server/model/model"
	"qnc-server/model/request"
	"qnc-server/model/response"
	"qnc-server/service"
	"qnc-server/utils"
	"sync"
	"time"
)

type Ent struct {
}

var entService service.EntSerivce

// 注册路由
func InitEnt(group *gin.RouterGroup) {
	var e Ent
	entPrivateGroup := group.Group("ent")
	entPrivateGroup.Use(JWTAuth())
	entPrivateGroup.GET("search", e.search)
	entPrivateGroup.GET("query_details", e.queryDetails)
	entPrivateGroup.GET("query_feature/:feature", e.queryFeature)
	entPrivateGroup.GET("query_list_feature/:feature", e.queryListFeature)

}
func (e *Ent) search(c *gin.Context) {
	var reqBody request.EntSearchReq
	if err := c.ShouldBindQuery(&reqBody); err != nil {
		response.FailWithMessage("Failed to read request body", c)
		return
	}
	resp, err := entService.RequestTycOpen(reqBody, model.Links["search"])
	time.Sleep(2 * time.Second)
	if err != nil {
		response.FailWithMessage("服务器错误请稍后再试", c)
		return
	}
	if resp == nil {
		response.OkWithEmpty(c)
		return
	}

	response.OkWithData(resp, c)
}
func (e *Ent) queryDetails(c *gin.Context) {

	var reqBody request.EntReq
	if err := c.ShouldBindQuery(&reqBody); err != nil {
		response.FailWithMessage("Failed to read request body", c)
		return
	}
	var wg sync.WaitGroup
	var baseinfoResp, holderResp interface{}
	var baseinfoErr, holderErr error
	wg.Add(2)
	go func() {
		defer wg.Done()
		baseinfoResp, baseinfoErr = entService.RequestTycOpen(reqBody, model.Links["baseinfo"])
	}()

	go func() {
		defer wg.Done()
		holderResp, holderErr = entService.RequestTycOpen(reqBody, model.Links["holder"])
	}()
	wg.Wait()
	if baseinfoErr != nil || holderErr != nil {
		return
	}
	response.OkWithData(gin.H{
		"baseinfo": baseinfoResp,
		"holder":   holderResp,
	}, c)
}
func (e *Ent) queryListFeature(c *gin.Context) {
	feature := c.Param("feature")
	if _, exists := model.Links[feature]; !exists {
		c.AbortWithStatus(http.StatusNotFound)
		return
	}

	userid := utils.GetUserID(c)
	// 查找是否有 未消费 已付费 的订单
	order, err := orderService.QueryConsumedOrder(userid, feature)
	if err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {
			// 为空就没有消费资格
			response.OkNeedPay(c)
			return
		} else {
			log.Printf("QueryConsumedOrder err:%s", err.Error())
			response.FailWithMessage("服务器错误请稍后再试", c)
			return
		}
	}
	entFeatureOrder, err := entService.QueryEntFeatureOrder(order.ID)
	if err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {

		} else {
			response.FailWithMessage("服务器错误请稍后再试", c)
			return
		}
	}
	if len(entFeatureOrder) > 1 {
		response.OkNeedPay(c)
		return
	}

	var reqBody request.EntListReq
	if err := c.ShouldBindQuery(&reqBody); err != nil {
		response.FailWithMessage("Failed to read request body", c)
		return
	}

	resp, err := entService.RequestTycOpen(reqBody, model.Links[feature])
	if err != nil {
		log.Printf("天眼查接口错误：%s", err.Error())
		notifyService.SendNotification("天眼查接口错误，请及时处理", model.Links[feature], userid, order.ID)
		response.FailRefund(c)
		return
	}
	RespJSON, err := json.Marshal(resp)
	if err != nil {
		log.Printf("failed to marshal feature data: ", err)
	}

	var entFeatureRecord = model.EntFeature{
		UserID:      userid,
		OrderID:     order.ID,
		FeatureName: feature,
		Resp:        string(RespJSON),
	}
	err = entService.SaveEntFeatureRecords(entFeatureRecord)
	if err != nil {
		log.Printf("SaveEntFeatureRecords err:%s", err.Error())
	}
	if resp != nil || len(entFeatureOrder) > 0 {
		orderService.OrderConsumed(order)
	}
	if resp == nil {
		response.OkWithEmpty(c)
		return
	}
	response.OkWithData(resp, c)
}
func (e *Ent) queryFeature(c *gin.Context) {
	feature := c.Param("feature")
	if _, exists := model.Links[feature]; !exists {
		c.AbortWithStatus(http.StatusNotFound)
		return
	}
	userid := utils.GetUserID(c)
	// 查找是否有 未消费 已付费 的订单
	order, err := orderService.QueryConsumedOrder(userid, feature)
	if err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {
			// 为空就没有消费资格
			response.OkNeedPay(c)
			return
		} else {
			log.Printf("QueryConsumedOrder err:%s", err.Error())
			response.FailWithMessage("服务器错误请稍后再试", c)
			return
		}
	}
	entFeatureOrder, err := entService.QueryEntFeatureOrder(order.ID)
	if err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {

		} else {
			response.FailWithMessage("服务器错误请稍后再试", c)
			return
		}
	}
	if len(entFeatureOrder) > 1 {
		response.OkNeedPay(c)
		return
	}

	var reqBody request.EntReq
	if err := c.ShouldBindQuery(&reqBody); err != nil {
		response.FailWithMessage("Failed to read request body", c)
		return
	}

	resp, err := entService.RequestTycOpen(reqBody, model.Links[feature])

	if err != nil {
		response.FailWithMessage("服务器错误请稍后再试", c)
		return
	}
	RespJSON, err := json.Marshal(resp)
	if err != nil {
		log.Printf("failed to marshal feature data: ", err)
	}

	var entFeatureRecord = model.EntFeature{
		UserID:      userid,
		OrderID:     order.ID,
		FeatureName: feature,
		Resp:        string(RespJSON),
	}
	err = entService.SaveEntFeatureRecords(entFeatureRecord)
	if err != nil {
		response.FailWithMessage("服务器错误请稍后再试", c)
		return
	}
	if resp != nil || len(entFeatureOrder) > 0 {
		orderService.OrderConsumed(order)
	}
	if resp == nil {
		response.OkWithEmpty(c)
		return
	}
	response.OkWithData(resp, c)
}