junhong_cmp_fiber/internal/bootstrap/carrier_check.go

package bootstrap

import (
	"context"
	"strconv"
	"strings"

	cardObservationApp "github.com/break/junhong_cmp_fiber/internal/application/cardobservation"
	"github.com/break/junhong_cmp_fiber/internal/polling"
	"github.com/break/junhong_cmp_fiber/pkg/constants"
)

// carrierAwareSeriesDispatcher 是读入口观测分发的模式接缝：按运营商账户调度时把读入口改为按场景请求检查
// （同卡合并、冷却、受账户限流），不再起"立即、3 分钟、5 分钟"观测序列；旧分片调度时沿用原分发器。
type carrierAwareSeriesDispatcher struct {
	legacy    cardObservationApp.BestEffortSeriesDispatcher
	requester *polling.CheckRequester
}

var _ cardObservationApp.BestEffortSeriesDispatcher = (*carrierAwareSeriesDispatcher)(nil)

// ReadEntryCheckScene 把读入口与设备控制的观测场景映射为请求检查场景；不认识的场景返回空串。
func ReadEntryCheckScene(observationScene string) string {
	switch observationScene {
	case constants.CardObservationSceneClientAssetRead:
		return constants.PollingCheckSceneClientAssetDetail
	case constants.CardObservationSceneAdminAssetRead:
		return constants.PollingCheckSceneAdminAssetRealtime
	case constants.CardObservationSceneClientRealnameLink, constants.CardObservationSceneAdminRealnameLink:
		return constants.PollingCheckSceneRealnameLink
	case constants.CardObservationSceneBusinessStop, constants.CardObservationSceneBusinessResume:
		return constants.PollingCheckSceneStopResumeSucceeded
	case constants.CardObservationScenePackageChanged:
		return constants.PollingCheckScenePackageActivated
	case constants.CardObservationSceneDeviceSwitchCard, constants.CardObservationSceneDeviceSwitchMode,
		constants.CardObservationSceneDeviceReboot, constants.CardObservationSceneDeviceReset, constants.CardObservationSceneDeviceSetWiFi:
		return constants.PollingCheckSceneDeviceOperation
	default:
		return ""
	}
}

func (d *carrierAwareSeriesDispatcher) active(ctx context.Context) bool {
	return d.requester != nil && d.requester.Active(ctx)
}

// Dispatch 读入口单卡（或设备）观测。
func (d *carrierAwareSeriesDispatcher) Dispatch(ctx context.Context, request cardObservationApp.SeriesRequest) {
	if !d.active(ctx) {
		d.legacy.Dispatch(ctx, request)
		return
	}
	scene := ReadEntryCheckScene(request.Scene)
	if scene == "" {
		return
	}
	id, err := strconv.ParseUint(request.ResourceID, 10, 64)
	if err != nil || id == 0 {
		return
	}
	if request.ResourceType == constants.CardObservationResourceTypeDevice {
		d.requester.RequestDevice(ctx, scene, uint(id))
		return
	}
	d.requester.RequestCards(ctx, scene, []uint{uint(id)}, request.ExpectedValue)
}

// DispatchDeviceCards 设备有效绑定卡观测。
func (d *carrierAwareSeriesDispatcher) DispatchDeviceCards(ctx context.Context, request cardObservationApp.DeviceCardsSeriesRequest) {
	if !d.active(ctx) {
		d.legacy.DispatchDeviceCards(ctx, request)
		return
	}
	if scene := ReadEntryCheckScene(request.Request.Scene); scene != "" {
		d.requester.RequestDevice(ctx, scene, request.DeviceID)
	}
}

// DispatchDeviceControl 设备控制成功后的观测：按设备操作场景为设备下各卡请求检查。
func (d *carrierAwareSeriesDispatcher) DispatchDeviceControl(ctx context.Context, request cardObservationApp.DeviceControlSeriesRequest) {
	if !d.active(ctx) {
		d.legacy.DispatchDeviceControl(ctx, request)
		return
	}
	// 设备信息同步（query_device_info，非运营商上游）保持原观测，只把卡检查改为请求检查。
	deviceInfo := request.Request
	deviceInfo.ResourceType = constants.CardObservationResourceTypeDevice
	deviceInfo.ResourceID = strconv.FormatUint(uint64(request.DeviceID), 10)
	deviceInfo.SyncType = constants.CardObservationSyncTypeDeviceInfo
	deviceInfo.ExpectedValue = strings.TrimSpace(request.TargetICCID)
	d.legacy.Dispatch(ctx, deviceInfo)
	cardIDs := append([]uint(nil), request.BoundCardIDs...)
	for _, id := range []uint{request.SourceCardID, request.TargetCardID} {
		if id != 0 && !containsUint(cardIDs, id) {
			cardIDs = append(cardIDs, id)
		}
	}
	if len(cardIDs) == 0 && request.DeviceID != 0 {
		d.requester.RequestDevice(ctx, constants.PollingCheckSceneDeviceOperation, request.DeviceID)
		return
	}
	d.requester.RequestCards(ctx, constants.PollingCheckSceneDeviceOperation, cardIDs, "")
}

// DispatchRealnameWithCapability 获取实名链接后的实名观测。
func (d *carrierAwareSeriesDispatcher) DispatchRealnameWithCapability(ctx context.Context, request cardObservationApp.RealnameCapabilitySeriesRequest) {
	if !d.active(ctx) {
		d.legacy.DispatchRealnameWithCapability(ctx, request)
		return
	}
	d.Dispatch(ctx, request.Request)
}

func containsUint(values []uint, target uint) bool {
	for _, value := range values {
		if value == target {
			return true
		}
	}
	return false
}