hfb_sys/backend/internal/modules/distribution/service.go

package distribution

import (
	"context"
	"errors"

	"hfb_sys/backend/internal/model"
)

var ErrDependencyUnavailable = errors.New("distribution dependency unavailable")

type Service struct{ repo *Repository }

func NewService(repo *Repository) *Service { return &Service{repo: repo} }

func (s *Service) available() error {
	if s == nil || s.repo == nil {
		return ErrDependencyUnavailable
	}
	return nil
}
func (s *Service) ListSites(ctx context.Context) ([]SiteDTO, error) {
	if err := s.available(); err != nil {
		return nil, err
	}
	return s.repo.ListSites(ctx)
}
func (s *Service) ListSitesForAdmin(ctx context.Context, adminID uint64) ([]SiteDTO, error) {
	if err := s.available(); err != nil {
		return nil, err
	}
	items, err := s.repo.ListSites(ctx)
	if err != nil {
		return nil, err
	}
	var members []model.DistributionSiteMember
	if adminID == 0 || s.repo.db == nil {
		return items, nil
	}
	if err := s.repo.db.WithContext(ctx).Where("admin_user_id = ? AND status = 'active'", adminID).Find(&members).Error; err != nil {
		return nil, err
	}
	if len(members) == 0 {
		return items, nil
	}
	allowed := make(map[uint64]struct{}, len(members))
	for _, member := range members {
		allowed[member.SiteID] = struct{}{}
	}
	filtered := make([]SiteDTO, 0, len(allowed))
	for _, item := range items {
		if _, ok := allowed[item.ID]; ok {
			filtered = append(filtered, item)
		}
	}
	return filtered, nil
}
func (s *Service) ScopeSiteID(ctx context.Context, adminID, requested uint64) (uint64, error) {
	if err := s.available(); err != nil {
		return 0, err
	}
	return s.repo.ScopeSiteID(ctx, adminID, requested)
}
func (s *Service) FindSite(ctx context.Context, adminID, id uint64) (*SiteDTO, error) {
	if err := s.available(); err != nil {
		return nil, err
	}
	return s.repo.FindSite(ctx, adminID, id)
}
func (s *Service) CreateSite(ctx context.Context, req CreateSiteRequest) (*SiteDTO, error) {
	if err := s.available(); err != nil {
		return nil, err
	}
	return s.repo.CreateSite(ctx, req)
}
func (s *Service) UpdateSite(ctx context.Context, adminID, id uint64, req UpdateSiteRequest) (*SiteDTO, error) {
	if err := s.available(); err != nil {
		return nil, err
	}
	return s.repo.UpdateSite(ctx, adminID, id, req)
}
func (s *Service) ListRules(ctx context.Context, adminID uint64, siteID *uint64, mode string) ([]RuleDTO, error) {
	if err := s.available(); err != nil {
		return nil, err
	}
	return s.repo.ListRules(ctx, adminID, siteID, mode)
}
func (s *Service) CreateRule(ctx context.Context, adminID uint64, req CreateRuleRequest) (*RuleDTO, error) {
	if err := s.available(); err != nil {
		return nil, err
	}
	return s.repo.CreateRule(ctx, adminID, req)
}
func (s *Service) UpdateRuleStatus(ctx context.Context, adminID, id uint64, status string) (*RuleDTO, error) {
	if err := s.available(); err != nil {
		return nil, err
	}
	return s.repo.UpdateRuleStatus(ctx, adminID, id, status)
}

func (s *Service) ListOrders(ctx context.Context, query DistributionOrderListQuery) (*DistributionOrderPage, error) {
	if err := s.available(); err != nil {
		return nil, err
	}
	return s.repo.ListOrders(ctx, query)
}
func (s *Service) FindOrder(ctx context.Context, adminID, id uint64) (*DistributionOrderDTO, error) {
	if err := s.available(); err != nil {
		return nil, err
	}
	return s.repo.FindOrder(ctx, adminID, id)
}
func (s *Service) ListAccountDisplays(ctx context.Context, siteID uint64, status string) ([]AccountDisplayDTO, error) {
	if err := s.available(); err != nil {
		return nil, err
	}
	return s.repo.ListAccountDisplays(ctx, siteID, status)
}
func (s *Service) UpdateAccountDisplay(ctx context.Context, adminID, id uint64, status string) (*AccountDisplayDTO, error) {
	if err := s.available(); err != nil {
		return nil, err
	}
	return s.repo.UpdateAccountDisplay(ctx, adminID, id, status)
}
func (s *Service) ListPaymentChannels(ctx context.Context, siteID uint64) ([]PaymentChannelDTO, error) {
	if err := s.available(); err != nil {
		return nil, err
	}
	return s.repo.ListPaymentChannels(ctx, siteID)
}
func (s *Service) BindPaymentChannel(ctx context.Context, siteID uint64, req BindPaymentChannelRequest) (*PaymentChannelDTO, error) {
	if err := s.available(); err != nil {
		return nil, err
	}
	return s.repo.BindPaymentChannel(ctx, siteID, req)
}
func (s *Service) UnbindPaymentChannel(ctx context.Context, adminID, id uint64) error {
	if err := s.available(); err != nil {
		return err
	}
	return s.repo.UnbindPaymentChannel(ctx, adminID, id)
}
func (s *Service) ListSettlementBatches(ctx context.Context, siteID uint64) ([]SettlementBatchDTO, error) {
	if err := s.available(); err != nil {
		return nil, err
	}
	return s.repo.ListSettlementBatches(ctx, siteID)
}
func (s *Service) CreateSettlementBatch(ctx context.Context, adminID uint64, req CreateSettlementBatchRequest) (*SettlementBatchDTO, error) {
	if err := s.available(); err != nil {
		return nil, err
	}
	return s.repo.CreateSettlementBatch(ctx, adminID, req)
}
func (s *Service) MarkSettlementBatch(ctx context.Context, adminID, id uint64) (*SettlementBatchDTO, error) {
	if err := s.available(); err != nil {
		return nil, err
	}
	return s.repo.MarkSettlementBatch(ctx, adminID, id)
}

func (s *Service) CreateFinancialSnapshot(ctx context.Context, adminID, orderID uint64, req CreateFinancialSnapshotRequest) (*DistributionOrderDTO, error) {
	if err := s.available(); err != nil {
		return nil, err
	}
	return s.repo.CreateFinancialSnapshot(ctx, adminID, orderID, req)
}