red-future/order
3
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

初始化项目

Browse Source
This commit is contained in:
张斌
2025-12-10 13:51:09 +08:00
parent 3c55577df8
commit 0486f468d6
19 changed files with 1078 additions and 1010 deletions
Download Patch File Download Diff File Expand all files Collapse all files

371
controller/order.go
View File

@@ -2,380 +2,71 @@ package controller
import (
"context"
"github.com/gogf/gf/v2/frame/g"
"github.com/gogf/gf/v2/net/ghttp"
"order/model/dto"
"order/service"
)
type order struct{}
// Order 订单控制器
type Order struct{}
var OrderController = &Order{}
var Order = new(order)
// Create 创建订单
func (c *Order) Create(r *ghttp.Request) {
ctx := r.Context()
var req dto.CreateOrderReq
if err := r.Parse(&req); err != nil {
g.Log().Error(ctx, "解析请求参数失败:", err)
r.Response.WriteJsonExit(g.Map{
"code": 400,
"message": "参数错误",
"data": nil,
})
return
}
// 获取订单服务实例
orderService := service.GetOrderService()
if orderService == nil {
g.Log().Error(ctx, "订单服务未初始化")
r.Response.WriteJsonExit(g.Map{
"code": 500,
"message": "服务内部错误",
"data": nil,
})
return
}
func (c *order) Create(ctx context.Context, req *dto.CreateOrderReq) (res *dto.CreateOrderResp, err error) {
// 创建订单
resp, err := orderService.CreateOrder(ctx, &req)
if err != nil {
g.Log().Error(ctx, "创建订单失败:", err)
r.Response.WriteJsonExit(g.Map{
"code": 500,
"message": err.Error(),
"data": nil,
})
return
}
r.Response.WriteJson(g.Map{
"code": 200,
"message": "success",
"data": resp,
})
res, err = service.Order.CreateOrder(ctx, req)
return
}
// Pay 支付订单
func (c *Order) Pay(r *ghttp.Request) {
ctx := r.Context()
var req dto.PayOrderReq
if err := r.Parse(&req); err != nil {
g.Log().Error(ctx, "解析请求参数失败:", err)
r.Response.WriteJsonExit(g.Map{
"code": 400,
"message": "参数错误",
"data": nil,
})
return
}
// 获取支付服务实例
paymentService := service.GetPaymentService()
if paymentService == nil {
g.Log().Error(ctx, "支付服务未初始化")
r.Response.WriteJsonExit(g.Map{
"code": 500,
"message": "服务内部错误",
"data": nil,
})
return
}
func (c *order) Pay(ctx context.Context, req *dto.PayOrderReq) (res *dto.PayOrderResp, err error) {
// 支付订单
resp, err := paymentService.PayOrder(ctx, &req)
if err != nil {
g.Log().Error(ctx, "支付订单失败:", err)
r.Response.WriteJsonExit(g.Map{
"code": 500,
"message": err.Error(),
"data": nil,
})
return
}
r.Response.WriteJson(g.Map{
"code": 200,
"message": "success",
"data": resp,
})
res, err = service.Payment.PayOrder(ctx, req)
return
}
// Query 查询订单详情
func (c *Order) Query(r *ghttp.Request) {
ctx := r.Context()
var req dto.QueryOrderReq
if err := r.Parse(&req); err != nil {
g.Log().Error(ctx, "解析请求参数失败:", err)
r.Response.WriteJsonExit(g.Map{
"code": 400,
"message": "参数错误",
"data": nil,
})
return
}
// 获取订单服务实例
orderService := service.GetOrderService()
if orderService == nil {
g.Log().Error(ctx, "订单服务未初始化")
r.Response.WriteJsonExit(g.Map{
"code": 500,
"message": "服务内部错误",
"data": nil,
})
return
}
func (c *order) Query(ctx context.Context, req *dto.QueryOrderReq) (res *dto.QueryOrderResp, err error) {
// 查询订单
resp, err := orderService.QueryOrder(ctx, &req)
if err != nil {
g.Log().Error(ctx, "查询订单失败:", err)
r.Response.WriteJsonExit(g.Map{
"code": 500,
"message": err.Error(),
"data": nil,
})
return
}
r.Response.WriteJson(g.Map{
"code": 200,
"message": "success",
"data": resp,
})
res, err = service.Order.QueryOrder(ctx, req)
return
}
// Cancel 取消订单
func (c *Order) Cancel(r *ghttp.Request) {
ctx := r.Context()
var req dto.CancelOrderReq
if err := r.Parse(&req); err != nil {
g.Log().Error(ctx, "解析请求参数失败:", err)
r.Response.WriteJsonExit(g.Map{
"code": 400,
"message": "参数错误",
"data": nil,
})
return
}
// 获取订单服务实例
orderService := service.GetOrderService()
if orderService == nil {
g.Log().Error(ctx, "订单服务未初始化")
r.Response.WriteJsonExit(g.Map{
"code": 500,
"message": "服务内部错误",
"data": nil,
})
return
}
func (c *order) Cancel(ctx context.Context, req *dto.CancelOrderReq) (res *dto.CancelOrderResp, err error) {
// 取消订单
resp, err := orderService.CancelOrder(ctx, &req)
if err != nil {
g.Log().Error(ctx, "取消订单失败:", err)
r.Response.WriteJsonExit(g.Map{
"code": 500,
"message": err.Error(),
"data": nil,
})
return
}
r.Response.WriteJson(g.Map{
"code": 200,
"message": "success",
"data": resp,
})
res, err = service.Order.CancelOrder(ctx, req)
return
}
// Refund 退款
func (c *Order) Refund(r *ghttp.Request) {
ctx := r.Context()
var req dto.RefundOrderReq
if err := r.Parse(&req); err != nil {
g.Log().Error(ctx, "解析请求参数失败:", err)
r.Response.WriteJsonExit(g.Map{
"code": 400,
"message": "参数错误",
"data": nil,
})
return
}
// 获取支付服务实例
paymentService := service.GetPaymentService()
if paymentService == nil {
g.Log().Error(ctx, "支付服务未初始化")
r.Response.WriteJsonExit(g.Map{
"code": 500,
"message": "服务内部错误",
"data": nil,
})
return
}
func (c *order) Refund(ctx context.Context, req *dto.RefundOrderReq) (res *dto.RefundOrderResp, err error) {
// 退款
resp, err := paymentService.RefundOrder(ctx, &req)
if err != nil {
g.Log().Error(ctx, "退款失败:", err)
r.Response.WriteJsonExit(g.Map{
"code": 500,
"message": err.Error(),
"data": nil,
})
return
}
r.Response.WriteJson(g.Map{
"code": 200,
"message": "success",
"data": resp,
})
res, err = service.Payment.RefundOrder(ctx, req)
return
}
// List 查询订单列表
func (c *Order) List(r *ghttp.Request) {
ctx := r.Context()
var req dto.ListOrdersReq
if err := r.Parse(&req); err != nil {
g.Log().Error(ctx, "解析请求参数失败:", err)
r.Response.WriteJsonExit(g.Map{
"code": 400,
"message": "参数错误",
"data": nil,
})
return
}
// 获取订单服务实例
orderService := service.GetOrderService()
if orderService == nil {
g.Log().Error(ctx, "订单服务未初始化")
r.Response.WriteJsonExit(g.Map{
"code": 500,
"message": "服务内部错误",
"data": nil,
})
return
}
func (c *order) List(ctx context.Context, req *dto.ListOrdersReq) (res *dto.ListOrdersResp, err error) {
// 查询订单列表
resp, err := orderService.ListOrders(ctx, &req)
if err != nil {
g.Log().Error(ctx, "查询订单列表失败:", err)
r.Response.WriteJsonExit(g.Map{
"code": 500,
"message": err.Error(),
"data": nil,
})
return
}
r.Response.WriteJson(g.Map{
"code": 200,
"message": "success",
"data": resp,
})
res, err = service.Order.ListOrders(ctx, req)
return
}
// PaymentNotify 支付回调
func (c *Order) PaymentNotify(r *ghttp.Request) {
ctx := r.Context()
var req service.PaymentNotifyReq
if err := r.Parse(&req); err != nil {
g.Log().Error(ctx, "解析支付回调参数失败:", err)
r.Response.WriteJsonExit(g.Map{
"code": 400,
"message": "参数错误",
"data": nil,
})
return
}
// 获取支付服务实例
paymentService := service.GetPaymentService()
if paymentService == nil {
g.Log().Error(ctx, "支付服务未初始化")
r.Response.WriteJsonExit(g.Map{
"code": 500,
"message": "服务内部错误",
"data": nil,
})
return
}
func (c *order) PaymentNotify(ctx context.Context, req *dto.PaymentNotifyReq) (res *dto.PaymentNotifyResp, err error) {
// 处理支付回调
if err := paymentService.HandlePaymentNotify(ctx, &req); err != nil {
g.Log().Error(ctx, "处理支付回调失败:", err)
r.Response.WriteJsonExit(g.Map{
"code": 500,
"message": err.Error(),
"data": nil,
})
return
}
r.Response.WriteJson(g.Map{
"code": 200,
"message": "success",
"data": nil,
})
err = service.Payment.HandlePaymentNotify(ctx, req)
return &dto.PaymentNotifyResp{
Success: err == nil,
}, err
}
// RefundNotify 退款回调
func (c *Order) RefundNotify(r *ghttp.Request) {
ctx := r.Context()
var req service.RefundNotifyReq
if err := r.Parse(&req); err != nil {
g.Log().Error(ctx, "解析退款回调参数失败:", err)
r.Response.WriteJsonExit(g.Map{
"code": 400,
"message": "参数错误",
"data": nil,
})
return
}
// 获取支付服务实例
paymentService := service.GetPaymentService()
if paymentService == nil {
g.Log().Error(ctx, "支付服务未初始化")
r.Response.WriteJsonExit(g.Map{
"code": 500,
"message": "服务内部错误",
"data": nil,
})
return
}
func (c *order) RefundNotify(ctx context.Context, req *dto.RefundNotifyReq) (res *dto.RefundNotifyResp, err error) {
// 处理退款回调
if err := paymentService.HandleRefundNotify(ctx, &req); err != nil {
g.Log().Error(ctx, "处理退款回调失败:", err)
r.Response.WriteJsonExit(g.Map{
"code": 500,
"message": err.Error(),
"data": nil,
})
return
}
r.Response.WriteJson(g.Map{
"code": 200,
"message": "success",
"data": nil,
})
err = service.Payment.HandleRefundNotify(ctx, req)
return &dto.RefundNotifyResp{
Success: err == nil,
}, err
}