DDD(Domain Driven Design)#

1
package service
2

3
import (
4
  "context"
5
  "errors"
6
  "time"
7
)
8

9
type SubscriptionService struct {
10
  userRepo       UserRepository
11
  subscriptionRepo SubscriptionRepository
12
  billingService  BillingService
13
}
14

15
func (s *SubscriptionService) UpdateSubscription(ctx context.Context, userID string, newPlan string) error {
16
  // 获取用户
17
  user, err := s.userRepo.GetByID(ctx, userID)
18
  if err != nil {
19
    return err
20
  }
21
  if user == nil {
22
    return errors.New("user not found")
23
  }
24

25
  // 获取当前订阅
26
  currentSubscription, err := s.subscriptionRepo.GetByUserID(ctx, userID)
27
  if err != nil {
28
    return err
29
  }
30
  if currentSubscription == nil {
31
    return errors.New("no active subscription found")
32
  }
33

34
  // 检查订阅状态
35
  if currentSubscription.Status != "active" {
36
    return errors.New("subscription is not active")
37
  }
38

39
  // 检查新计划是否与当前计划相同
40
  if newPlan == currentSubscription.Plan {
41
    return errors.New("new plan is the same as current plan")
42
  }
43

44
  // 检查用户是否有资格升级到新计划
45
  if !isEligibleForPlan(user, newPlan) {
46
    return errors.New("user is not eligible for this plan")
47
  }
48

49
  // 计算价格差
50
  priceDifference, err := calculatePriceDifference(currentSubscription.Plan, newPlan)
51
  if err != nil {
52
    return err
53
  }
54

55
  // 存储旧计划以便回滚
56
  oldPlan := currentSubscription.Plan
57

58
  // 更新订阅计划
59
  currentSubscription.Plan = newPlan
60
  currentSubscription.UpdatedAt = time.Now()
61
  err = s.subscriptionRepo.Update(ctx, currentSubscription)
62
  if err != nil {
63
    return err
64
  }
65

66
  // 调整账单
67
  err = s.billingService.AdjustBilling(ctx, userID, priceDifference)
68
  if err != nil {
69
    // 回滚订阅更新
70
    currentSubscription.Plan = oldPlan
71
    s.subscriptionRepo.Update(ctx, currentSubscription)
72
    return err
73
  }
74

75
  return nil
76
}

1
package domain
2

3
import (
4
  "errors"
5
  "time"
6
)
7

8
// Plan 代表订阅计划
9
type Plan struct {
10
  Name  string
11
  Price float64
12
}
13

14
func (p *Plan) CanUpgradeFrom(current *Plan) bool {
15
  // 定义升级规则
16
  return true // 简化示例
17
}
18

19
func (p *Plan) PriceDifference(current *Plan) float64 {
20
  return p.Price - current.Price
21
}
22

23
// Subscription 代表用户订阅
24
type Subscription struct {
25
  ID          string
26
  UserID      string
27
  CurrentPlan *Plan
28
  Status      string
29
  CreatedAt   time.Time
30
  UpdatedAt   time.Time
31
}
32

33
func (s *Subscription) IsActive() bool {
34
  return s.Status == "active"
35
}
36

37
func (s *Subscription) CanUpdateTo(newPlan *Plan) error {
38
  if !s.IsActive() {
39
    return errors.New("subscription is not active")
40
  }
41
  if newPlan.Name == s.CurrentPlan.Name {
42
    return errors.New("new plan is the same as current plan")
43
  }
44
  if !newPlan.CanUpgradeFrom(s.CurrentPlan) {
45
    return errors.New("cannot upgrade to this plan from current plan")
46
  }
47
  return nil
48
}
49

50
func (s *Subscription) UpdateTo(newPlan *Plan) {
51
  s.CurrentPlan = newPlan
52
  s.UpdatedAt = time.Now()
53
}

1
package application
2

3
import (
4
  "context"
5
  "domain"
6
)
7

8
type UpdateSubscriptionHandler struct {
9
  subscriptionRepo domain.SubscriptionRepository
10
  planRepo          domain.PlanRepository
11
  billingService    domain.BillingService
12
}
13

14
func (h *UpdateSubscriptionHandler) Handle(ctx context.Context, cmd UpdateSubscriptionCommand) error {
15
  // 获取当前订阅
16
  subscription, err := h.subscriptionRepo.GetByUserID(ctx, cmd.UserID)
17
  if err != nil {
18
    return err
19
  }
20
  if subscription == nil {
21
    return errors.New("no active subscription found")
22
  }
23

24
  // 获取新计划
25
  newPlan, err := h.planRepo.GetByName(ctx, cmd.NewPlan)
26
  if err != nil {
27
    return err
28
  }
29

30
  // 检查是否可以更新计划
31
  err = subscription.CanUpdateTo(newPlan)
32
  if err != nil {
33
    return err
34
  }
35

36
  // 计算价格差
37
  priceDifference := newPlan.PriceDifference(subscription.CurrentPlan)
38

39
  // 调整账单
40
  err = h.billingService.AdjustBilling(ctx, cmd.UserID, priceDifference)
41
  if err != nil {
42
    return err
43
  }
44

45
  // 更新订阅
46
  subscription.UpdateTo(newPlan)
47
  return h.subscriptionRepo.Update(ctx, subscription)
48
}