363 lines
12 KiB
Go
363 lines
12 KiB
Go
package service
|
|
|
|
import (
|
|
"context"
|
|
"log/slog"
|
|
|
|
"git.lzcwy.cn/zhengchiliu/zt-closet-backend/global"
|
|
"git.lzcwy.cn/zhengchiliu/zt-closet-backend/internal/dto"
|
|
"git.lzcwy.cn/zhengchiliu/zt-closet-backend/internal/mysqldao"
|
|
"git.lzcwy.cn/zhengchiliu/zt-closet-backend/internal/mysqlmodel"
|
|
"git.lzcwy.cn/zhengchiliu/zt-closet-backend/internal/redisdao"
|
|
"git.lzcwy.cn/zhengchiliu/zt-closet-backend/pkg/errcode"
|
|
"git.lzcwy.cn/zhengchiliu/zt-closet-backend/pkg/upload"
|
|
"gorm.io/gorm"
|
|
)
|
|
|
|
// ClosetShareService 衣柜分享业务服务。
|
|
type ClosetShareService struct {
|
|
shareDao *mysqldao.ClosetShareDao
|
|
shareItemDao *mysqldao.ClosetShareItemDao
|
|
receiverDao *mysqldao.ClosetShareReceiverDao
|
|
clothesDao *mysqldao.ClothesDao
|
|
userDao *mysqldao.UserDao
|
|
auditLogDao *mysqldao.ClosetAuditLogDao
|
|
}
|
|
|
|
// NewClosetShareService 创建衣柜分享服务。
|
|
func NewClosetShareService() *ClosetShareService {
|
|
return &ClosetShareService{
|
|
shareDao: mysqldao.NewClosetShareDao(),
|
|
shareItemDao: mysqldao.NewClosetShareItemDao(),
|
|
receiverDao: mysqldao.NewClosetShareReceiverDao(),
|
|
clothesDao: mysqldao.NewClothesDao(),
|
|
userDao: mysqldao.NewUserDao(),
|
|
auditLogDao: mysqldao.NewClosetAuditLogDao(),
|
|
}
|
|
}
|
|
|
|
// Create 创建衣柜分享。部分分享需指定衣物；全量快照分享快照当前全部衣物。创建即自动审核通过。
|
|
func (s *ClosetShareService) Create(ctx context.Context, userID int64, request *dto.ClosetShareCreateRequest) (*dto.ClosetShareCreateResponse, *errcode.Error) {
|
|
ctx, span := global.Tracer.Start(ctx, "svc.ClosetShareCreate")
|
|
defer span.End()
|
|
|
|
// 校验过期时间：必须晚于当前时间（0 表示不设置过期时间）。
|
|
if request.ExpireTime > 0 && request.ExpireTime <= nowUnix() {
|
|
return nil, errcode.InvalidParams.WithDetails("过期时间必须晚于当前时间")
|
|
}
|
|
|
|
// 1. 确定分享的衣物 ID 集合。
|
|
var clothesIDs []int64
|
|
switch request.ShareType {
|
|
case ShareTypePartial:
|
|
if len(request.ClothesUUIDs) == 0 {
|
|
return nil, errcode.InvalidParams.WithDetails("部分分享需选择衣物")
|
|
}
|
|
ids, cerr := s.resolveOwnedClothesIDs(ctx, userID, request.ClothesUUIDs)
|
|
if cerr != nil {
|
|
return nil, cerr
|
|
}
|
|
clothesIDs = ids
|
|
case ShareTypeSnapshot:
|
|
ids, err := s.allUserClothesIDs(ctx, userID)
|
|
if err != nil {
|
|
return nil, errcode.DatabaseError
|
|
}
|
|
clothesIDs = ids
|
|
default:
|
|
return nil, errcode.InvalidParams
|
|
}
|
|
|
|
// 2. 消耗衣柜分享每日额度。
|
|
if qerr := consumeDailyQuota(ctx, userID, QuotaTypeClosetShare, 1, "衣柜分享消耗"); qerr != nil {
|
|
return nil, qerr
|
|
}
|
|
|
|
// 3. 原子创建分享及快照明细，避免留下空分享。
|
|
shareUUID := genUUID()
|
|
share := &mysqlmodel.ClosetShare{ShareUUID: shareUUID, UserID: userID, ShareType: request.ShareType, ExpireTime: request.ExpireTime, Status: ShareStatusNormal}
|
|
items := make([]mysqlmodel.ClosetShareItem, 0, len(clothesIDs))
|
|
for _, cid := range clothesIDs {
|
|
items = append(items, mysqlmodel.ClosetShareItem{ShareUUID: shareUUID, ClothesID: cid})
|
|
}
|
|
if err := global.MysqlEngine.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
|
|
if err := tx.Create(share).Error; err != nil {
|
|
return err
|
|
}
|
|
if len(items) > 0 {
|
|
return tx.Create(&items).Error
|
|
}
|
|
return nil
|
|
}); err != nil {
|
|
refundDailyQuota(ctx, userID, QuotaTypeClosetShare, 1)
|
|
return nil, errcode.DatabaseError
|
|
}
|
|
|
|
// 5. 自动审核通过，写审核日志（best-effort：失败仅告警不阻断创建）。
|
|
if err := s.auditLogDao.ClosetAuditLogCreate(ctx, &mysqlmodel.ClosetAuditLog{
|
|
TargetID: share.ID,
|
|
AuditResult: AuditResultPass,
|
|
AuditTime: nowUnix(),
|
|
}); err != nil {
|
|
slog.WarnContext(ctx, "write closet audit log failed", "share_id", share.ID, "error", err)
|
|
}
|
|
|
|
return &dto.ClosetShareCreateResponse{ShareUUID: shareUUID}, nil
|
|
}
|
|
|
|
// Detail 查看分享详情（访客/属主视角）。
|
|
func (s *ClosetShareService) Detail(ctx context.Context, userID int64, shareUUID string) (*dto.ClosetShareDetailResponse, *errcode.Error) {
|
|
ctx, span := global.Tracer.Start(ctx, "svc.ClosetShareDetail")
|
|
defer span.End()
|
|
|
|
share, err := s.shareDao.ClosetShareGetByUUID(ctx, shareUUID)
|
|
if err != nil {
|
|
if isNotFound(err) {
|
|
return nil, errcode.ShareNotFound
|
|
}
|
|
return nil, errcode.DatabaseError
|
|
}
|
|
|
|
// 状态校验。
|
|
switch share.Status {
|
|
case ShareStatusCancelled:
|
|
return nil, errcode.ShareCancelled
|
|
case ShareStatusBanned:
|
|
return nil, errcode.ShareNotFound
|
|
case ShareStatusExpired:
|
|
return nil, errcode.ShareExpired
|
|
}
|
|
// 时间过期校验。
|
|
if share.ExpireTime > 0 && nowUnix() > share.ExpireTime {
|
|
_ = s.shareDao.ClosetShareUpdateStatus(ctx, shareUUID, ShareStatusExpired)
|
|
return nil, errcode.ShareExpired
|
|
}
|
|
|
|
isOwner := share.UserID == userID
|
|
|
|
// 访问计数（访客计入）。
|
|
if !isOwner {
|
|
_, _ = redisdao.ClosetShareViewIncr(ctx, shareUUID)
|
|
}
|
|
|
|
// 加载分享的衣物。
|
|
shareItems, ierr := s.shareItemDao.ClosetShareItemListByShareUUID(ctx, shareUUID)
|
|
if ierr != nil {
|
|
return nil, errcode.DatabaseError
|
|
}
|
|
clothesIDs := make([]int64, 0, len(shareItems))
|
|
for _, it := range shareItems {
|
|
clothesIDs = append(clothesIDs, it.ClothesID)
|
|
}
|
|
clothesList, cerr := s.clothesDao.ClothesGetByIDs(ctx, clothesIDs)
|
|
if cerr != nil {
|
|
return nil, errcode.DatabaseError
|
|
}
|
|
clothesResp := make([]dto.ClothesGetByUUIDResponse, 0, len(clothesList))
|
|
for i := range clothesList {
|
|
clothesResp = append(clothesResp, buildClothesResponse(&clothesList[i]))
|
|
}
|
|
|
|
// 记录接收关系：登录且非属主用户成功访问即视为收到，幂等，失败不阻断详情返回。
|
|
if userID > 0 && !isOwner {
|
|
if rerr := s.receiverDao.ClosetShareReceiverUpsert(ctx, shareUUID, userID); rerr != nil {
|
|
slog.WarnContext(ctx, "record closet share receiver failed", "share_uuid", shareUUID, "user_id", userID, "error", rerr)
|
|
}
|
|
}
|
|
|
|
// 分享者信息。
|
|
ownerName, ownerAvatar := "", ""
|
|
if owner, oerr := s.userDao.UserGetByID(ctx, share.UserID); oerr == nil {
|
|
ownerName = owner.Username
|
|
ownerAvatar = upload.AvatarURL(owner.Avatar)
|
|
}
|
|
|
|
return &dto.ClosetShareDetailResponse{
|
|
ShareUUID: shareUUID,
|
|
OwnerName: ownerName,
|
|
OwnerAvatar: ownerAvatar,
|
|
Clothes: clothesResp,
|
|
ExpireTime: share.ExpireTime,
|
|
Status: share.Status,
|
|
IsOwner: isOwner,
|
|
}, nil
|
|
}
|
|
|
|
// List 分页查询我的分享。
|
|
func (s *ClosetShareService) List(ctx context.Context, userID int64, request *dto.ClosetShareListRequest) (*dto.ShareListResponse, *errcode.Error) {
|
|
ctx, span := global.Tracer.Start(ctx, "svc.ClosetShareList")
|
|
defer span.End()
|
|
|
|
page, pageSize := normalizePage(request.Page, request.PageSize)
|
|
|
|
list, total, err := s.shareDao.ClosetShareListByUserID(ctx, userID, request.Status, page, pageSize)
|
|
if err != nil {
|
|
return nil, errcode.DatabaseError
|
|
}
|
|
|
|
// 批量统计各分享的衣物数量。
|
|
shareUUIDs := make([]string, 0, len(list))
|
|
for _, sh := range list {
|
|
shareUUIDs = append(shareUUIDs, sh.ShareUUID)
|
|
}
|
|
countByShare := make(map[string]int, len(list))
|
|
if allItems, ierr := s.shareItemDao.ClosetShareItemListByShareUUIDs(ctx, shareUUIDs); ierr == nil {
|
|
for _, it := range allItems {
|
|
countByShare[it.ShareUUID]++
|
|
}
|
|
}
|
|
|
|
items := make([]dto.ClosetShareItemResponse, 0, len(list))
|
|
for _, sh := range list {
|
|
items = append(items, dto.ClosetShareItemResponse{
|
|
ShareUUID: sh.ShareUUID,
|
|
ShareType: sh.ShareType,
|
|
ClothesCount: countByShare[sh.ShareUUID],
|
|
ExpireTime: sh.ExpireTime,
|
|
Status: sh.Status,
|
|
})
|
|
}
|
|
|
|
return &dto.ShareListResponse{
|
|
PageResponse: dto.PageResponse{Total: total, Page: page, PageSize: pageSize},
|
|
List: items,
|
|
}, nil
|
|
}
|
|
|
|
// ListReceived 分页查询"分享给我的"分享。
|
|
func (s *ClosetShareService) ListReceived(ctx context.Context, userID int64, request *dto.ClosetShareListRequest) (*dto.ShareListResponse, *errcode.Error) {
|
|
ctx, span := global.Tracer.Start(ctx, "svc.ClosetShareReceivedList")
|
|
defer span.End()
|
|
|
|
page, pageSize := normalizePage(request.Page, request.PageSize)
|
|
|
|
list, total, err := s.receiverDao.ClosetShareReceivedList(ctx, userID, request.Status, page, pageSize)
|
|
if err != nil {
|
|
return nil, errcode.DatabaseError
|
|
}
|
|
|
|
// 批量统计各分享的衣物数量。
|
|
shareUUIDs := make([]string, 0, len(list))
|
|
ownerIDs := make([]int64, 0, len(list))
|
|
for _, sh := range list {
|
|
shareUUIDs = append(shareUUIDs, sh.ShareUUID)
|
|
ownerIDs = append(ownerIDs, sh.UserID)
|
|
}
|
|
countByShare := make(map[string]int, len(list))
|
|
if allItems, ierr := s.shareItemDao.ClosetShareItemListByShareUUIDs(ctx, shareUUIDs); ierr == nil {
|
|
for _, it := range allItems {
|
|
countByShare[it.ShareUUID]++
|
|
}
|
|
}
|
|
|
|
// 批量查询分享者信息。
|
|
ownerByID := make(map[int64]mysqlmodel.User, len(ownerIDs))
|
|
if owners, oerr := s.userDao.UserGetByIDs(ctx, ownerIDs); oerr == nil {
|
|
for _, u := range owners {
|
|
ownerByID[u.ID] = u
|
|
}
|
|
}
|
|
|
|
items := make([]dto.ClosetShareItemResponse, 0, len(list))
|
|
for _, sh := range list {
|
|
ownerName, ownerAvatar := "", ""
|
|
if owner, ok := ownerByID[sh.UserID]; ok {
|
|
ownerName = owner.Username
|
|
ownerAvatar = upload.AvatarURL(owner.Avatar)
|
|
}
|
|
items = append(items, dto.ClosetShareItemResponse{
|
|
ShareUUID: sh.ShareUUID,
|
|
ShareType: sh.ShareType,
|
|
ClothesCount: countByShare[sh.ShareUUID],
|
|
ExpireTime: sh.ExpireTime,
|
|
Status: sh.Status,
|
|
OwnerName: ownerName,
|
|
OwnerAvatar: ownerAvatar,
|
|
CreatedAt: sh.CreatedAt,
|
|
})
|
|
}
|
|
|
|
return &dto.ShareListResponse{
|
|
PageResponse: dto.PageResponse{Total: total, Page: page, PageSize: pageSize},
|
|
List: items,
|
|
}, nil
|
|
}
|
|
|
|
// Cancel 取消分享（校验归属）。
|
|
func (s *ClosetShareService) Cancel(ctx context.Context, userID int64, request *dto.ClosetShareCancelRequest) (*dto.CollectResponse, *errcode.Error) {
|
|
ctx, span := global.Tracer.Start(ctx, "svc.ClosetShareCancel")
|
|
defer span.End()
|
|
|
|
share, err := s.shareDao.ClosetShareGetByUUID(ctx, request.ShareUUID)
|
|
if err != nil {
|
|
if isNotFound(err) {
|
|
return nil, errcode.ShareNotFound
|
|
}
|
|
return nil, errcode.DatabaseError
|
|
}
|
|
if share.UserID != userID {
|
|
return nil, errcode.Forbidden
|
|
}
|
|
if err := s.shareDao.ClosetShareUpdateStatus(ctx, request.ShareUUID, ShareStatusCancelled); err != nil {
|
|
return nil, errcode.DatabaseError
|
|
}
|
|
return &dto.CollectResponse{}, nil
|
|
}
|
|
|
|
// ---- 内部辅助 ----
|
|
|
|
// resolveOwnedClothesIDs 校验衣物均属于用户，返回有序去重的 clothesID 列表。
|
|
func (s *ClosetShareService) resolveOwnedClothesIDs(ctx context.Context, userID int64, uuids []string) ([]int64, *errcode.Error) {
|
|
dedup := make([]string, 0, len(uuids))
|
|
seen := make(map[string]struct{}, len(uuids))
|
|
for _, u := range uuids {
|
|
if _, ok := seen[u]; ok {
|
|
continue
|
|
}
|
|
seen[u] = struct{}{}
|
|
dedup = append(dedup, u)
|
|
}
|
|
|
|
clothesList, err := s.clothesDao.ClothesGetByUUIDs(ctx, dedup)
|
|
if err != nil {
|
|
return nil, errcode.DatabaseError
|
|
}
|
|
byUUID := make(map[string]mysqlmodel.Clothes, len(clothesList))
|
|
for _, c := range clothesList {
|
|
byUUID[c.ClothesUUID] = c
|
|
}
|
|
|
|
ids := make([]int64, 0, len(dedup))
|
|
for _, u := range dedup {
|
|
c, ok := byUUID[u]
|
|
if !ok {
|
|
return nil, errcode.ClothesNotFound
|
|
}
|
|
if c.UserID != userID {
|
|
return nil, errcode.ClothesNoPermission
|
|
}
|
|
ids = append(ids, c.ID)
|
|
}
|
|
return ids, nil
|
|
}
|
|
|
|
// allUserClothesIDs 获取用户当前全部衣物 ID（分页遍历）。
|
|
func (s *ClosetShareService) allUserClothesIDs(ctx context.Context, userID int64) ([]int64, error) {
|
|
var ids []int64
|
|
page, pageSize := 1, 200
|
|
for {
|
|
list, total, err := s.clothesDao.ClothesListByUserID(ctx, userID, "", "", page, pageSize)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
for _, c := range list {
|
|
ids = append(ids, c.ID)
|
|
}
|
|
if len(list) == 0 || int64(page*pageSize) >= total {
|
|
break
|
|
}
|
|
page++
|
|
}
|
|
return ids, nil
|
|
}
|