yml2213andClaude Opus 4.8
be5d322c10
新增客服「封存订单」动作，用于号主失联、无法联系的场景：单事务内 完成关闭订单、全量原路退款、永久封存关联商品、解散发布群、双方通知 与审计日志。 - 新增 listing 终态 sealed（封存），区别于可恢复的 offline - listingLockedForOwnerMutation 锁定 sealed，号主无法再编辑/提审/上架 - 解散群聊按 listing_id 查发布群（listing_group）置 archived， 阻断所有成员发言并留系统消息 - 新增 order.AdminSeal 及 /admin/orders/:id/seal 路由 - 前端：卖家页 PC/移动端 sealed 视为终态禁用操作，客服后台新增 「封存订单」按钮与二次确认 Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
272 lines
8.2 KiB
Go
272 lines
8.2 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")
|
|
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")
|
|
ErrInvalidCheckoutAmount = errors.New("invalid checkout amount")
|
|
ErrPermissionDenied = errors.New("permission denied")
|
|
)
|
|
|
|
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) ([]OrderDTO, error) {
|
|
if s.repo == nil {
|
|
return nil, ErrDependencyUnavailable
|
|
}
|
|
return s.repo.ListForUser(ctx, userID)
|
|
}
|
|
|
|
func (s *Service) ListAdmin(ctx context.Context, query AdminOrderQuery) (*PaginatedResult, 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) 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)
|
|
}
|