Go で権限を型安全・拡張しやすく管理する —— 型・Proto・Composite で組み立てる権限ロジック

利用可能 ⇔
  利用国に含まれる
  AND 公開状態が「公開開始」
  AND ( 会員条件を満たす OR 購入権利を保持 )

// コンテンツの提供方法（利用に必要な条件の種類）
enum Requirement {
  REQUIREMENT_UNSPECIFIED = 0;
  REQUIREMENT_FREE_TIER = 1;           // 無料会員
  REQUIREMENT_SUBSCRIPTION_TIER_BASIC = 2;   // 基本会員
  REQUIREMENT_SUBSCRIPTION_TIER_PREMIUM = 3; // プレミアム会員
  REQUIREMENT_PURCHASE = 4;            // 購入
}

// コンテンツの公開ステータス
message PublicStatus {
  Status status = 1;
  ...

  enum Status {
    STATUS_UNSPECIFIED = 0;
    STATUS_PUBLISHED = 1;    // 公開開始
    STATUS_ARCHIVED = 2;     // 公開終了
    STATUS_CONFIDENTIAL = 3; // 非公開
  }
}

// Level は会員ステータスに応じた利用権限レベルを表します
type Level string

const (
	LevelEveryone      Level = "everyone"       // 誰でも利用可能
	LevelFreeMember    Level = "free-member"    // 無料会員なら利用可能
	LevelBasicMember   Level = "basic-member"   // 基本会員以上なら利用可能
	LevelPremiumMember Level = "premium-member" // プレミアム会員なら利用可能
	LevelNoPermission  Level = "no-permission"  // 会員による利用権限なし
)

var levelValues = map[string]Level{
	string(LevelEveryone):      LevelEveryone,
	string(LevelFreeMember):    LevelFreeMember,
	string(LevelBasicMember):   LevelBasicMember,
	string(LevelPremiumMember): LevelPremiumMember,
	string(LevelNoPermission):  LevelNoPermission,
}

func NewMembershipLevel(level string) (Level, error) {
	membershipLevel, ok := levelValues[level]
	if !ok {
		return "", fmt.Errorf("invalid membership level: %s", level)
	}
	return membershipLevel, nil
}

// Requirements は、そのレベルが「満たすべき会員」のリストを返す（例: 基本会員 → [基本, プレミアム]）
func (l Level) Requirements() []Level {
	// ...
}

var requirementsMap = map[membership.Level]api.Requirement{
	membership.LevelFreeMember:    api.Requirement_REQUIREMENT_FREE_TIER,
	membership.LevelBasicMember:   api.Requirement_REQUIREMENT_SUBSCRIPTION_TIER_BASIC,
	membership.LevelPremiumMember: api.Requirement_REQUIREMENT_SUBSCRIPTION_TIER_PREMIUM,
}

// コンテンツが購入対象なら PURCHASE を追加し、Level.Requirements() に対応する enum を並べる
func toRequirements(level membership.Level, purchaseInfo *PurchaseInfo) []api.Requirement {
	var requirements []api.Requirement
	if purchaseInfo != nil {
		requirements = append(requirements, api.Requirement_REQUIREMENT_PURCHASE)
	}
	for _, requirement := range level.Requirements() {
		if requirement == membership.LevelNoPermission || requirement == membership.LevelEveryone {
			continue
		}
		requirements = append(requirements, requirementsMap[requirement])
	}
	return requirements
}

type Content struct {
	// ...
	MembershipLevel membership.Level  // このコンテンツに必要な会員レベル
	// 対象国・公開スケジュールなどは省略
}

// 利用国: ユーザーの国がコンテンツ（または親コンテンツ）の公開対象に含まれるか
func (c *Content) IsDistributedInCountry(userCountry string, parent *ParentMaster) bool { ... }

// 公開状態: 現在時刻で「公開開始」かどうか
func (c *Content) IsPublished() bool { ... }

// UseCondition はコンテンツを利用できる条件を抽象化したインターフェースです。
// 単一条件も AND/OR で組み合わせた条件も、同じ UseCondition として扱えるようにしています（Composite）。
type UseCondition interface {
	CanUse(ctx context.Context, user *user.User, profile *user.Profile) (bool, error)
}

// 全ての条件を満たしていることを検証する UseCondition
type andCondition struct {
	conditions []UseCondition
}

func (c *andCondition) CanUse(ctx context.Context, user *user.User, profile *user.Profile) (bool, error) {
	for _, condition := range c.conditions {
		canUse, err := condition.CanUse(ctx, user, profile)
		if err != nil {
			return false, fmt.Errorf("one of and conditions not satisfied: %w", err)
		}
		if !canUse {
			return false, nil
		}
	}
	return true, nil
}

// いずれか 1 つの条件を満たすことを検証する UseCondition
type orCondition struct {
	conditions []UseCondition
}

func (c *orCondition) CanUse(ctx context.Context, user *user.User, profile *user.Profile) (bool, error) {
	for _, condition := range c.conditions {
		canUse, err := condition.CanUse(ctx, user, profile)
		if err != nil {
			continue // 他の条件が true を返す可能性があるので続行
		}
		if canUse {
			return true, nil
		}
	}
	return false, errors.Join(/* 集めたエラー */)
}

func (f *Factory) Create(
	content *Content,
	purchaseInfo *PurchaseInfo,
) (UseCondition, error) {
	// 利用権利の種別: 会員 OR 購入
	rightsCondition := newOrCondition(
		newMembershipUseCondition(content.MembershipLevel, f.membershipClient),
	)
	if purchaseInfo != nil {
		perpetualCondition := newPerpetualUseCondition(content.ID, f.perpetualUseRepo)
		rightsCondition = rightsCondition.Or(perpetualCondition)
	}

	// 全体: 利用国 AND 公開状態 AND (会員 OR 購入)
	countryCondition := newCountryUseCondition(content)
	publishedTimeCondition := newPublishedTimeUseCondition(content)
	return newAndCondition(
		countryCondition,
		publishedTimeCondition,
		rightsCondition,
	), nil
}

AND
├── 利用国に含まれる
├── 公開状態が「公開開始」
└── OR
    ├── 会員条件を満たす
    └── 購入権利を保持（購入対象コンテンツの場合のみ）

useCondition, err := p.useConditionFactory.Create(content, content, purchaseInfoByContent[contentID])
if err != nil {
	return false, err
}
canUse, err := useCondition.CanUse(ctx, user, profile)

// イベント参加者かどうかを判定する UseCondition（新規追加）
type eventParticipantUseCondition struct {
	eventID string
	repo   EventParticipationRepository
}

func (c *eventParticipantUseCondition) CanUse(ctx context.Context, user *user.User, _ *user.Profile) (bool, error) {
	return c.repo.HasParticipation(ctx, user.ID, c.eventID)
}

// Create 内の一部（追加・変更箇所のみ）
rightsCondition := newOrCondition(
	newMembershipUseCondition(content.MembershipLevel, b.membershipClient),
)
if purchaseInfo != nil {
	rightsCondition = rightsCondition.Or(newPerpetualUseCondition(content.ID, b.perpetualPlayRightRepo))
}
if eventID != "" {
	rightsCondition = rightsCondition.Or(newEventParticipantUseCondition(eventID, b.eventRepo)) // 追加
}
// 以下、countryCondition, publishedTimeCondition との AND は変更なし