break
5c4d17e9fc
Some checks failed
构建并部署到测试环境（无 SSH） / build-and-deploy (push) Has been cancelled
完成运营商实名回调、业务事件观测序列与受控配置装配，同时恢复 UR43 已交付的 packages[].remove 字段及旧响应兼容，统一更新 OpenSpec、OpenAPI 和交付文档。 Constraint: 七月测试环境里程碑不新增或运行自动化测试 Rejected: 以必填 operation_type 替换 packages[].remove | 会破坏已交付前端契约 Confidence: high Scope-risk: broad Directive: 后续修改系列套餐管理接口必须保持 packages[].remove 和 ShopSeriesGrantResponse 兼容 Tested: go run ./cmd/gendocs；go build -buildvcs=false ./...；openspec validate complete-july-iteration-test-release --strict；git diff --check Not-tested: 按本 Change 约定未运行 go test，真实运营商与 Gateway 联调延期
466 lines
19 KiB
Go
466 lines
19 KiB
Go
package cardobservation
|
|
|
|
import (
|
|
"context"
|
|
stderrors "errors"
|
|
"strconv"
|
|
"strings"
|
|
"time"
|
|
|
|
"gorm.io/gorm"
|
|
|
|
cardapp "github.com/break/junhong_cmp_fiber/internal/application/cardobservation"
|
|
carddomain "github.com/break/junhong_cmp_fiber/internal/domain/cardobservation"
|
|
"github.com/break/junhong_cmp_fiber/internal/gateway"
|
|
"github.com/break/junhong_cmp_fiber/internal/infrastructure/integrationlog"
|
|
"github.com/break/junhong_cmp_fiber/internal/model"
|
|
"github.com/break/junhong_cmp_fiber/internal/store/postgres"
|
|
"github.com/break/junhong_cmp_fiber/pkg/constants"
|
|
apperrors "github.com/break/junhong_cmp_fiber/pkg/errors"
|
|
)
|
|
|
|
// SeriesAttemptLogger 将未发送的序列结果写入统一 Integration Log。
|
|
type SeriesAttemptLogger struct {
|
|
repository *integrationlog.Repository
|
|
}
|
|
|
|
// NewSeriesAttemptLogger 创建未发送尝试日志适配器。
|
|
func NewSeriesAttemptLogger(repository *integrationlog.Repository) *SeriesAttemptLogger {
|
|
return &SeriesAttemptLogger{repository: repository}
|
|
}
|
|
|
|
// Record 写入互斥、限频或提前完成结果。
|
|
func (l *SeriesAttemptLogger) Record(ctx context.Context, payload cardapp.SeriesTaskPayload, result, reason string) error {
|
|
if l == nil || l.repository == nil {
|
|
return apperrors.New(apperrors.CodeInternalError, "卡观测 Integration Log 未配置")
|
|
}
|
|
resourceID := payload.ResourceID
|
|
source, scene, seriesID := payload.Source, payload.Scene, payload.SeriesID
|
|
requestID, correlationID := optionalText(payload.RequestID), optionalText(payload.CorrelationID)
|
|
attempt, err := l.repository.Start(ctx, integrationlog.Attempt{
|
|
IntegrationID: unsentIntegrationID(payload), Provider: constants.IntegrationProviderGateway,
|
|
Direction: constants.IntegrationDirectionOutbound, Operation: operationForSyncType(payload.SyncType),
|
|
ResourceType: payload.ResourceType, ResourceID: &resourceID, TriggerSource: &source,
|
|
TriggerScene: &scene, TriggerSeries: &seriesID, ScheduledAt: &payload.ScheduledAt,
|
|
Attempt: payload.Attempt, InitialResult: initialResult(result), RequestID: requestID, CorrelationID: correlationID,
|
|
Metadata: map[string]any{"reason": reason, "sync_type": payload.SyncType},
|
|
})
|
|
if err != nil || result != constants.IntegrationResultFailed {
|
|
return err
|
|
}
|
|
_, err = l.repository.Complete(ctx, attempt.IntegrationID, integrationlog.Completion{
|
|
Result: constants.IntegrationResultFailed, ResponseSummary: map[string]any{"reason": reason},
|
|
})
|
|
return err
|
|
}
|
|
|
|
// RecordMerged 记录同场景重复触发被合并，不创建第二组三任务。
|
|
func (l *SeriesAttemptLogger) RecordMerged(ctx context.Context, request cardapp.SeriesRequest, seriesID string) error {
|
|
resourceID := request.ResourceID
|
|
source, scene := request.Source, request.Scene
|
|
now := time.Now().UTC()
|
|
_, err := l.repository.Start(ctx, integrationlog.Attempt{
|
|
Provider: constants.IntegrationProviderGateway, Direction: constants.IntegrationDirectionOutbound,
|
|
Operation: operationForSyncType(request.SyncType), ResourceType: request.ResourceType,
|
|
ResourceID: &resourceID, TriggerSource: &source, TriggerScene: &scene, TriggerSeries: &seriesID,
|
|
ScheduledAt: &now, Attempt: 1, InitialResult: constants.IntegrationResultMerged,
|
|
RequestID: optionalText(request.RequestID), CorrelationID: optionalText(request.CorrelationID),
|
|
Metadata: map[string]any{"reason": "同场景未结束序列已存在", "sync_type": request.SyncType},
|
|
})
|
|
return err
|
|
}
|
|
|
|
// SeriesRunner 负责卡本地预期判断、Gateway 查询和公共观测应用。
|
|
type SeriesRunner struct {
|
|
db *gorm.DB
|
|
gateway *gateway.Client
|
|
observation *cardapp.Service
|
|
integration *integrationlog.Repository
|
|
carrier *postgres.CarrierStore
|
|
}
|
|
|
|
// NewSeriesRunner 创建卡观测序列 Gateway 执行器。
|
|
func NewSeriesRunner(db *gorm.DB, gatewayClient *gateway.Client, observation *cardapp.Service, integration *integrationlog.Repository) *SeriesRunner {
|
|
return &SeriesRunner{db: db, gateway: gatewayClient, observation: observation, integration: integration, carrier: postgres.NewCarrierStore(db)}
|
|
}
|
|
|
|
// Provider 返回用于请求互斥的运营商接入标识。
|
|
func (r *SeriesRunner) Provider(ctx context.Context, payload cardapp.SeriesTaskPayload) (string, error) {
|
|
if payload.ResourceType == constants.CardObservationResourceTypeDevice {
|
|
if _, err := r.loadDevice(ctx, payload); err != nil {
|
|
return "", err
|
|
}
|
|
return constants.CardObservationResourceTypeDevice, nil
|
|
}
|
|
card, err := r.loadCard(ctx, payload)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
provider := strings.ToLower(strings.TrimSpace(card.CarrierType))
|
|
if provider == "" {
|
|
provider = "carrier-" + strconv.FormatUint(uint64(card.CarrierID), 10)
|
|
}
|
|
return provider, nil
|
|
}
|
|
|
|
// ExpectationMet 在访问 Gateway 前读取本地权威快照。
|
|
func (r *SeriesRunner) ExpectationMet(ctx context.Context, payload cardapp.SeriesTaskPayload) (bool, error) {
|
|
expected := strings.ToLower(strings.TrimSpace(payload.ExpectedValue))
|
|
if expected == "" {
|
|
return false, nil
|
|
}
|
|
if payload.ResourceType == constants.CardObservationResourceTypeDevice && payload.SyncType == constants.CardObservationSyncTypeDeviceInfo {
|
|
currentICCIDs, err := r.loadCurrentICCIDs(ctx, payload)
|
|
if err != nil {
|
|
return false, err
|
|
}
|
|
for _, currentICCID := range currentICCIDs {
|
|
if strings.EqualFold(expected, strings.TrimSpace(currentICCID)) {
|
|
return true, nil
|
|
}
|
|
}
|
|
return false, nil
|
|
}
|
|
card, err := r.loadCard(ctx, payload)
|
|
if err != nil {
|
|
return false, err
|
|
}
|
|
switch payload.SyncType {
|
|
case constants.CardObservationSyncTypeRealname:
|
|
return (expected == "verified" || expected == "1") && card.RealNameStatus == constants.RealNameStatusVerified, nil
|
|
case constants.CardObservationSyncTypeNetwork:
|
|
if expected == "online" || expected == "1" {
|
|
return card.NetworkStatus == constants.NetworkStatusOnline, nil
|
|
}
|
|
if expected == "offline" || expected == "stopped" || expected == "0" {
|
|
return card.NetworkStatus == constants.NetworkStatusOffline, nil
|
|
}
|
|
}
|
|
return false, nil
|
|
}
|
|
|
|
// Run 执行一次 Gateway 查询，并将结果交给公共卡观测应用服务。
|
|
func (r *SeriesRunner) Run(ctx context.Context, payload cardapp.SeriesTaskPayload) (cardapp.RunResult, error) {
|
|
if r == nil || r.db == nil || r.gateway == nil || r.observation == nil || r.integration == nil {
|
|
return cardapp.RunResult{}, apperrors.New(apperrors.CodeInternalError, "卡观测序列 Gateway 能力未完整配置")
|
|
}
|
|
if payload.ResourceType == constants.CardObservationResourceTypeDevice && payload.SyncType == constants.CardObservationSyncTypeDeviceInfo {
|
|
return r.runDeviceInfo(ctx, payload)
|
|
}
|
|
card, err := r.loadCard(ctx, payload)
|
|
if err != nil {
|
|
return cardapp.RunResult{}, err
|
|
}
|
|
attempt, err := r.startAttempt(ctx, payload, card)
|
|
if err != nil {
|
|
return cardapp.RunResult{}, err
|
|
}
|
|
startedAt := time.Now()
|
|
result, runErr := r.queryAndApply(ctx, payload, card, attempt.IntegrationID)
|
|
completionResult := constants.IntegrationResultSuccess
|
|
if runErr != nil {
|
|
completionResult = constants.IntegrationResultFailed
|
|
if isRateLimited(runErr) {
|
|
completionResult = constants.IntegrationResultRateLimited
|
|
result.RateLimited = true
|
|
}
|
|
}
|
|
_, completeErr := r.integration.Complete(ctx, attempt.IntegrationID, integrationlog.Completion{
|
|
Result: completionResult, DurationMS: time.Since(startedAt).Milliseconds(), StateChanged: result.StateChanged,
|
|
ResponseSummary: map[string]any{"sync_type": payload.SyncType, "applied": runErr == nil},
|
|
})
|
|
if completeErr != nil {
|
|
return result, completeErr
|
|
}
|
|
return result, runErr
|
|
}
|
|
|
|
func (r *SeriesRunner) runDeviceInfo(ctx context.Context, payload cardapp.SeriesTaskPayload) (cardapp.RunResult, error) {
|
|
device, err := r.loadDevice(ctx, payload)
|
|
if err != nil {
|
|
return cardapp.RunResult{}, err
|
|
}
|
|
attempt, err := r.startDeviceAttempt(ctx, payload, device)
|
|
if err != nil {
|
|
return cardapp.RunResult{}, err
|
|
}
|
|
startedAt := time.Now()
|
|
response, runErr := r.gateway.SyncDeviceInfo(ctx, &gateway.SyncDeviceInfoReq{CardNo: deviceGatewayIdentifier(device)})
|
|
result := cardapp.RunResult{}
|
|
if runErr == nil {
|
|
result.StateChanged, runErr = r.applyDeviceInfo(ctx, device, response)
|
|
}
|
|
completionResult := constants.IntegrationResultSuccess
|
|
if runErr != nil {
|
|
completionResult = constants.IntegrationResultFailed
|
|
if isRateLimited(runErr) {
|
|
completionResult = constants.IntegrationResultRateLimited
|
|
result.RateLimited = true
|
|
}
|
|
}
|
|
_, completeErr := r.integration.Complete(ctx, attempt.IntegrationID, integrationlog.Completion{
|
|
Result: completionResult, DurationMS: time.Since(startedAt).Milliseconds(), StateChanged: result.StateChanged,
|
|
ResponseSummary: map[string]any{"sync_type": payload.SyncType, "applied": runErr == nil},
|
|
})
|
|
if completeErr != nil {
|
|
return result, completeErr
|
|
}
|
|
return result, runErr
|
|
}
|
|
|
|
func (r *SeriesRunner) startDeviceAttempt(ctx context.Context, payload cardapp.SeriesTaskPayload, device *model.Device) (*model.IntegrationLog, error) {
|
|
resourceID, source, scene, seriesID := payload.ResourceID, payload.Source, payload.Scene, payload.SeriesID
|
|
resourceKey := "device:" + strconv.FormatUint(uint64(device.ID), 10)
|
|
return r.integration.Start(ctx, integrationlog.Attempt{
|
|
IntegrationID: gatewayIntegrationID(payload), Provider: constants.IntegrationProviderGateway,
|
|
Direction: constants.IntegrationDirectionOutbound, Operation: operationForSyncType(payload.SyncType),
|
|
ResourceType: payload.ResourceType, ResourceID: &resourceID, ResourceKey: &resourceKey,
|
|
TriggerSource: &source, TriggerScene: &scene, TriggerSeries: &seriesID,
|
|
ScheduledAt: &payload.ScheduledAt, Attempt: payload.Attempt,
|
|
RequestSummary: map[string]any{"device_id": device.ID, "sync_type": payload.SyncType},
|
|
RequestID: optionalText(payload.RequestID), CorrelationID: optionalText(payload.CorrelationID),
|
|
})
|
|
}
|
|
|
|
func (r *SeriesRunner) applyDeviceInfo(ctx context.Context, device *model.Device, response *gateway.SyncDeviceInfoResp) (bool, error) {
|
|
if response == nil {
|
|
return false, apperrors.New(apperrors.CodeGatewayError, "Gateway 设备信息响应为空")
|
|
}
|
|
now := time.Now()
|
|
updates := map[string]any{
|
|
"online_status": int(response.OnlineStatus),
|
|
"software_version": string(response.SoftwareVersion),
|
|
"switch_mode": string(response.SwitchMode),
|
|
"last_gateway_sync_at": now,
|
|
}
|
|
if lastOnlineTime := parseGatewayTime(response.LastOnlineTime); lastOnlineTime != nil {
|
|
updates["last_online_time"] = lastOnlineTime
|
|
}
|
|
var currentBinding struct {
|
|
SlotPosition int
|
|
}
|
|
currentSlotErr := r.db.WithContext(ctx).Model(&model.DeviceSimBinding{}).
|
|
Select("slot_position").
|
|
Where("device_id = ? AND bind_status = ? AND is_current = ?", device.ID, constants.BindStatusBound, true).
|
|
Take(¤tBinding).Error
|
|
if currentSlotErr != nil && currentSlotErr != gorm.ErrRecordNotFound {
|
|
return false, apperrors.Wrap(apperrors.CodeDatabaseError, currentSlotErr, "读取设备当前槽位失败")
|
|
}
|
|
changed := device.OnlineStatus != int(response.OnlineStatus) ||
|
|
device.SoftwareVersion != string(response.SoftwareVersion) ||
|
|
device.SwitchMode != string(response.SwitchMode) ||
|
|
currentBinding.SlotPosition != int(response.CurrentSlotNo)
|
|
err := r.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
|
|
if err := tx.Model(&model.Device{}).Where("id = ?", device.ID).Updates(updates).Error; err != nil {
|
|
return err
|
|
}
|
|
if err := tx.Model(&model.DeviceSimBinding{}).
|
|
Where("device_id = ? AND bind_status = ?", device.ID, constants.BindStatusBound).
|
|
Update("is_current", false).Error; err != nil {
|
|
return err
|
|
}
|
|
if int(response.CurrentSlotNo) <= 0 {
|
|
return nil
|
|
}
|
|
return tx.Model(&model.DeviceSimBinding{}).
|
|
Where("device_id = ? AND slot_position = ? AND bind_status = ?", device.ID, int(response.CurrentSlotNo), constants.BindStatusBound).
|
|
Update("is_current", true).Error
|
|
})
|
|
if err != nil {
|
|
return false, apperrors.Wrap(apperrors.CodeDatabaseError, err, "回写设备 Gateway 信息失败")
|
|
}
|
|
return changed, nil
|
|
}
|
|
|
|
func (r *SeriesRunner) loadDevice(ctx context.Context, payload cardapp.SeriesTaskPayload) (*model.Device, error) {
|
|
if payload.ResourceType != constants.CardObservationResourceTypeDevice {
|
|
return nil, apperrors.New(apperrors.CodeInvalidParam, "设备信息观测资源类型无效")
|
|
}
|
|
deviceID, err := strconv.ParseUint(payload.ResourceID, 10, 64)
|
|
if err != nil || deviceID == 0 {
|
|
return nil, apperrors.New(apperrors.CodeInvalidParam, "设备观测资源 ID 无效")
|
|
}
|
|
var device model.Device
|
|
if err := r.db.WithContext(ctx).Where("id = ?", uint(deviceID)).First(&device).Error; err != nil {
|
|
if err == gorm.ErrRecordNotFound {
|
|
return nil, apperrors.New(apperrors.CodeNotFound, "设备不存在")
|
|
}
|
|
return nil, apperrors.Wrap(apperrors.CodeDatabaseError, err, "查询设备观测本地快照失败")
|
|
}
|
|
if deviceGatewayIdentifier(&device) == "" {
|
|
return nil, apperrors.New(apperrors.CodeInvalidParam, "设备缺少 Gateway 标识")
|
|
}
|
|
return &device, nil
|
|
}
|
|
|
|
func (r *SeriesRunner) loadCurrentICCIDs(ctx context.Context, payload cardapp.SeriesTaskPayload) ([]string, error) {
|
|
device, err := r.loadDevice(ctx, payload)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
var current struct {
|
|
ICCID string
|
|
ICCID19 string
|
|
ICCID20 *string
|
|
}
|
|
err = r.db.WithContext(ctx).Table("tb_device_sim_binding AS binding").
|
|
Select("card.iccid, card.iccid_19, card.iccid_20").
|
|
Joins("JOIN tb_iot_card AS card ON card.id = binding.iot_card_id AND card.deleted_at IS NULL").
|
|
Where("binding.device_id = ? AND binding.bind_status = ? AND binding.is_current = ? AND binding.deleted_at IS NULL", device.ID, constants.BindStatusBound, true).
|
|
Take(¤t).Error
|
|
if err == gorm.ErrRecordNotFound {
|
|
return nil, nil
|
|
}
|
|
if err != nil {
|
|
return nil, apperrors.Wrap(apperrors.CodeDatabaseError, err, "查询设备当前卡失败")
|
|
}
|
|
iccids := []string{current.ICCID, current.ICCID19}
|
|
if current.ICCID20 != nil {
|
|
iccids = append(iccids, *current.ICCID20)
|
|
}
|
|
return iccids, nil
|
|
}
|
|
|
|
func deviceGatewayIdentifier(device *model.Device) string {
|
|
if strings.TrimSpace(device.IMEI) != "" {
|
|
return strings.TrimSpace(device.IMEI)
|
|
}
|
|
return strings.TrimSpace(device.SN)
|
|
}
|
|
|
|
func parseGatewayTime(raw gateway.FlexString) *time.Time {
|
|
value := strings.TrimSpace(string(raw))
|
|
if value == "" {
|
|
return nil
|
|
}
|
|
if parsed, err := time.Parse(time.RFC3339, value); err == nil {
|
|
return &parsed
|
|
}
|
|
timestamp, err := strconv.ParseInt(value, 10, 64)
|
|
if err != nil {
|
|
return nil
|
|
}
|
|
if timestamp > 1_000_000_000_000 {
|
|
timestamp /= 1000
|
|
}
|
|
parsed := time.Unix(timestamp, 0)
|
|
return &parsed
|
|
}
|
|
|
|
func (r *SeriesRunner) startAttempt(ctx context.Context, payload cardapp.SeriesTaskPayload, card *model.IotCard) (*model.IntegrationLog, error) {
|
|
resourceID, source, scene, seriesID := payload.ResourceID, payload.Source, payload.Scene, payload.SeriesID
|
|
resourceKey := "card:" + formatCardID(card.ID)
|
|
return r.integration.Start(ctx, integrationlog.Attempt{
|
|
IntegrationID: gatewayIntegrationID(payload), Provider: constants.IntegrationProviderGateway,
|
|
Direction: constants.IntegrationDirectionOutbound, Operation: operationForSyncType(payload.SyncType),
|
|
ResourceType: payload.ResourceType, ResourceID: &resourceID, ResourceKey: &resourceKey,
|
|
TriggerSource: &source, TriggerScene: &scene, TriggerSeries: &seriesID,
|
|
ScheduledAt: &payload.ScheduledAt, Attempt: payload.Attempt,
|
|
RequestSummary: map[string]any{"card_id": card.ID, "sync_type": payload.SyncType},
|
|
RequestID: optionalText(payload.RequestID), CorrelationID: optionalText(payload.CorrelationID),
|
|
})
|
|
}
|
|
|
|
func (r *SeriesRunner) queryAndApply(ctx context.Context, payload cardapp.SeriesTaskPayload, card *model.IotCard, observationID string) (cardapp.RunResult, error) {
|
|
metadata := carddomain.ObservationMetadata{
|
|
ObservationID: observationID, Source: constants.CardObservationSourceBusinessEvent,
|
|
Scene: payload.Scene, ObservedAt: time.Now().UTC(), RequestID: payload.RequestID,
|
|
CorrelationID: payload.CorrelationID,
|
|
}
|
|
switch payload.SyncType {
|
|
case constants.CardObservationSyncTypeRealname:
|
|
response, err := r.gateway.QueryRealnameStatus(ctx, &gateway.CardStatusReq{CardNo: card.ICCID})
|
|
if err != nil {
|
|
return cardapp.RunResult{}, err
|
|
}
|
|
decision, err := r.observation.ApplyCardObservation(ctx, carddomain.RealnameObservation{CardID: card.ID, Verified: response.RealStatus, Metadata: metadata})
|
|
return cardapp.RunResult{StateChanged: decision.StatusChanged}, err
|
|
case constants.CardObservationSyncTypeTraffic:
|
|
response, err := r.gateway.QueryFlow(ctx, &gateway.FlowQueryReq{CardNo: card.ICCID})
|
|
if err != nil {
|
|
return cardapp.RunResult{}, err
|
|
}
|
|
decision, err := r.observation.ApplyTrafficObservation(ctx, carddomain.TrafficObservation{
|
|
CardID: card.ID, GatewayReadingMB: float64(response.Used), ResetDay: r.carrier.GetDataResetDay(ctx, card.CarrierID), Metadata: metadata,
|
|
})
|
|
return cardapp.RunResult{StateChanged: decision.IncrementMB > 0 || decision.CrossMonth}, err
|
|
case constants.CardObservationSyncTypeNetwork:
|
|
response, err := r.gateway.QueryCardStatus(ctx, &gateway.CardStatusReq{CardNo: card.ICCID})
|
|
if err != nil {
|
|
return cardapp.RunResult{}, err
|
|
}
|
|
decision, err := r.observation.ApplyNetworkObservation(ctx, carddomain.NetworkObservation{
|
|
CardID: card.ID, GatewayStatus: response.CardStatus, GatewayExtend: response.Extend,
|
|
GatewayIMEI: response.IMEI, Metadata: metadata,
|
|
})
|
|
return cardapp.RunResult{StateChanged: decision.StatusChanged}, err
|
|
default:
|
|
return cardapp.RunResult{}, apperrors.New(apperrors.CodeInvalidParam, "设备信息观测执行器尚未注册")
|
|
}
|
|
}
|
|
|
|
func (r *SeriesRunner) loadCard(ctx context.Context, payload cardapp.SeriesTaskPayload) (*model.IotCard, error) {
|
|
if payload.ResourceType != constants.CardObservationResourceTypeCard {
|
|
return nil, apperrors.New(apperrors.CodeInvalidParam, "当前观测执行器仅支持 IoT 卡资源")
|
|
}
|
|
cardID, err := strconv.ParseUint(payload.ResourceID, 10, 64)
|
|
if err != nil || cardID == 0 {
|
|
return nil, apperrors.New(apperrors.CodeInvalidParam, "卡观测资源 ID 无效")
|
|
}
|
|
var card model.IotCard
|
|
if err := r.db.WithContext(ctx).Where("id = ?", uint(cardID)).First(&card).Error; err != nil {
|
|
if err == gorm.ErrRecordNotFound {
|
|
return nil, apperrors.New(apperrors.CodeNotFound, "IoT卡不存在")
|
|
}
|
|
return nil, apperrors.Wrap(apperrors.CodeDatabaseError, err, "查询卡观测本地快照失败")
|
|
}
|
|
return &card, nil
|
|
}
|
|
|
|
func isRateLimited(err error) bool {
|
|
var appErr *apperrors.AppError
|
|
if stderrors.As(err, &appErr) && appErr.Code == apperrors.CodeTooManyRequests {
|
|
return true
|
|
}
|
|
return strings.Contains(err.Error(), "429") || strings.Contains(strings.ToLower(err.Error()), "rate limit")
|
|
}
|
|
|
|
func operationForSyncType(syncType string) string {
|
|
switch syncType {
|
|
case constants.CardObservationSyncTypeRealname:
|
|
return constants.IntegrationOperationGatewayRealname
|
|
case constants.CardObservationSyncTypeTraffic:
|
|
return constants.IntegrationOperationGatewayTraffic
|
|
case constants.CardObservationSyncTypeNetwork:
|
|
return constants.IntegrationOperationGatewayNetwork
|
|
default:
|
|
return constants.IntegrationOperationGatewayDeviceInfo
|
|
}
|
|
}
|
|
|
|
func gatewayIntegrationID(payload cardapp.SeriesTaskPayload) string {
|
|
return "card-series:" + payload.SeriesID + ":" + strconv.Itoa(payload.Attempt)
|
|
}
|
|
|
|
func unsentIntegrationID(payload cardapp.SeriesTaskPayload) string {
|
|
return gatewayIntegrationID(payload) + ":unsent"
|
|
}
|
|
|
|
func optionalText(value string) *string {
|
|
value = strings.TrimSpace(value)
|
|
if value == "" {
|
|
return nil
|
|
}
|
|
return &value
|
|
}
|
|
|
|
func initialResult(result string) string {
|
|
if result == constants.IntegrationResultFailed {
|
|
return constants.IntegrationResultPending
|
|
}
|
|
return result
|
|
}
|
|
|
|
var _ cardapp.SeriesAttemptLogger = (*SeriesAttemptLogger)(nil)
|
|
var _ cardapp.SeriesRunner = (*SeriesRunner)(nil)
|