eta_mini_ht_api/controllers/user/subscribe_controller.go

package user

import (
	"eta/eta_mini_ht_api/common/exception"
	"eta/eta_mini_ht_api/common/utils/page"
	"eta/eta_mini_ht_api/controllers"
	"eta/eta_mini_ht_api/service/facade"
	"eta/eta_mini_ht_api/service/order"
	"eta/eta_mini_ht_api/service/user"
	"golang.org/x/time/rate"
	"net/http"
	"sync"
	"time"
)

type SubscribeController struct {
	controllers.ListController
}

var (
	// 初始化限流器
	orderRateLimiter   = NewUserRateLimiter(rate.Every(5*time.Second), 1)
	orderNoRateLimiter = NewUserRateLimiter(rate.Every(time.Second), 1)
)

type UserRateLimiter struct {
	limiters       sync.Map      // 存储每个用户的限流器
	defaultLimiter *rate.Limiter // 默认限流器
}

func NewUserRateLimiter(limit rate.Limit, burst int) *UserRateLimiter {
	return &UserRateLimiter{
		defaultLimiter: rate.NewLimiter(limit, burst),
	}
}

func (url *UserRateLimiter) Allow(userID int) bool {
	if limiter, ok := url.limiters.Load(userID); ok {
		return limiter.(*rate.Limiter).Allow()
	}
	// 创建新的限流器并存储
	newLimiter := rate.NewLimiter(url.defaultLimiter.Limit(), url.defaultLimiter.Burst())
	url.limiters.Store(userID, newLimiter)
	return newLimiter.Allow()
}

func orderRateLimitFilter(userId int) (code int) {
	if userId <= 0 {
		code = http.StatusBadRequest
		return
	}
	if !orderRateLimiter.Allow(userId) {
		code = http.StatusTooManyRequests
		return
	}
	code = http.StatusOK
	return
}
func orderNoRateLimitFilter(userId int) (code int) {
	if userId <= 0 {
		code = http.StatusBadRequest
		return
	}
	if !orderNoRateLimiter.Allow(userId) {
		code = http.StatusTooManyRequests
		return
	}
	code = http.StatusOK
	return
}

const (
	AccountNotOpen = 430
	IDExpired      = 431
	RiskUnTest     = 432
	RiskNotMatch   = 433
	RiskExpired    = 434
	AccountOpening = 435

	orderPending = "pending"
	orderPaid    = "paid"
	orderRefund  = "refund"
	orderClosed  = "closed"
)

// GetOrderNo  获取订单号
// @Summary  获取订单号
// @Description  获取订单号
// @Success 200 {object} controllers.BaseResponse
// @router /subscribe/orderNo [get]
func (sc *SubscribeController) GetOrderNo() {
	controllers.Wrap(&sc.BaseController, func() (result *controllers.WrapData, err error) {
		result = sc.InitWrapData("获取订单号失败")
		userInfo := sc.Data["user"].(user.User)
		if code := orderNoRateLimitFilter(userInfo.Id); code != 200 {
			err = exception.New(exception.SubscribeFailed)
			sc.FailedResult("操作太频繁了,请稍后再试", result)
			return
		}

		orderNo := order.GenerateProductOrderNo()
		sc.SuccessResult("获取订单号成功", orderNo, result)
		return
	})
}

// OrderDetail  获取订单号
// @Summary  获取订单号
// @Description  获取订单号
// @Success 200 {object} controllers.BaseResponse
// @router /subscribe/orderDetail [get]
func (sc *SubscribeController) GetOrderDetail(orderId int) {
	controllers.Wrap(&sc.BaseController, func() (result *controllers.WrapData, err error) {
		result = sc.InitWrapData("获取订单号失败")
		userInfo := sc.Data["user"].(user.User)
		if orderId <= 0 {
			err = exception.New(exception.IllegalProductOrderId)
			sc.FailedResult("获取订单详情失败,产品编号非法", result)
			return
		}
		orderDetail, err := order.GetOrderDetail(orderId, userInfo.Id)
		if err != nil {
			sc.FailedResult("获取订单详情失败", result)
		}
		sc.SuccessResult("获取订单详情成功", orderDetail, result)
		return
	})
}

// GetOrderList  获取用户订单号列表
// @Summary   获取用户订单号列表
// @Description   获取用户订单号列表
// @Success 200 {object} controllers.BaseResponse
// @router /subscribe/orderList [get]
func (sc *SubscribeController) GetOrderList(orderStatus string) {
	controllers.Wrap(&sc.BaseController, func() (result *controllers.WrapData, err error) {
		result = sc.InitWrapData("分页查询订单列表失败")
		userInfo := sc.Data["user"].(user.User)
		pageRes := page.Page{
			Current:  sc.PageInfo.Current,
			PageSize: sc.PageInfo.PageSize,
		}
		pageRes.Total, pageRes.LatestId = order.GetTotalPageCountByUserId(userInfo.Id, orderStatus)
		if sc.PageInfo.LatestId == 0 {
			sc.PageInfo.LatestId = pageRes.LatestId
		} else {
			pageRes.LatestId = sc.PageInfo.LatestId
			pageRes.Total = sc.PageInfo.Total
		}
		pageRes.TotalPage = page.TotalPages(pageRes.Total, pageRes.PageSize)

		list, err := order.GetOrderPage(sc.PageInfo, userInfo.Id, orderStatus)
		if err != nil {
			sc.FailedResult("分页查询订单列表失败", result)
			return
		}
		orders := new(page.PageResult)
		orders.Data = list
		orders.Page = pageRes
		sc.SuccessResult("查询报告列表成功", orders, result)
		return
	})
}

// SubscribeProduct  订阅产品
// @Summary 订阅产品
// @Description 订阅产品
// @Success 200 {object} controllers.BaseResponse
// @router /subscribe/createOrder [post]
func (sc *SubscribeController) SubscribeProduct() {
	controllers.Wrap(&sc.BaseController, func() (result *controllers.WrapData, err error) {
		result = sc.InitWrapData("订阅产品失败")
		subscribeReq := new(SubscribeRequest)
		sc.GetPostParams(subscribeReq)
		var userInfo user.User
		userInfo = sc.Data["user"].(user.User)
		if subscribeReq.ProductId <= 0 {
			err = exception.New(exception.IllegalProductId)
			sc.FailedResult("订阅产品失败,产品编号非法", result)
			return
		}
		if subscribeReq.OrderNo == "" {
			err = exception.New(exception.IllegalOrderNo)
			sc.FailedResult("订阅产品失败,订单编号非法", result)
			return
		}
		if code := orderRateLimitFilter(userInfo.Id); code != 200 {
			err = exception.New(exception.SubscribeFailed)
			sc.FailedResult("操作太频繁了,请稍后再试", result)
			return
		}
		//校验是否已经购买并且在有效期内
		//是否开户
		//未开户
		officialUser, err := user.GetUserByTemplateUserId(userInfo.Id)
		if err != nil {
			if err.Error() == exception.GetMsg(exception.OfficialUserNotFound) {
				result.Ret = AccountNotOpen
				sc.FailedResult("用户未开通账户", result)
			} else {
				sc.FailedResult("获取用户账户信息失败", result)
			}
			return
		}
		//开户中
		if officialUser.AccountStatus == "opening" {
			result.Ret = AccountOpening
			sc.FailedResult("用户开户中", result)
			return
		}

		//证件信息是否过期
		if !officialUser.IDValid {
			result.Ret = IDExpired
			sc.FailedResult("用户证件有效期过期", result)
			return
		}
		//主动发起查询最新风险测评（获取失败用系统中原有的测评信息）
		code, err := facade.CheckUserRiskLevel(userInfo.Id, subscribeReq.ProductId, officialUser)
		if err != nil {
			result.Ret = code
			sc.FailedResult("校验用户风险等级失败", result)
			return
		}
		//创单
		//返回订单信息、商品信息
		orderInfo, err := order.CreateProductOrder(userInfo, subscribeReq.ProductId, subscribeReq.OrderNo)
		if err != nil {
			sc.FailedResult("创建订单失败", result)
			return
		}
		sc.SuccessResult("订阅产品成功", orderInfo, result)
		return
	})
}

type SubscribeRequest struct {
	ProductId int    `json:"productId"`
	OrderNo   string `json:"orderNo"`
}