iotlcm/internal/service/trafficusage/service.go

package trafficusage

import (
	"context"
	"math"
	"strings"
	"time"

	"git.5iot.com/iotlcm-public/iotlcm-worker-svr/internal/model"
	"github.com/gogf/gf/v2/errors/gerror"
)

type UpstreamClient interface {
	QuerySimDatausageDaily(context.Context, *model.SimDataUsageDailyInput) ([]model.SimBaseRes[model.SimDataUsageDailyOutputItem], error)
	QuerySimDatausageMonthly(context.Context, *model.SimDataUsageMonthlyInput) ([]model.SimBaseRes[model.SimDataUsageMonthlyOutputItem], error)
}

type Repository interface {
	UpdateDaily(context.Context, []model.TrafficUsageDailyItem) error
	UpdateMonthly(context.Context, []model.TrafficUsageMonthlyItem) error
}

type Service struct {
	upstream   UpstreamClient
	repository Repository
}

type Failure struct {
	Cause     error
	UsageMb   *float64
	Permanent bool
}

func (failure *Failure) Error() string { return failure.Cause.Error() }
func (failure *Failure) Unwrap() error { return failure.Cause }

func New(upstream UpstreamClient, repository Repository) *Service {
	return &Service{upstream: upstream, repository: repository}
}

var usageLocation = time.FixedZone("UTC+8", 8*60*60)

func validateMessage(simKey *model.SimKey, card model.TrafficUsageSimCard, queryDate, layout string) (time.Time, error) {
	if simKey == nil || card.Iccid == "" || simKey.ICCID != card.Iccid {
		return time.Time{}, &Failure{Cause: gerror.New("invalid traffic usage card identity"), Permanent: true}
	}
	date, err := time.ParseInLocation(layout, queryDate, usageLocation)
	if err != nil {
		return time.Time{}, &Failure{Cause: gerror.Wrap(err, "invalid traffic usage period"), Permanent: true}
	}
	return date, nil
}

func validateUsage(usage float64) error {
	if math.IsNaN(usage) || math.IsInf(usage, 0) || usage < 0 {
		return &Failure{Cause: gerror.New("invalid traffic usage amount"), Permanent: true}
	}
	return nil
}

func (s *Service) RetryDaily(ctx context.Context, message model.TrafficUsageDailyRetryMessage) error {
	date, err := validateMessage(message.SimKey, message.Card, message.QueryDate, "20060102")
	if err != nil {
		return err
	}
	usage := message.UsageMb
	if usage == nil {
		output, err := s.upstream.QuerySimDatausageDaily(ctx, &model.SimDataUsageDailyInput{
			SimKeys: []*model.SimKey{message.SimKey},
			ReqData: model.SimDataUsageDailyInputItem{QueryDate: message.QueryDate},
		})
		if err != nil {
			return err
		}
		if len(output) != 1 || output[0].SimKey == nil || output[0].SimKey.ICCID != message.Card.Iccid {
			return gerror.New("daily usage response missing, failed or card identity mismatched")
		}
		if output[0].Code != 0 {
			return &Failure{Cause: gerror.Newf("daily usage query failed: %s", output[0].Message), Permanent: isPermanentUsageResponse(output[0].Message)}
		}
		if queryDate, ok := normalizeDailyQueryDate(output[0].ResData.QueryDate); !ok || queryDate != message.QueryDate {
			return gerror.New("daily usage response period mismatched")
		}
		usage = &output[0].ResData.DataAmount
	}
	if err := validateUsage(*usage); err != nil {
		return err
	}
	err = s.repository.UpdateDaily(ctx, []model.TrafficUsageDailyItem{{
		TrafficUsageBase: model.TrafficUsageBase{Iccid: message.Card.Iccid, UsageMb: *usage, PackageCode: message.Card.PackageCode}, Date: date,
	}})
	if err != nil {
		return &Failure{Cause: err, UsageMb: usage}
	}
	return nil
}

func (s *Service) RetryMonthly(ctx context.Context, message model.TrafficUsageMonthlyRetryMessage) error {
	month, err := validateMessage(message.SimKey, message.Card, message.QueryDate, "200601")
	if err != nil {
		return err
	}
	usage := message.UsageMb
	if usage == nil {
		output, err := s.upstream.QuerySimDatausageMonthly(ctx, &model.SimDataUsageMonthlyInput{
			SimKeys: []*model.SimKey{message.SimKey},
			ReqData: model.SimDataUsageMonthlyInputItem{QueryDate: message.QueryDate},
		})
		if err != nil {
			return err
		}
		if len(output) != 1 || output[0].SimKey == nil || output[0].SimKey.ICCID != message.Card.Iccid {
			return gerror.New("monthly usage response missing, failed or card identity mismatched")
		}
		if output[0].Code != 0 {
			return &Failure{Cause: gerror.Newf("monthly usage query failed: %s", output[0].Message), Permanent: isPermanentUsageResponse(output[0].Message)}
		}
		if queryMonth, ok := normalizeMonthlyQueryDate(output[0].ResData.DeadLine); !ok || queryMonth != message.QueryDate {
			return gerror.New("monthly usage response period mismatched")
		}
		usage = &output[0].ResData.DataAmount
	}
	if err := validateUsage(*usage); err != nil {
		return err
	}
	err = s.repository.UpdateMonthly(ctx, []model.TrafficUsageMonthlyItem{{
		TrafficUsageBase: model.TrafficUsageBase{Iccid: message.Card.Iccid, UsageMb: *usage, PackageCode: message.Card.PackageCode}, Month: month,
	}})
	if err != nil {
		return &Failure{Cause: err, UsageMb: usage}
	}
	return nil
}

func normalizeDailyQueryDate(value string) (string, bool) {
	for _, layout := range []string{"20060102", "2006-01-02"} {
		parsed, err := time.ParseInLocation(layout, value, usageLocation)
		if err == nil {
			return parsed.Format("20060102"), true
		}
	}
	return "", false
}

func normalizeMonthlyQueryDate(value string) (string, bool) {
	for _, layout := range []string{"200601", "2006-01", "20060102", "2006-01-02"} {
		parsed, err := time.ParseInLocation(layout, value, usageLocation)
		if err == nil {
			return parsed.Format("200601"), true
		}
	}
	return "", false
}

func isPermanentUsageResponse(message string) bool {
	message = strings.ToLower(strings.TrimSpace(message))
	return strings.Contains(message, "unsupported") || strings.Contains(message, "does not support") || strings.Contains(message, "not supported")
}