yml2213
85332df2bd
- 订单列表使用独立最小 DTO 并分页，号主待办提供独立接口与统计 - 用户 token 增加版本控制，冻结/改密/退出即时撤销会话 - 移除 URL token 传参，SSE 与接口统一使用 HttpOnly Cookie - 私有文件按上传归属与业务关联授权，收款凭证转私有访问并校验归属 - 公开商品接口返回最小字段，隐藏号主身份与内部状态 - 每日清理超过 30 天未关联业务的上传归属，上传归属失败时补偿删除对象
371 lines
12 KiB
Go
371 lines
12 KiB
Go
package order
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
)
|
|
|
|
var (
|
|
ErrDependencyUnavailable = errors.New("dependency unavailable")
|
|
ErrInvalidRentHours = errors.New("invalid rent hours")
|
|
ErrListingUnavailable = errors.New("listing unavailable")
|
|
ErrCannotRentOwnListing = errors.New("cannot rent own listing")
|
|
ErrInsufficientBalance = errors.New("insufficient balance")
|
|
ErrOrderCannotPay = errors.New("order cannot pay")
|
|
ErrChannelPaymentRequired = errors.New("channel payment required")
|
|
ErrOrderCannotCancel = errors.New("order cannot cancel")
|
|
ErrOrderCannotHandoff = errors.New("order cannot handoff")
|
|
ErrOrderCannotForceHandoff = errors.New("order cannot force handoff")
|
|
ErrOrderCannotResetHandoff = errors.New("order cannot reset handoff")
|
|
ErrOrderCannotReceive = errors.New("order cannot receive")
|
|
ErrOrderCannotReturn = errors.New("order cannot return")
|
|
ErrOrderCannotComplete = errors.New("order cannot complete")
|
|
ErrCheckoutCannotSubmit = errors.New("checkout cannot submit")
|
|
ErrCheckoutCannotConfirm = errors.New("checkout cannot confirm")
|
|
ErrCheckoutCannotCounter = errors.New("checkout cannot counter")
|
|
ErrCheckoutMaxRounds = errors.New("checkout max rounds reached")
|
|
ErrCheckoutDepositShortfall = errors.New("checkout deposit shortfall")
|
|
ErrInvalidCheckoutAmount = errors.New("invalid checkout amount")
|
|
ErrDisputeExists = errors.New("dispute already exists")
|
|
ErrPermissionDenied = errors.New("permission denied")
|
|
ErrDepositCannotHold = errors.New("deposit cannot hold")
|
|
ErrDepositNotHeld = errors.New("deposit not held")
|
|
ErrDepositHoldAmountEmpty = errors.New("deposit hold amount empty")
|
|
ErrOfflineSettlementCannotMark = errors.New("offline settlement cannot mark")
|
|
ErrInvalidSellerHandoffStatus = errors.New("invalid seller handoff status")
|
|
)
|
|
|
|
const internalOrderHours = 24
|
|
|
|
type Service struct {
|
|
repo *Repository
|
|
}
|
|
|
|
func NewService(repo *Repository) *Service {
|
|
return &Service{repo: repo}
|
|
}
|
|
|
|
func (s *Service) Create(ctx context.Context, userID uint64, req CreateRequest) (*OrderDTO, error) {
|
|
if s.repo == nil {
|
|
return nil, ErrDependencyUnavailable
|
|
}
|
|
if req.ListingID == 0 {
|
|
return nil, ErrInvalidRentHours
|
|
}
|
|
return s.repo.Create(ctx, userID, req)
|
|
}
|
|
|
|
func (s *Service) Cancel(ctx context.Context, userID uint64, orderID uint64) error {
|
|
if s.repo == nil {
|
|
return ErrDependencyUnavailable
|
|
}
|
|
return s.repo.Cancel(ctx, userID, orderID)
|
|
}
|
|
|
|
func (s *Service) Pay(ctx context.Context, userID uint64, orderID uint64) error {
|
|
if s.repo == nil {
|
|
return ErrDependencyUnavailable
|
|
}
|
|
if orderID == 0 {
|
|
return ErrOrderCannotPay
|
|
}
|
|
return s.repo.Pay(ctx, userID, orderID)
|
|
}
|
|
|
|
func (s *Service) SubmitHandoff(ctx context.Context, userID uint64, orderID uint64, req SubmitHandoffRequest) (*HandoffRecordDTO, error) {
|
|
if s.repo == nil {
|
|
return nil, ErrDependencyUnavailable
|
|
}
|
|
if orderID == 0 || req.Content == "" {
|
|
return nil, ErrOrderCannotHandoff
|
|
}
|
|
return s.repo.SubmitHandoff(ctx, userID, orderID, req)
|
|
}
|
|
|
|
func (s *Service) ConfirmReceive(ctx context.Context, userID uint64, orderID uint64) error {
|
|
if s.repo == nil {
|
|
return ErrDependencyUnavailable
|
|
}
|
|
return s.repo.ConfirmReceive(ctx, userID, orderID)
|
|
}
|
|
|
|
func (s *Service) HandoffRecords(ctx context.Context, userID uint64, orderID uint64) ([]HandoffRecordDTO, error) {
|
|
if s.repo == nil {
|
|
return nil, ErrDependencyUnavailable
|
|
}
|
|
return s.repo.HandoffRecords(ctx, userID, orderID)
|
|
}
|
|
|
|
func (s *Service) SubmitReturn(ctx context.Context, userID uint64, orderID uint64, req SubmitReturnRequest) (*HandoffRecordDTO, error) {
|
|
if s.repo == nil {
|
|
return nil, ErrDependencyUnavailable
|
|
}
|
|
if orderID == 0 || req.Content == "" {
|
|
return nil, ErrOrderCannotReturn
|
|
}
|
|
return s.repo.SubmitReturn(ctx, userID, orderID, req)
|
|
}
|
|
|
|
func (s *Service) SubmitCheckout(ctx context.Context, userID uint64, orderID uint64, req SubmitCheckoutRequest) (*HandoffRecordDTO, error) {
|
|
if s.repo == nil {
|
|
return nil, ErrDependencyUnavailable
|
|
}
|
|
if orderID == 0 || req.Content == "" {
|
|
return nil, ErrCheckoutCannotSubmit
|
|
}
|
|
return s.repo.SubmitCheckout(ctx, userID, orderID, req)
|
|
}
|
|
|
|
func (s *Service) ConfirmReturn(ctx context.Context, userID uint64, orderID uint64) error {
|
|
if s.repo == nil {
|
|
return ErrDependencyUnavailable
|
|
}
|
|
return s.repo.ConfirmReturn(ctx, userID, orderID)
|
|
}
|
|
|
|
func (s *Service) ConfirmCheckout(ctx context.Context, userID uint64, orderID uint64) error {
|
|
if s.repo == nil {
|
|
return ErrDependencyUnavailable
|
|
}
|
|
return s.repo.ConfirmCheckout(ctx, userID, orderID)
|
|
}
|
|
|
|
func (s *Service) CounterCheckout(ctx context.Context, userID uint64, orderID uint64, req CounterCheckoutRequest) (*CheckoutDTO, error) {
|
|
if s.repo == nil {
|
|
return nil, ErrDependencyUnavailable
|
|
}
|
|
if orderID == 0 || req.Reason == "" {
|
|
return nil, ErrCheckoutCannotCounter
|
|
}
|
|
return s.repo.CounterCheckout(ctx, userID, orderID, req)
|
|
}
|
|
|
|
func (s *Service) AcceptCheckout(ctx context.Context, userID uint64, orderID uint64) error {
|
|
if s.repo == nil {
|
|
return ErrDependencyUnavailable
|
|
}
|
|
return s.repo.AcceptCheckout(ctx, userID, orderID)
|
|
}
|
|
|
|
func (s *Service) ListForUser(ctx context.Context, userID uint64, page, pageSize int) (*UserPaginatedResult, error) {
|
|
if s.repo == nil {
|
|
return nil, ErrDependencyUnavailable
|
|
}
|
|
return s.repo.ListForUser(ctx, userID, page, pageSize)
|
|
}
|
|
|
|
func (s *Service) ListSellerHandoffs(ctx context.Context, userID uint64, query SellerHandoffQuery) (*SellerHandoffPaginatedResult, error) {
|
|
if s.repo == nil {
|
|
return nil, ErrDependencyUnavailable
|
|
}
|
|
if query.Status != "" && !isSellerHandoffStatus(query.Status) {
|
|
return nil, ErrInvalidSellerHandoffStatus
|
|
}
|
|
return s.repo.ListSellerHandoffs(ctx, userID, query)
|
|
}
|
|
|
|
func (s *Service) ListAdmin(ctx context.Context, query AdminOrderQuery) (*AdminOrderListPaginatedResult, error) {
|
|
if s.repo == nil {
|
|
return nil, ErrDependencyUnavailable
|
|
}
|
|
return s.repo.ListAdmin(ctx, query)
|
|
}
|
|
|
|
func (s *Service) FindAdmin(ctx context.Context, orderID uint64) (*OrderDTO, error) {
|
|
if s.repo == nil {
|
|
return nil, ErrDependencyUnavailable
|
|
}
|
|
return s.repo.FindAdmin(ctx, orderID)
|
|
}
|
|
|
|
func (s *Service) FindLatestAdminByListing(ctx context.Context, listingID uint64) (*OrderDTO, error) {
|
|
if s.repo == nil {
|
|
return nil, ErrDependencyUnavailable
|
|
}
|
|
if listingID == 0 {
|
|
return nil, ErrListingUnavailable
|
|
}
|
|
return s.repo.FindLatestAdminByListing(ctx, listingID)
|
|
}
|
|
|
|
func (s *Service) HandoffRecordsAdmin(ctx context.Context, orderID uint64) ([]HandoffRecordDTO, error) {
|
|
if s.repo == nil {
|
|
return nil, ErrDependencyUnavailable
|
|
}
|
|
return s.repo.HandoffRecordsAdmin(ctx, orderID)
|
|
}
|
|
|
|
func (s *Service) AdminClose(ctx context.Context, adminID uint64, orderID uint64, req AdminActionRequest, meta AuditMeta) error {
|
|
if s.repo == nil {
|
|
return ErrDependencyUnavailable
|
|
}
|
|
if orderID == 0 || req.Reason == "" {
|
|
return ErrOrderCannotComplete
|
|
}
|
|
return s.repo.AdminClose(ctx, adminID, orderID, req, meta)
|
|
}
|
|
|
|
func (s *Service) AdminMarkAbnormal(ctx context.Context, adminID uint64, orderID uint64, req AdminActionRequest, meta AuditMeta) error {
|
|
if s.repo == nil {
|
|
return ErrDependencyUnavailable
|
|
}
|
|
if orderID == 0 || req.Reason == "" {
|
|
return ErrOrderCannotComplete
|
|
}
|
|
return s.repo.AdminMarkAbnormal(ctx, adminID, orderID, req, meta)
|
|
}
|
|
|
|
func (s *Service) AdminSeal(ctx context.Context, adminID uint64, orderID uint64, req AdminActionRequest, meta AuditMeta) error {
|
|
if s.repo == nil {
|
|
return ErrDependencyUnavailable
|
|
}
|
|
if orderID == 0 || req.Reason == "" {
|
|
return ErrOrderCannotComplete
|
|
}
|
|
return s.repo.AdminSeal(ctx, adminID, orderID, req, meta)
|
|
}
|
|
|
|
func (s *Service) AdminResetHandoff(ctx context.Context, adminID uint64, orderID uint64, req AdminActionRequest, meta AuditMeta) error {
|
|
if s.repo == nil {
|
|
return ErrDependencyUnavailable
|
|
}
|
|
if orderID == 0 || req.Reason == "" {
|
|
return ErrOrderCannotResetHandoff
|
|
}
|
|
return s.repo.AdminResetHandoff(ctx, adminID, orderID, req, meta)
|
|
}
|
|
|
|
func (s *Service) AdminPlatformHandoff(ctx context.Context, adminID uint64, orderID uint64, req PlatformHandoffRequest, meta AuditMeta) (*HandoffRecordDTO, error) {
|
|
if s.repo == nil {
|
|
return nil, ErrDependencyUnavailable
|
|
}
|
|
if orderID == 0 || req.Content == "" || req.Reason == "" {
|
|
return nil, ErrOrderCannotHandoff
|
|
}
|
|
return s.repo.AdminPlatformHandoff(ctx, adminID, orderID, req, meta)
|
|
}
|
|
|
|
func (s *Service) AdminForceHandoff(ctx context.Context, adminID uint64, orderID uint64, req ForceHandoffRequest, meta AuditMeta) error {
|
|
if s.repo == nil {
|
|
return ErrDependencyUnavailable
|
|
}
|
|
if orderID == 0 || req.Reason == "" {
|
|
return ErrOrderCannotForceHandoff
|
|
}
|
|
return s.repo.AdminForceHandoff(ctx, adminID, orderID, req, meta)
|
|
}
|
|
|
|
func (s *Service) AdminPlatformCheckoutConfirm(ctx context.Context, adminID uint64, orderID uint64, req AdminActionRequest, meta AuditMeta) error {
|
|
if s.repo == nil {
|
|
return ErrDependencyUnavailable
|
|
}
|
|
if orderID == 0 || req.Reason == "" {
|
|
return ErrCheckoutCannotConfirm
|
|
}
|
|
return s.repo.AdminPlatformCheckoutConfirm(ctx, adminID, orderID, req, meta)
|
|
}
|
|
|
|
func (s *Service) AdminPlatformCheckoutCounter(ctx context.Context, adminID uint64, orderID uint64, req CounterCheckoutRequest, meta AuditMeta) (*CheckoutDTO, error) {
|
|
if s.repo == nil {
|
|
return nil, ErrDependencyUnavailable
|
|
}
|
|
if orderID == 0 || req.Reason == "" {
|
|
return nil, ErrCheckoutCannotCounter
|
|
}
|
|
return s.repo.AdminPlatformCheckoutCounter(ctx, adminID, orderID, req, meta)
|
|
}
|
|
|
|
func (s *Service) AdminPlatformCheckoutDispute(ctx context.Context, adminID uint64, orderID uint64, req AdminActionRequest, meta AuditMeta) error {
|
|
if s.repo == nil {
|
|
return ErrDependencyUnavailable
|
|
}
|
|
if orderID == 0 || req.Reason == "" {
|
|
return ErrCheckoutCannotCounter
|
|
}
|
|
return s.repo.AdminPlatformCheckoutDispute(ctx, adminID, orderID, req, meta)
|
|
}
|
|
|
|
func (s *Service) AdminMarkOfflineSettlement(ctx context.Context, adminID uint64, orderID uint64, req OfflineSettlementRequest, meta AuditMeta) error {
|
|
if s.repo == nil {
|
|
return ErrDependencyUnavailable
|
|
}
|
|
if orderID == 0 {
|
|
return ErrOfflineSettlementCannotMark
|
|
}
|
|
return s.repo.AdminMarkOfflineSettlement(ctx, adminID, orderID, req, meta)
|
|
}
|
|
|
|
func (s *Service) AdminHoldDeposit(ctx context.Context, adminID uint64, orderID uint64, req AdminActionRequest, meta AuditMeta) error {
|
|
if s.repo == nil {
|
|
return ErrDependencyUnavailable
|
|
}
|
|
if orderID == 0 || req.Reason == "" {
|
|
return ErrDepositCannotHold
|
|
}
|
|
return s.repo.AdminHoldDeposit(ctx, adminID, orderID, req, meta)
|
|
}
|
|
|
|
func (s *Service) AdminReleaseDeposit(ctx context.Context, adminID uint64, orderID uint64, req AdminActionRequest, meta AuditMeta) error {
|
|
if s.repo == nil {
|
|
return ErrDependencyUnavailable
|
|
}
|
|
if orderID == 0 || req.Reason == "" {
|
|
return ErrDepositCannotHold
|
|
}
|
|
return s.repo.AdminReleaseDeposit(ctx, adminID, orderID, req, meta)
|
|
}
|
|
|
|
func (s *Service) AdminRefund(ctx context.Context, orderID uint64) (*RefundStatusDTO, error) {
|
|
if s.repo == nil {
|
|
return nil, ErrDependencyUnavailable
|
|
}
|
|
if orderID == 0 {
|
|
return nil, ErrOrderCannotComplete
|
|
}
|
|
return s.repo.AdminRefund(ctx, orderID)
|
|
}
|
|
|
|
func (s *Service) AdminRefundStatus(ctx context.Context, orderID uint64) (*RefundStatusDTO, error) {
|
|
if s.repo == nil {
|
|
return nil, ErrDependencyUnavailable
|
|
}
|
|
if orderID == 0 {
|
|
return nil, ErrOrderCannotComplete
|
|
}
|
|
return s.repo.AdminRefundStatus(ctx, orderID)
|
|
}
|
|
|
|
func (s *Service) AdminApproveRefund(ctx context.Context, orderID uint64) error {
|
|
if s.repo == nil {
|
|
return ErrDependencyUnavailable
|
|
}
|
|
if orderID == 0 {
|
|
return ErrOrderCannotComplete
|
|
}
|
|
return s.repo.AdminApproveRefund(ctx, orderID)
|
|
}
|
|
|
|
func (s *Service) AdminRejectRefund(ctx context.Context, orderID uint64, action string) error {
|
|
if s.repo == nil {
|
|
return ErrDependencyUnavailable
|
|
}
|
|
if orderID == 0 {
|
|
return ErrOrderCannotComplete
|
|
}
|
|
return s.repo.AdminRejectRefund(ctx, orderID, action)
|
|
}
|
|
|
|
func (s *Service) ListPendingRefund(ctx context.Context) ([]OrderDTO, error) {
|
|
if s.repo == nil {
|
|
return nil, ErrDependencyUnavailable
|
|
}
|
|
return s.repo.ListPendingRefund(ctx)
|
|
}
|
|
|
|
func (s *Service) FindForUser(ctx context.Context, userID uint64, orderID uint64) (*OrderDTO, error) {
|
|
if s.repo == nil {
|
|
return nil, ErrDependencyUnavailable
|
|
}
|
|
return s.repo.FindForUser(ctx, userID, orderID)
|
|
}
|