juwan/juwan-backend
1
0
Fork 0
Code Issues Pull Requests Actions 22 Packages Projects Releases Wiki Activity

feat: 添加争议微服务，支持订单争议流程

Browse Source
This commit is contained in:
zetaloop
2026-04-24 12:31:41 +08:00
parent 6edf15996c
commit 95f2f10f9f
66 changed files with 13301 additions and 57 deletions
Download Patch File Download Diff File Expand all files Collapse all files
app/dispute/api/dispute.go
+34
View File
@@ -0,0 +1,34 @@
// Code scaffolded by goctl. Safe to edit.
// goctl 1.10.1
package main
import (
"flag"
"fmt"
"juwan-backend/app/dispute/api/internal/config"
"juwan-backend/app/dispute/api/internal/handler"
"juwan-backend/app/dispute/api/internal/svc"
"github.com/zeromicro/go-zero/core/conf"
"github.com/zeromicro/go-zero/rest"
)
var configFile = flag.String("f", "etc/dispute-api.yaml", "the config file")
func main() {
flag.Parse()
var c config.Config
conf.MustLoad(*configFile, &c)
server := rest.MustNewServer(c.RestConf)
defer server.Stop()
ctx := svc.NewServiceContext(c)
handler.RegisterHandlers(server, ctx)
fmt.Printf("Starting server at %s:%d...\n", c.Host, c.Port)
server.Start()
}
app/dispute/api/etc/dispute-api.yaml
+16
View File
@@ -0,0 +1,16 @@
Name: dispute-api
Host: 0.0.0.0
Port: 8888
Prometheus:
Host: 0.0.0.0
Port: 4001
Path: /metrics
# ===== DEV CONFIG =====
DisputeRpcConf:
Endpoints:
- dispute-rpc:8080
OrderRpcConf:
Endpoints:
- order-rpc:8080
app/dispute/api/internal/config/config.go
+12
View File
@@ -0,0 +1,12 @@
package config
import (
"github.com/zeromicro/go-zero/rest"
"github.com/zeromicro/go-zero/zrpc"
)
type Config struct {
rest.RestConf
DisputeRpcConf zrpc.RpcClientConf
OrderRpcConf zrpc.RpcClientConf
}
app/dispute/api/internal/handler/dispute/appealDisputeHandler.go
+32
View File
@@ -0,0 +1,32 @@
// Code scaffolded by goctl. Safe to edit.
// goctl 1.10.1
package dispute
import (
"net/http"
"github.com/zeromicro/go-zero/rest/httpx"
"juwan-backend/app/dispute/api/internal/logic/dispute"
"juwan-backend/app/dispute/api/internal/svc"
"juwan-backend/app/dispute/api/internal/types"
)
// 申诉
func AppealDisputeHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.AppealReq
if err := httpx.Parse(r, &req); err != nil {
httpx.ErrorCtx(r.Context(), w, err)
return
}
l := dispute.NewAppealDisputeLogic(r.Context(), svcCtx)
resp, err := l.AppealDispute(&req)
if err != nil {
httpx.ErrorCtx(r.Context(), w, err)
} else {
httpx.OkJsonCtx(r.Context(), w, resp)
}
}
}
app/dispute/api/internal/handler/dispute/createDisputeHandler.go
+32
View File
@@ -0,0 +1,32 @@
// Code scaffolded by goctl. Safe to edit.
// goctl 1.10.1
package dispute
import (
"net/http"
"github.com/zeromicro/go-zero/rest/httpx"
"juwan-backend/app/dispute/api/internal/logic/dispute"
"juwan-backend/app/dispute/api/internal/svc"
"juwan-backend/app/dispute/api/internal/types"
)
// 发起争议
func CreateDisputeHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.CreateDisputeReq
if err := httpx.Parse(r, &req); err != nil {
httpx.ErrorCtx(r.Context(), w, err)
return
}
l := dispute.NewCreateDisputeLogic(r.Context(), svcCtx)
resp, err := l.CreateDispute(&req)
if err != nil {
httpx.ErrorCtx(r.Context(), w, err)
} else {
httpx.OkJsonCtx(r.Context(), w, resp)
}
}
}
app/dispute/api/internal/handler/dispute/getOrderDisputeHandler.go
+32
View File
@@ -0,0 +1,32 @@
// Code scaffolded by goctl. Safe to edit.
// goctl 1.10.1
package dispute
import (
"net/http"
"github.com/zeromicro/go-zero/rest/httpx"
"juwan-backend/app/dispute/api/internal/logic/dispute"
"juwan-backend/app/dispute/api/internal/svc"
"juwan-backend/app/dispute/api/internal/types"
)
// 获取订单争议
func GetOrderDisputeHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.DisputePathId
if err := httpx.Parse(r, &req); err != nil {
httpx.ErrorCtx(r.Context(), w, err)
return
}
l := dispute.NewGetOrderDisputeLogic(r.Context(), svcCtx)
resp, err := l.GetOrderDispute(&req)
if err != nil {
httpx.ErrorCtx(r.Context(), w, err)
} else {
httpx.OkJsonCtx(r.Context(), w, resp)
}
}
}
app/dispute/api/internal/handler/dispute/listDisputesHandler.go
+32
View File
@@ -0,0 +1,32 @@
// Code scaffolded by goctl. Safe to edit.
// goctl 1.10.1
package dispute
import (
"net/http"
"github.com/zeromicro/go-zero/rest/httpx"
"juwan-backend/app/dispute/api/internal/logic/dispute"
"juwan-backend/app/dispute/api/internal/svc"
"juwan-backend/app/dispute/api/internal/types"
)
// 获取争议列表
func ListDisputesHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.DisputeListReq
if err := httpx.Parse(r, &req); err != nil {
httpx.ErrorCtx(r.Context(), w, err)
return
}
l := dispute.NewListDisputesLogic(r.Context(), svcCtx)
resp, err := l.ListDisputes(&req)
if err != nil {
httpx.ErrorCtx(r.Context(), w, err)
} else {
httpx.OkJsonCtx(r.Context(), w, resp)
}
}
}
app/dispute/api/internal/handler/dispute/respondDisputeHandler.go
+32
View File
@@ -0,0 +1,32 @@
// Code scaffolded by goctl. Safe to edit.
// goctl 1.10.1
package dispute
import (
"net/http"
"github.com/zeromicro/go-zero/rest/httpx"
"juwan-backend/app/dispute/api/internal/logic/dispute"
"juwan-backend/app/dispute/api/internal/svc"
"juwan-backend/app/dispute/api/internal/types"
)
// 回应争议
func RespondDisputeHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.DisputeResponseReq
if err := httpx.Parse(r, &req); err != nil {
httpx.ErrorCtx(r.Context(), w, err)
return
}
l := dispute.NewRespondDisputeLogic(r.Context(), svcCtx)
resp, err := l.RespondDispute(&req)
if err != nil {
httpx.ErrorCtx(r.Context(), w, err)
} else {
httpx.OkJsonCtx(r.Context(), w, resp)
}
}
}
app/dispute/api/internal/handler/routes.go
+51
View File
@@ -0,0 +1,51 @@
// Code generated by goctl. DO NOT EDIT.
// goctl 1.10.1
package handler
import (
"net/http"
dispute "juwan-backend/app/dispute/api/internal/handler/dispute"
"juwan-backend/app/dispute/api/internal/svc"
"github.com/zeromicro/go-zero/rest"
)
func RegisterHandlers(server *rest.Server, serverCtx *svc.ServiceContext) {
server.AddRoutes(
[]rest.Route{
{
// 获取争议列表
Method: http.MethodGet,
Path: "/disputes",
Handler: dispute.ListDisputesHandler(serverCtx),
},
{
// 申诉
Method: http.MethodPost,
Path: "/disputes/:id/appeal",
Handler: dispute.AppealDisputeHandler(serverCtx),
},
{
// 回应争议
Method: http.MethodPost,
Path: "/disputes/:id/response",
Handler: dispute.RespondDisputeHandler(serverCtx),
},
{
// 获取订单争议
Method: http.MethodGet,
Path: "/orders/:id/dispute",
Handler: dispute.GetOrderDisputeHandler(serverCtx),
},
{
// 发起争议
Method: http.MethodPost,
Path: "/orders/:id/dispute",
Handler: dispute.CreateDisputeHandler(serverCtx),
},
},
rest.WithPrefix("/api/v1"),
)
}
app/dispute/api/internal/logic/dispute/appealDisputeLogic.go
+82
View File
@@ -0,0 +1,82 @@
// Code scaffolded by goctl. Safe to edit.
// goctl 1.10.1
package dispute
import (
"context"
"errors"
"time"
"juwan-backend/app/dispute/api/internal/svc"
"juwan-backend/app/dispute/api/internal/types"
"juwan-backend/app/dispute/rpc/disputeservice"
"juwan-backend/common/utils/contextj"
"github.com/zeromicro/go-zero/core/logx"
)
type AppealDisputeLogic struct {
logx.Logger
ctx context.Context
svcCtx *svc.ServiceContext
}
// 申诉
func NewAppealDisputeLogic(ctx context.Context, svcCtx *svc.ServiceContext) *AppealDisputeLogic {
return &AppealDisputeLogic{
Logger: logx.WithContext(ctx),
ctx: ctx,
svcCtx: svcCtx,
}
}
func (l *AppealDisputeLogic) AppealDispute(req *types.AppealReq) (resp *types.EmptyResp, err error) {
uid, err := contextj.UserIDFrom(l.ctx)
if err != nil {
return nil, err
}
if req.Reason == "" {
return nil, errors.New("reason is required")
}
disputeResp, err := l.svcCtx.DisputeRpc.GetDisputesById(l.ctx, &disputeservice.GetDisputesByIdReq{Id: req.Id})
if err != nil {
return nil, err
}
d := disputeResp.GetDisputes()
if d == nil {
return nil, errors.New("dispute not found")
}
if uid != d.GetInitiatorId() && uid != d.GetRespondentId() {
return nil, errors.New("not a participant of this dispute")
}
if d.GetStatus() != "resolved" {
return nil, errors.New("dispute status does not allow appeal")
}
status := "appealed"
now := time.Now().Unix()
_, err = l.svcCtx.DisputeRpc.UpdateDisputes(l.ctx, &disputeservice.UpdateDisputesReq{
Id: req.Id,
Status: &status,
AppealReason: &req.Reason,
AppealedAt: &now,
})
if err != nil {
return nil, err
}
_, err = l.svcCtx.DisputeRpc.AddDisputeTimeline(l.ctx, &disputeservice.AddDisputeTimelineReq{
DisputeId: req.Id,
EventType: "appealed",
ActorId: uid,
ActorName: actorName(uid),
Details: detailsJSON(map[string]any{"reason": req.Reason}),
})
if err != nil {
return nil, err
}
return &types.EmptyResp{}, nil
}
app/dispute/api/internal/logic/dispute/createDisputeLogic.go
+128
View File
@@ -0,0 +1,128 @@
// Code scaffolded by goctl. Safe to edit.
// goctl 1.10.1
package dispute
import (
"context"
"errors"
"time"
"juwan-backend/app/dispute/api/internal/svc"
"juwan-backend/app/dispute/api/internal/types"
"juwan-backend/app/dispute/rpc/disputeservice"
"juwan-backend/app/order/rpc/orderservice"
"juwan-backend/common/utils/contextj"
"github.com/zeromicro/go-zero/core/logx"
)
type CreateDisputeLogic struct {
logx.Logger
ctx context.Context
svcCtx *svc.ServiceContext
}
// 发起争议
func NewCreateDisputeLogic(ctx context.Context, svcCtx *svc.ServiceContext) *CreateDisputeLogic {
return &CreateDisputeLogic{
Logger: logx.WithContext(ctx),
ctx: ctx,
svcCtx: svcCtx,
}
}
func (l *CreateDisputeLogic) CreateDispute(req *types.CreateDisputeReq) (resp *types.EmptyResp, err error) {
uid, err := contextj.UserIDFrom(l.ctx)
if err != nil {
return nil, err
}
if req.Reason == "" {
return nil, errors.New("reason is required")
}
orderResp, err := l.svcCtx.OrderRpc.GetOrdersById(l.ctx, &orderservice.GetOrdersByIdReq{Id: req.Id})
if err != nil {
return nil, err
}
order := orderResp.GetOrders()
if order == nil {
return nil, errors.New("order not found")
}
if order.GetStatus() != "in_progress" && order.GetStatus() != "pending_close" {
return nil, errors.New("order status does not allow disputes")
}
var respondentID int64
if uid == order.GetConsumerId() {
respondentID = order.GetPlayerId()
} else if uid == order.GetPlayerId() {
respondentID = order.GetConsumerId()
} else {
return nil, errors.New("not a participant of this order")
}
existing, err := l.svcCtx.DisputeRpc.SearchDisputes(l.ctx, &disputeservice.SearchDisputesReq{
Offset: 0,
Limit: 1,
OrderId: &req.Id,
})
if err != nil {
return nil, err
}
if len(existing.GetDisputes()) > 0 {
return nil, errors.New("dispute already exists")
}
created, err := l.svcCtx.DisputeRpc.AddDisputes(l.ctx, &disputeservice.AddDisputesReq{
OrderId: req.Id,
InitiatorId: uid,
InitiatorName: actorName(uid),
RespondentId: respondentID,
Reason: req.Reason,
Evidence: req.Evidence,
Status: "open",
})
if err != nil {
return nil, err
}
_, err = l.svcCtx.DisputeRpc.AddDisputeTimeline(l.ctx, &disputeservice.AddDisputeTimelineReq{
DisputeId: created.GetId(),
EventType: "created",
ActorId: uid,
ActorName: actorName(uid),
Details: detailsJSON(map[string]any{"reason": req.Reason, "evidence": req.Evidence}),
})
if err != nil {
return nil, err
}
now := time.Now().Unix()
status := "disputed"
oldStatus := order.GetStatus()
metadata := detailsJSON(map[string]any{"disputeId": created.GetId()})
_, err = l.svcCtx.OrderRpc.UpdateOrders(l.ctx, &orderservice.UpdateOrdersReq{
Id: req.Id,
Status: &status,
UpdatedAt: &now,
})
if err != nil {
return nil, err
}
_, err = l.svcCtx.OrderRpc.AddOrderStateLogs(l.ctx, &orderservice.AddOrderStateLogsReq{
OrderId: req.Id,
FromStatus: &oldStatus,
ToStatus: status,
Action: "open_dispute",
ActorId: uid,
ActorRole: "user",
Metadata: &metadata,
CreatedAt: &now,
})
if err != nil {
return nil, err
}
return &types.EmptyResp{}, nil
}
app/dispute/api/internal/logic/dispute/getOrderDisputeLogic.go
+65
View File
@@ -0,0 +1,65 @@
// Code scaffolded by goctl. Safe to edit.
// goctl 1.10.1
package dispute
import (
"context"
"errors"
"juwan-backend/app/dispute/api/internal/svc"
"juwan-backend/app/dispute/api/internal/types"
"juwan-backend/app/dispute/rpc/disputeservice"
"juwan-backend/app/order/rpc/orderservice"
"juwan-backend/common/utils/contextj"
"github.com/zeromicro/go-zero/core/logx"
)
type GetOrderDisputeLogic struct {
logx.Logger
ctx context.Context
svcCtx *svc.ServiceContext
}
// 获取订单争议
func NewGetOrderDisputeLogic(ctx context.Context, svcCtx *svc.ServiceContext) *GetOrderDisputeLogic {
return &GetOrderDisputeLogic{
Logger: logx.WithContext(ctx),
ctx: ctx,
svcCtx: svcCtx,
}
}
func (l *GetOrderDisputeLogic) GetOrderDispute(req *types.DisputePathId) (resp *types.Dispute, err error) {
uid, err := contextj.UserIDFrom(l.ctx)
if err != nil {
return nil, err
}
orderResp, err := l.svcCtx.OrderRpc.GetOrdersById(l.ctx, &orderservice.GetOrdersByIdReq{Id: req.Id})
if err != nil {
return nil, err
}
order := orderResp.GetOrders()
if order == nil {
return nil, errors.New("order not found")
}
if uid != order.GetConsumerId() && uid != order.GetPlayerId() {
return nil, errors.New("not a participant of this order")
}
out, err := l.svcCtx.DisputeRpc.SearchDisputes(l.ctx, &disputeservice.SearchDisputesReq{
Offset: 0,
Limit: 1,
OrderId: &req.Id,
})
if err != nil {
return nil, err
}
if len(out.GetDisputes()) == 0 {
return nil, errors.New("dispute not found")
}
dispute := toAPIDispute(out.GetDisputes()[0])
return &dispute, nil
}
app/dispute/api/internal/logic/dispute/helpers.go
+97
View File
@@ -0,0 +1,97 @@
package dispute
import (
"encoding/json"
"sort"
"strconv"
"time"
"juwan-backend/app/dispute/api/internal/types"
"juwan-backend/app/dispute/rpc/disputeservice"
)
func formatUnix(ts int64) string {
if ts <= 0 {
return ""
}
return time.Unix(ts, 0).UTC().Format(time.RFC3339)
}
func toAPIDispute(d *disputeservice.Disputes) types.Dispute {
return types.Dispute{
Id: d.GetId(),
OrderId: d.GetOrderId(),
InitiatorId: d.GetInitiatorId(),
InitiatorName: d.GetInitiatorName(),
RespondentId: d.GetRespondentId(),
Reason: d.GetReason(),
Evidence: d.GetEvidence(),
Status: d.GetStatus(),
Result: d.GetResult(),
RespondentReason: d.GetRespondentReason(),
RespondentEvidence: d.GetRespondentEvidence(),
AppealReason: d.GetAppealReason(),
AppealedAt: formatUnix(d.GetAppealedAt()),
ResolvedBy: d.GetResolvedBy(),
ResolvedAt: formatUnix(d.GetResolvedAt()),
CreatedAt: formatUnix(d.GetCreatedAt()),
UpdatedAt: formatUnix(d.GetUpdatedAt()),
}
}
func mergeDisputes(groups ...[]*disputeservice.Disputes) []*disputeservice.Disputes {
seen := make(map[int64]struct{})
items := make([]*disputeservice.Disputes, 0)
for _, group := range groups {
for _, item := range group {
if item == nil {
continue
}
if _, ok := seen[item.GetId()]; ok {
continue
}
seen[item.GetId()] = struct{}{}
items = append(items, item)
}
}
sort.Slice(items, func(i, j int) bool {
if items[i].GetCreatedAt() == items[j].GetCreatedAt() {
return items[i].GetId() > items[j].GetId()
}
return items[i].GetCreatedAt() > items[j].GetCreatedAt()
})
return items
}
func paginateDisputes(items []*disputeservice.Disputes, offset int64, limit int64) []*disputeservice.Disputes {
if offset < 0 {
offset = 0
}
if limit <= 0 {
limit = 20
}
start := int(offset)
if start >= len(items) {
return []*disputeservice.Disputes{}
}
end := start + int(limit)
if end > len(items) {
end = len(items)
}
return items[start:end]
}
func actorName(uid int64) string {
return strconv.FormatInt(uid, 10)
}
func detailsJSON(values map[string]any) string {
if len(values) == 0 {
return "{}"
}
b, err := json.Marshal(values)
if err != nil {
return "{}"
}
return string(b)
}
app/dispute/api/internal/logic/dispute/listDisputesLogic.go
+80
View File
@@ -0,0 +1,80 @@
// Code scaffolded by goctl. Safe to edit.
// goctl 1.10.1
package dispute
import (
"context"
"juwan-backend/app/dispute/api/internal/svc"
"juwan-backend/app/dispute/api/internal/types"
"juwan-backend/app/dispute/rpc/disputeservice"
"juwan-backend/common/utils/contextj"
"github.com/zeromicro/go-zero/core/logx"
)
type ListDisputesLogic struct {
logx.Logger
ctx context.Context
svcCtx *svc.ServiceContext
}
// 获取争议列表
func NewListDisputesLogic(ctx context.Context, svcCtx *svc.ServiceContext) *ListDisputesLogic {
return &ListDisputesLogic{
Logger: logx.WithContext(ctx),
ctx: ctx,
svcCtx: svcCtx,
}
}
func (l *ListDisputesLogic) ListDisputes(req *types.DisputeListReq) (resp *types.DisputeListResp, err error) {
uid, err := contextj.UserIDFrom(l.ctx)
if err != nil {
return nil, err
}
limit := req.Limit
if limit <= 0 {
limit = 20
}
var status *string
if req.Status != "" {
status = &req.Status
}
initiated, err := l.svcCtx.DisputeRpc.SearchDisputes(l.ctx, &disputeservice.SearchDisputesReq{
Offset: 0,
Limit: 100,
InitiatorId: &uid,
Status: status,
})
if err != nil {
return nil, err
}
responded, err := l.svcCtx.DisputeRpc.SearchDisputes(l.ctx, &disputeservice.SearchDisputesReq{
Offset: 0,
Limit: 100,
RespondentId: &uid,
Status: status,
})
if err != nil {
return nil, err
}
items := mergeDisputes(initiated.GetDisputes(), responded.GetDisputes())
page := paginateDisputes(items, req.Offset, limit)
out := make([]types.Dispute, 0, len(page))
for _, item := range page {
out = append(out, toAPIDispute(item))
}
return &types.DisputeListResp{
Items: out,
Meta: types.PageMeta{
Total: int64(len(items)),
Offset: req.Offset,
Limit: limit,
},
}, nil
}
app/dispute/api/internal/logic/dispute/respondDisputeLogic.go
+80
View File
@@ -0,0 +1,80 @@
// Code scaffolded by goctl. Safe to edit.
// goctl 1.10.1
package dispute
import (
"context"
"errors"
"juwan-backend/app/dispute/api/internal/svc"
"juwan-backend/app/dispute/api/internal/types"
"juwan-backend/app/dispute/rpc/disputeservice"
"juwan-backend/common/utils/contextj"
"github.com/zeromicro/go-zero/core/logx"
)
type RespondDisputeLogic struct {
logx.Logger
ctx context.Context
svcCtx *svc.ServiceContext
}
// 回应争议
func NewRespondDisputeLogic(ctx context.Context, svcCtx *svc.ServiceContext) *RespondDisputeLogic {
return &RespondDisputeLogic{
Logger: logx.WithContext(ctx),
ctx: ctx,
svcCtx: svcCtx,
}
}
func (l *RespondDisputeLogic) RespondDispute(req *types.DisputeResponseReq) (resp *types.EmptyResp, err error) {
uid, err := contextj.UserIDFrom(l.ctx)
if err != nil {
return nil, err
}
if req.Reason == "" {
return nil, errors.New("reason is required")
}
disputeResp, err := l.svcCtx.DisputeRpc.GetDisputesById(l.ctx, &disputeservice.GetDisputesByIdReq{Id: req.Id})
if err != nil {
return nil, err
}
d := disputeResp.GetDisputes()
if d == nil {
return nil, errors.New("dispute not found")
}
if uid != d.GetRespondentId() {
return nil, errors.New("not the respondent of this dispute")
}
if d.GetStatus() != "open" {
return nil, errors.New("dispute status does not allow response")
}
status := "reviewing"
_, err = l.svcCtx.DisputeRpc.UpdateDisputes(l.ctx, &disputeservice.UpdateDisputesReq{
Id: req.Id,
Status: &status,
RespondentReason: &req.Reason,
RespondentEvidence: req.Evidence,
})
if err != nil {
return nil, err
}
_, err = l.svcCtx.DisputeRpc.AddDisputeTimeline(l.ctx, &disputeservice.AddDisputeTimelineReq{
DisputeId: req.Id,
EventType: "response",
ActorId: uid,
ActorName: actorName(uid),
Details: detailsJSON(map[string]any{"reason": req.Reason, "evidence": req.Evidence}),
})
if err != nil {
return nil, err
}
return &types.EmptyResp{}, nil
}
app/dispute/api/internal/svc/serviceContext.go
+23
View File
@@ -0,0 +1,23 @@
package svc
import (
"juwan-backend/app/dispute/api/internal/config"
"juwan-backend/app/dispute/rpc/disputeservice"
"juwan-backend/app/order/rpc/orderservice"
"github.com/zeromicro/go-zero/zrpc"
)
type ServiceContext struct {
Config config.Config
DisputeRpc disputeservice.DisputeService
OrderRpc orderservice.OrderService
}
func NewServiceContext(c config.Config) *ServiceContext {
return &ServiceContext{
Config: c,
DisputeRpc: disputeservice.NewDisputeService(zrpc.MustNewClient(c.DisputeRpcConf)),
OrderRpc: orderservice.NewOrderService(zrpc.MustNewClient(c.OrderRpcConf)),
}
}
app/dispute/api/internal/types/types.go
+88
View File
@@ -0,0 +1,88 @@
// Code generated by goctl. DO NOT EDIT.
// goctl 1.10.1
package types
type AppealReq struct {
DisputePathId
Reason string `json:"reason"`
}
type CreateDisputeReq struct {
DisputePathId
Reason string `json:"reason"`
Evidence []string `json:"evidence"`
}
type Dispute struct {
Id int64 `json:"id"`
OrderId int64 `json:"orderId"`
InitiatorId int64 `json:"initiatorId"`
InitiatorName string `json:"initiatorName"`
RespondentId int64 `json:"respondentId"`
Reason string `json:"reason"`
Evidence []string `json:"evidence"`
Status string `json:"status"`
Result string `json:"result,optional"`
RespondentReason string `json:"respondentReason,optional"`
RespondentEvidence []string `json:"respondentEvidence"`
AppealReason string `json:"appealReason,optional"`
AppealedAt string `json:"appealedAt,optional"`
ResolvedBy int64 `json:"resolvedBy,optional"`
ResolvedAt string `json:"resolvedAt,optional"`
CreatedAt string `json:"createdAt"`
UpdatedAt string `json:"updatedAt"`
}
type DisputeListReq struct {
PageReq
Status string `form:"status,optional"`
}
type DisputeListResp struct {
Items []Dispute `json:"items"`
Meta PageMeta `json:"meta"`
}
type DisputePathId struct {
Id int64 `path:"id"`
}
type DisputeResponseReq struct {
DisputePathId
Reason string `json:"reason"`
Evidence []string `json:"evidence"`
}
type EmptyResp struct {
}
type PageMeta struct {
Total int64 `json:"total"`
Offset int64 `json:"offset"`
Limit int64 `json:"limit"`
}
type PageReq struct {
Offset int64 `form:"offset,default=0"`
Limit int64 `form:"limit,default=20"`
}
type SimpleUser struct {
Id string `json:"id"`
Nickname string `json:"nickname"`
Avatar string `json:"avatar"`
}
type UserProfile struct {
Id string `json:"id"`
Username string `json:"username"`
Nickname string `json:"nickname"`
Avatar string `json:"avatar"`
Role string `json:"role"` // consumer, player, owner, admin
VerifiedRoles []string `json:"verifiedRoles"`
VerificationStatus map[string]string `json:"verificationStatus"`
Phone string `json:"phone,optional"`
Bio string `json:"bio,optional"`
CreatedAt string `json:"createdAt"`
}