300 lines
9.9 KiB
Go
300 lines
9.9 KiB
Go
package handler
|
|
|
|
import (
|
|
"encoding/json"
|
|
"net/http"
|
|
"strconv"
|
|
|
|
"affiliate_dash/internal/middleware"
|
|
"affiliate_dash/internal/model"
|
|
"affiliate_dash/internal/pkg/openlog"
|
|
"affiliate_dash/internal/pkg/response"
|
|
"affiliate_dash/internal/service"
|
|
|
|
"github.com/gin-gonic/gin"
|
|
)
|
|
|
|
// OpenV1Handler 提供面向商户系统的客户侧开放接口。
|
|
type OpenV1Handler struct {
|
|
merchantSvc *service.MerchantService
|
|
fulfillmentSvc *service.FulfillmentService
|
|
deliverySvc *service.DeliveryService
|
|
}
|
|
|
|
func NewOpenV1Handler(merchantSvc *service.MerchantService, fulfillmentSvc *service.FulfillmentService, deliverySvc *service.DeliveryService) *OpenV1Handler {
|
|
return &OpenV1Handler{merchantSvc: merchantSvc, fulfillmentSvc: fulfillmentSvc, deliverySvc: deliverySvc}
|
|
}
|
|
|
|
func (h *OpenV1Handler) ListProducts(c *gin.Context) {
|
|
openlog.SetAction(c, openlog.ActionList)
|
|
page, _ := strconv.Atoi(c.DefaultQuery("page", "1"))
|
|
size, _ := strconv.Atoi(c.DefaultQuery("size", "20"))
|
|
openlog.Info(c, "list_products start page=%d size=%d", page, size)
|
|
list, total, err := h.merchantSvc.ListMerchantProducts(middleware.GetMerchantID(c), page, size, true)
|
|
if err != nil {
|
|
openlog.Warn(c, "list_products fail err=%v", err)
|
|
response.ServerError(c, err.Error())
|
|
return
|
|
}
|
|
openlog.Info(c, "list_products ok total=%d returned=%d", total, len(list))
|
|
response.Page(c, list, total, page, size)
|
|
}
|
|
|
|
type openCreateOrderReq struct {
|
|
ClientOrderNo string `json:"client_order_no" binding:"required"`
|
|
SKU string `json:"sku" binding:"required"`
|
|
Quantity int64 `json:"quantity"`
|
|
BuyerReference string `json:"buyer_reference"`
|
|
Data json.RawMessage `json:"data"`
|
|
}
|
|
|
|
func (h *OpenV1Handler) CreateOrder(c *gin.Context) {
|
|
openlog.SetAction(c, openlog.ActionCreate)
|
|
var req openCreateOrderReq
|
|
if err := c.ShouldBindJSON(&req); err != nil {
|
|
openlog.Warn(c, "create_order bind_fail err=%v", err)
|
|
response.BadRequest(c, "参数错误：client_order_no 与 sku 必填")
|
|
return
|
|
}
|
|
if key := c.GetHeader("Idempotency-Key"); key != "" && key != req.ClientOrderNo {
|
|
openlog.Warn(c, "create_order idempotency_key_mismatch header=%s body=%s", key, req.ClientOrderNo)
|
|
response.BadRequest(c, "Idempotency-Key 必须与 client_order_no 一致")
|
|
return
|
|
}
|
|
var data interface{}
|
|
if len(req.Data) > 0 {
|
|
var decoded interface{}
|
|
if err := json.Unmarshal(req.Data, &decoded); err != nil {
|
|
openlog.Warn(c, "create_order bad_data err=%v", err)
|
|
response.BadRequest(c, "data 必须是有效 JSON")
|
|
return
|
|
}
|
|
data = decoded
|
|
}
|
|
client := middleware.GetAPIClient(c)
|
|
openlog.Info(c, "create_order start client_order_no=%s sku=%s quantity=%d buyer=%s",
|
|
req.ClientOrderNo, req.SKU, req.Quantity, req.BuyerReference)
|
|
result, err := h.fulfillmentSvc.CreateOrder(service.CreateFulfillmentOrderInput{
|
|
MerchantID: middleware.GetMerchantID(c),
|
|
APIClientID: client.ID,
|
|
ClientOrderNo: req.ClientOrderNo,
|
|
SKU: req.SKU,
|
|
Quantity: req.Quantity,
|
|
BuyerReference: req.BuyerReference,
|
|
RequestData: data,
|
|
})
|
|
if err != nil {
|
|
openlog.Warn(c, "create_order fail client_order_no=%s sku=%s err=%v",
|
|
req.ClientOrderNo, req.SKU, err)
|
|
response.BadRequest(c, err.Error())
|
|
return
|
|
}
|
|
status := http.StatusOK
|
|
if !result.Idempotent {
|
|
status = http.StatusCreated
|
|
}
|
|
openlog.Info(c, "create_order ok order_no=%s idempotent=%v amount=%d",
|
|
result.Order.OrderNo, result.Idempotent, result.Order.Amount)
|
|
c.JSON(status, response.Body{
|
|
Code: 0,
|
|
Message: "ok",
|
|
Data: gin.H{
|
|
"order": buildOpenOrderResponse(result.Order),
|
|
"idempotent": result.Idempotent,
|
|
},
|
|
})
|
|
}
|
|
|
|
func (h *OpenV1Handler) QueryOrder(c *gin.Context) {
|
|
openlog.SetAction(c, openlog.ActionQuery)
|
|
orderNo := c.Param("order_no")
|
|
openlog.Info(c, "query_order start order_no=%s", orderNo)
|
|
order, err := h.fulfillmentSvc.GetOrder(middleware.GetMerchantID(c), orderNo)
|
|
if err != nil {
|
|
openlog.Warn(c, "query_order fail order_no=%s err=%v", orderNo, err)
|
|
if err.Error() == "订单不存在" {
|
|
response.NotFound(c, err.Error())
|
|
return
|
|
}
|
|
response.ServerError(c, err.Error())
|
|
return
|
|
}
|
|
openlog.Info(c, "query_order ok order_no=%s status=%s payment=%s",
|
|
order.OrderNo, order.FulfillmentStatus, order.PaymentStatus)
|
|
response.OK(c, buildOpenOrderResponse(order))
|
|
}
|
|
|
|
type openCancelOrderReq struct {
|
|
Reason string `json:"reason"`
|
|
}
|
|
|
|
func (h *OpenV1Handler) CancelOrder(c *gin.Context) {
|
|
openlog.SetAction(c, openlog.ActionCancel)
|
|
var req openCancelOrderReq
|
|
if err := c.ShouldBindJSON(&req); err != nil {
|
|
openlog.Warn(c, "cancel_order bind_fail err=%v", err)
|
|
response.BadRequest(c, "参数错误")
|
|
return
|
|
}
|
|
orderNo := c.Param("order_no")
|
|
openlog.Info(c, "cancel_order start order_no=%s reason=%s", orderNo, req.Reason)
|
|
client := middleware.GetAPIClient(c)
|
|
order, err := h.fulfillmentSvc.CancelOrder(middleware.GetMerchantID(c), client.ID, orderNo, req.Reason)
|
|
if err != nil {
|
|
openlog.Warn(c, "cancel_order fail order_no=%s err=%v", orderNo, err)
|
|
response.BadRequest(c, err.Error())
|
|
return
|
|
}
|
|
openlog.Info(c, "cancel_order ok order_no=%s", order.OrderNo)
|
|
response.OK(c, buildOpenOrderResponse(order))
|
|
}
|
|
|
|
func (h *OpenV1Handler) GetWallet(c *gin.Context) {
|
|
openlog.SetAction(c, openlog.ActionWallet)
|
|
openlog.Info(c, "get_wallet start")
|
|
wallet, err := h.fulfillmentSvc.GetWallet(middleware.GetMerchantID(c))
|
|
if err != nil {
|
|
openlog.Warn(c, "get_wallet fail err=%v", err)
|
|
response.ServerError(c, err.Error())
|
|
return
|
|
}
|
|
openlog.Info(c, "get_wallet ok balance=%d frozen=%d",
|
|
wallet.AvailableBalance, wallet.FrozenBalance)
|
|
response.OK(c, wallet)
|
|
}
|
|
|
|
func (h *OpenV1Handler) GetDeliveryLink(c *gin.Context) {
|
|
openlog.SetAction(c, openlog.ActionQuery)
|
|
orderNo := c.Param("order_no")
|
|
openlog.Info(c, "delivery_link start order_no=%s", orderNo)
|
|
link, err := h.deliverySvc.GetOrCreateDeliveryLink(middleware.GetMerchantID(c), orderNo)
|
|
if err != nil {
|
|
openlog.Warn(c, "delivery_link fail order_no=%s err=%v", orderNo, err)
|
|
if sc, ok := err.(interface{ HTTPStatus() int }); ok {
|
|
response.Fail(c, sc.HTTPStatus(), sc.HTTPStatus(), err.Error())
|
|
return
|
|
}
|
|
if err.Error() == "订单不存在" {
|
|
response.NotFound(c, err.Error())
|
|
return
|
|
}
|
|
response.BadRequest(c, err.Error())
|
|
return
|
|
}
|
|
response.OK(c, link)
|
|
}
|
|
|
|
func (h *OpenV1Handler) GetDeliveryOrder(c *gin.Context) {
|
|
openlog.SetAction(c, openlog.ActionQuery)
|
|
orderNo := c.Param("order_no")
|
|
openlog.Info(c, "delivery_get start order_no=%s", orderNo)
|
|
order, err := h.deliverySvc.GetMerchantOrder(middleware.GetMerchantID(c), orderNo)
|
|
if err != nil {
|
|
openlog.Warn(c, "delivery_get fail order_no=%s err=%v", orderNo, err)
|
|
if err.Error() == "订单不存在" {
|
|
response.NotFound(c, err.Error())
|
|
return
|
|
}
|
|
if sc, ok := err.(interface{ HTTPStatus() int }); ok {
|
|
response.Fail(c, sc.HTTPStatus(), sc.HTTPStatus(), err.Error())
|
|
return
|
|
}
|
|
response.BadRequest(c, err.Error())
|
|
return
|
|
}
|
|
response.OK(c, order)
|
|
}
|
|
|
|
type openDeliveryBindReq struct {
|
|
GameAccount string `json:"game_account" binding:"required"`
|
|
}
|
|
|
|
func (h *OpenV1Handler) BindDeliveryOrder(c *gin.Context) {
|
|
openlog.SetAction(c, openlog.ActionCreate)
|
|
var req openDeliveryBindReq
|
|
if err := c.ShouldBindJSON(&req); err != nil {
|
|
response.BadRequest(c, "请输入玩家编号")
|
|
return
|
|
}
|
|
orderNo := c.Param("order_no")
|
|
openlog.Info(c, "delivery_bind start order_no=%s", orderNo)
|
|
result, err := h.deliverySvc.BindForMerchant(middleware.GetMerchantID(c), orderNo, req.GameAccount)
|
|
if err != nil {
|
|
openlog.Warn(c, "delivery_bind fail order_no=%s err=%v", orderNo, err)
|
|
if sc, ok := err.(interface{ HTTPStatus() int }); ok {
|
|
response.Fail(c, sc.HTTPStatus(), sc.HTTPStatus(), err.Error())
|
|
return
|
|
}
|
|
response.BadRequest(c, err.Error())
|
|
return
|
|
}
|
|
response.OK(c, result)
|
|
}
|
|
|
|
type openDeliverySubmitReq struct {
|
|
GameAccount string `json:"game_account" binding:"required"`
|
|
BindUUID string `json:"bind_uuid" binding:"required"`
|
|
}
|
|
|
|
func (h *OpenV1Handler) SubmitDeliveryOrder(c *gin.Context) {
|
|
openlog.SetAction(c, openlog.ActionCreate)
|
|
var req openDeliverySubmitReq
|
|
if err := c.ShouldBindJSON(&req); err != nil {
|
|
response.BadRequest(c, "玩家编号和绑定凭证不能为空")
|
|
return
|
|
}
|
|
orderNo := c.Param("order_no")
|
|
openlog.Info(c, "delivery_submit start order_no=%s", orderNo)
|
|
client := middleware.GetAPIClient(c)
|
|
result, err := h.deliverySvc.SubmitForMerchant(middleware.GetMerchantID(c), client.ID, orderNo, req.GameAccount, req.BindUUID)
|
|
if err != nil {
|
|
openlog.Warn(c, "delivery_submit fail order_no=%s err=%v", orderNo, err)
|
|
if sc, ok := err.(interface{ HTTPStatus() int }); ok {
|
|
response.Fail(c, sc.HTTPStatus(), sc.HTTPStatus(), err.Error())
|
|
return
|
|
}
|
|
if err.Error() == "订单不存在" {
|
|
response.NotFound(c, err.Error())
|
|
return
|
|
}
|
|
response.BadRequest(c, err.Error())
|
|
return
|
|
}
|
|
response.OK(c, result)
|
|
}
|
|
|
|
func buildOpenOrderResponse(order *model.FulfillmentOrder) gin.H {
|
|
canFulfill, reason := service.CanFulfill(order)
|
|
data := gin.H{
|
|
"order_no": order.OrderNo,
|
|
"client_order_no": order.ClientOrderNo,
|
|
"payment_status": order.PaymentStatus,
|
|
"fulfillment_status": order.FulfillmentStatus,
|
|
"can_fulfill": canFulfill,
|
|
"cannot_fulfill_reason": reason,
|
|
"product": gin.H{
|
|
"sku": order.ProductSKU,
|
|
"name": order.ProductName,
|
|
},
|
|
"quantity": order.Quantity,
|
|
"base_amount": order.BaseAmount,
|
|
"fee_type": order.FeeType,
|
|
"service_fee_amount": order.ServiceFeeAmount,
|
|
"amount": order.Amount,
|
|
"currency": order.Currency,
|
|
"buyer_reference": order.BuyerReference,
|
|
"provider_order_no": order.ProviderOrderNo,
|
|
"failure_reason": order.FailureReason,
|
|
"created_at": order.CreatedAt,
|
|
"delivered_at": order.DeliveredAt,
|
|
"cancelled_at": order.CancelledAt,
|
|
}
|
|
if json.Valid([]byte(order.RequestData)) {
|
|
data["data"] = json.RawMessage(order.RequestData)
|
|
}
|
|
if json.Valid([]byte(order.ResultData)) {
|
|
data["result"] = json.RawMessage(order.ResultData)
|
|
}
|
|
return data
|
|
}
|