eta_mini_ht_api/controllers/order/order_controller.go

package order

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"
)

type OrderController struct {
	controllers.BaseController
}

type PreviewOrderRequest struct {
	ProductId int `json:"productId"`
}

// PreviewProductOrder  预览订单
// @Summary 预览订单
// @Description 预览订单
// @Success 200 {object} controllers.BaseResponse
// @router /previewProductOrder [get]
func (o *OrderController) PreviewProductOrder(productId int) {
	controllers.Wrap(&o.BaseController, func() (result *controllers.WrapData, err error) {
		result = o.InitWrapData("预览订单创建失败")
		var userInfo user.User
		userInfo = o.Data["user"].(user.User)
		if productId <= 0 {
			err = exception.New(exception.IllegalProductId)
			o.FailedResult("预览订单失败,产品编号非法", result)
			return
		}
		if code := orderRateLimitFilter(userInfo.Id); code != 200 {
			err = exception.New(exception.SubscribeFailed)
			o.FailedResult("操作太频繁了,请稍后再试", result)
			return
		}
		//校验是否已经购买并且在有效期内
		//是否开户
		//未开户
		officialUser, err := user.GetUserByTemplateUserId(userInfo.Id)
		if err != nil {
			if err.Error() == exception.GetMsg(exception.OfficialUserNotFound) {
				err = exception.New(exception.OfficialUserNotFound)
				result.Ret = AccountNotOpen
				o.FailedResult("用户未开通账户", result)
			} else {
				o.FailedResult("获取用户账户信息失败", result)
			}
			return
		}
		switch officialUser.AccountStatus {
		case "unopen":
			result.Ret = AccountNotOpen
			err = exception.New(exception.AccountNotOpen)
			o.FailedResult("用户未开通账户", result)
			return
		case "opening":
			result.Ret = AccountOpening
			err = exception.New(exception.AccountNotOpen)
			o.FailedResult("用户开户中", result)
			return
		case "opened":
		default:
			err = exception.New(exception.IllegalAccountStatus)
			o.FailedResult(result.Msg, result)
			return
		}
		//证件信息是否过期
		if !officialUser.IDValid {
			err = exception.New(exception.IDExpired)
			result.Ret = IDExpired
			o.FailedResult("用户证件有效期过期", result)
			return
		}
		//主动发起查询最新风险测评（获取失败用系统中原有的测评信息）
		code, err := facade.CheckUserRiskLevel(userInfo.Id, productId, officialUser)
		if err != nil {
			result.Ret = code
			o.FailedResult("校验用户风险等级失败", result)
			return
		}
		//创单
		//返回订单信息、商品信息
		orderInfo, err := order.PreViewProductOrder(userInfo, productId)
		if err != nil {
			o.FailedResult("创建预览订单失败", result)
			return
		}
		o.SuccessResult("预览订单创建成功", orderInfo, result)
		return
	})
}

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

// GetOrderList  获取用户订单号列表
// @Summary   获取用户订单号列表
// @Description   获取用户订单号列表
// @Success 200 {object} controllers.BaseResponse
// @router /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
	})
}

type OrderRequest struct {
	ProductOrderNo string `json:"productOrderNo"`
}

// CloseOrder  获取用户订单号列表
// @Summary   获取用户订单号列表
// @Description   获取用户订单号列表
// @Success 200 {object} controllers.BaseResponse
// @router /closeOrder [post]
func (sc *SubscribeController) CloseOrder() {
	controllers.Wrap(&sc.BaseController, func() (result *controllers.WrapData, err error) {
		result = sc.InitWrapData("关闭订单失败")
		userInfo := sc.Data["user"].(user.User)
		orderReq := new(OrderRequest)
		sc.GetPostParams(orderReq)
		if orderReq.ProductOrderNo == "" {
			sc.FailedResult("关闭订单失败,非法的订单编号", result)
			err = exception.New(exception.IllegalOrderNo)
			return
		}
		err = order.CloseProductOrder(userInfo.Id, orderReq.ProductOrderNo)
		if err != nil {
			sc.FailedResult("关闭订单失败", result)
			err = exception.NewWithException(exception.CloseOrderFailed, err.Error())
			return
		}
		closeDTO := map[string]string{
			"orderNo": orderReq.ProductOrderNo,
		}
		sc.SuccessResult("关闭订单成功", closeDTO, result)
		return
	})
}