iotlcm/server/internal/logic/simwarning/log_writer.go

package simwarning

import (
	"context"
	"git.5iot.com/iotlcm-public/iotlcm-admin-svr/internal/dao"
	"git.5iot.com/iotlcm-public/iotlcm-admin-svr/internal/model/do"
	"time"

	"github.com/gogf/gf/v2/database/gdb"
	"github.com/gogf/gf/v2/frame/g"
	"github.com/gogf/gf/v2/os/gtime"
)

func writeWarningRecord(ctx context.Context, hit warningHit, warnTime time.Time) (warningRecord, error) {
	stored, err := writeWarningBatch(ctx, []pendingWarning{{Hit: hit}}, warnTime)
	if err != nil {
		return warningRecord{}, err
	}
	if len(stored) == 0 {
		return warningRecord{}, nil
	}
	return stored[0].Record, nil
}

func writeWarningBatch(ctx context.Context, pendingWarnings []pendingWarning, warnTime time.Time) ([]storedWarning, error) {
	if len(pendingWarnings) == 0 {
		return nil, nil
	}

	storedWarnings := make([]storedWarning, 0, len(pendingWarnings))
	err := dao.TWarnLog.Transaction(ctx, func(ctx context.Context, tx gdb.TX) error {
		for _, pending := range pendingWarnings {
			warnLogID, err := tx.Ctx(ctx).Model(dao.TWarnLog.Table()).Safe().
				Data(buildWarnLogData(pending.Hit, warnTime)).
				InsertAndGetId()
			if err != nil {
				return err
			}
			storedWarnings = append(storedWarnings, storedWarning{
				Hit: pending.Hit,
				Record: warningRecord{
					WarnLogID: warnLogID,
				},
			})
		}
		return nil
	})
	return storedWarnings, err
}

func buildWarnLogData(hit warningHit, warnTime time.Time) do.TWarnLog {
	var remainFlowMb any
	if isTrafficKind(hit.Kind) {
		remainFlowMb = hit.RemainFlowMb
	}

	return do.TWarnLog{
		TenantId:       hit.Config.TenantId,
		ConfigId:       hit.Config.Id,
		ItemType:       hit.Config.ItemType,
		ItemId:         hit.Config.ItemId,
		ItemCode:       warnItemCodeSnapshot(hit),
		WarnStage:      hit.WarnStage,
		WarnLevel:      hit.WarnLevel,
		WarnUnit:       hit.Config.WarnUnit,
		ThresholdValue: hit.ThresholdValue,
		ActualValue:    hit.ActualValue,
		TotalFlowMb:    hit.TotalFlowMb,
		RemainFlowMb:   remainFlowMb,
		WarnMethods:    warnMethodsSnapshot(hit),
		WarnPhones:     hit.Config.WarnPhones,
		WarnEmails:     hit.Config.WarnEmails,
		MessageLogId:   nil,
		WarnTime:       gtime.NewFromTime(warnTime),
		Remark:         hit.Remark,
		CreatedDept:    hit.Config.CreatedDept,
		CreatedBy:      hit.Config.CreatedBy,
	}
}

func logWarningHit(ctx context.Context, hit warningHit, record warningRecord) {
	g.Log().Infof(
		ctx,
		"SimWarning hit stored, mode:warn_log_only, warnLogId:%d, kind:%s, configId:%d, tenantId:%s, itemType:%d, itemId:%d, itemCode:%s, warnUnit:%d, stage:%d, level:%d, threshold:%.3f, actual:%.3f, totalFlowMb:%.3f, remainFlowMb:%.3f, methods:%s, phones:%s, emails:%s, remark:%s",
		record.WarnLogID,
		hit.Kind,
		hit.Config.Id,
		hit.Config.TenantId,
		hit.Config.ItemType,
		hit.Config.ItemId,
		warnItemCodeSnapshot(hit),
		hit.Config.WarnUnit,
		hit.WarnStage,
		hit.WarnLevel,
		hit.ThresholdValue,
		hit.ActualValue,
		hit.TotalFlowMb,
		hit.RemainFlowMb,
		warnMethodsSnapshot(hit),
		hit.Config.WarnPhones,
		hit.Config.WarnEmails,
		hit.Remark,
	)
}

func logWarningBatch(ctx context.Context, storedWarnings []storedWarning) {
	if len(storedWarnings) == 0 {
		return
	}
	g.Log().Infof(ctx, "SimWarning warning batch stored, mode:warn_log_only, warnings:%d", len(storedWarnings))
}

func warnItemCodeSnapshot(hit warningHit) string {
	if hit.Config.ItemCode != "" {
		return hit.Config.ItemCode
	}
	if hit.Config.ItemType == warnItemTypeFlowPool && hit.Pool.FlowPoolCode != "" {
		return hit.Pool.FlowPoolCode
	}
	if hit.Card.Iccid != "" {
		return hit.Card.Iccid
	}
	return hit.Card.Msisdn
}

func warnMethodsSnapshot(hit warningHit) string {
	if hit.Config.WarnMethods != "" {
		return hit.Config.WarnMethods
	}
	return warnMessageDefaultMethod
}