iotlcm/server/internal/logic/iot/simcardbatch/change/repository.go

package change

import (
	"context"
	"strings"

	"git.5iot.com/iotlcm-public/iotlcm-admin-svr/internal/consts"
	"git.5iot.com/iotlcm-public/iotlcm-admin-svr/internal/dao"
	"git.5iot.com/iotlcm-public/iotlcm-admin-svr/internal/library/contexts"
	"git.5iot.com/iotlcm-public/iotlcm-admin-svr/internal/model/entity"

	"github.com/gogf/gf/v2/database/gdb"
)

type Repository struct{}

func NewRepository() *Repository {
	return &Repository{}
}

// GetSourceBindRows 获取源绑定记录
func (r *Repository) GetSourceBindRows(ctx context.Context, batchNo string) ([]*Row, error) {
	var binds []*entity.TSimCardBindPkg
	columns := dao.TSimCardBindPkg.Columns()
	err := dao.TSimCardBindPkg.Ctx(ctx).
		Fields(
			columns.Id,
			columns.Iccid,
			columns.Msisdn,
			columns.PackageCode,
			columns.SubscriptionNo,
			columns.OrderCode,
			columns.EffectiveTime,
			columns.ExpectedExpireTime,
		).
		Where(columns.BatchNo, strings.TrimSpace(batchNo)).
		Where(columns.TenantId, contexts.GetTenantId(ctx)).
		WhereIn(columns.EffectiveStatus, []int{consts.EffectiveStatusPending, consts.EffectiveStatusEffective}).
		OrderAsc(columns.Id).
		Scan(&binds)
	if err != nil {
		return nil, err
	}

	rows := make([]*Row, 0, len(binds))
	for i, bind := range binds {
		if bind == nil {
			continue
		}
		rows = append(rows, &Row{
			RowNo:             i + 1,
			Iccid:             strings.TrimSpace(bind.Iccid),
			Msisdn:            strings.TrimSpace(bind.Msisdn),
			OldPackageCode:    strings.TrimSpace(bind.PackageCode),
			OldSubscriptionNo: strings.TrimSpace(bind.SubscriptionNo),
			OldOrderSn:        strings.TrimSpace(bind.OrderCode),
			OldEffectiveTime:  bind.EffectiveTime,
			OldExpireTime:     bind.ExpectedExpireTime,
		})
	}
	return rows, nil
}

// GetChangeBatchRows 获取变更批次记录
func (r *Repository) GetChangeBatchRows(ctx context.Context, batchNo string, batchType int) ([]*Row, error) {
	var details []*entity.BatchDetail
	columns := dao.BatchDetail.Columns()
	if batchType == 0 {
		batchType = consts.BatchTypeChange
	}
	err := dao.BatchDetail.Ctx(ctx).
		Fields(columns.RowNo, columns.ItemId, columns.Snapshot).
		Where(columns.BatchNo, strings.TrimSpace(batchNo)).
		Where(columns.BatchType, batchType).
		Where(columns.DetailStatus, consts.BatchDetailStatusSuccess).
		OrderAsc(columns.RowNo).
		Scan(&details)
	if err != nil {
		return nil, err
	}
	return detailsToRows(details), nil
}

// detailsToRows 转换变更批次记录为行数据
func detailsToRows(details []*entity.BatchDetail) []*Row {
	rows := make([]*Row, 0, len(details))
	for _, detail := range details {
		if detail == nil {
			continue
		}
		row := &Row{RowNo: detail.RowNo, Iccid: strings.TrimSpace(detail.ItemId)}
		if detail.Snapshot != nil {
			if row.Iccid == "" {
				row.Iccid = strings.TrimSpace(detail.Snapshot.Get("iccid").String())
			}
			if row.Iccid == "" {
				row.Iccid = strings.TrimSpace(detail.Snapshot.Get("ICCID").String())
			}
			row.Msisdn = strings.TrimSpace(detail.Snapshot.Get("msisdn").String())
			if row.Msisdn == "" {
				row.Msisdn = strings.TrimSpace(detail.Snapshot.Get("MSISDN").String())
			}
			row.Imsi = strings.TrimSpace(detail.Snapshot.Get("imsi").String())
			if row.Imsi == "" {
				row.Imsi = strings.TrimSpace(detail.Snapshot.Get("IMSI").String())
			}
			row.OldPackageCode = strings.TrimSpace(detail.Snapshot.Get("oldPackageCode").String())
			row.OldPackageName = strings.TrimSpace(detail.Snapshot.Get("oldPackageName").String())
			row.OldSubscriptionNo = strings.TrimSpace(detail.Snapshot.Get("oldSubscriptionNo").String())
			row.OldOrderSn = strings.TrimSpace(detail.Snapshot.Get("oldOrderSn").String())
		}
		rows = append(rows, row)
	}
	return rows
}

// LockCardsByIccids 锁定ICCID对应的SIM卡信息
func (r *Repository) LockCardsByIccids(ctx context.Context, tx gdb.TX, iccids []string) (map[string]*entity.TSimCardInfo, error) {
	result := make(map[string]*entity.TSimCardInfo)
	uniqueIccids := uniqueStrings(iccids)
	if len(uniqueIccids) == 0 {
		return result, nil
	}

	var list []*entity.TSimCardInfo
	if err := tx.Ctx(ctx).Model(dao.TSimCardInfo.Table()).
		WhereIn(dao.TSimCardInfo.Columns().Iccid, uniqueIccids).
		LockUpdate().
		Scan(&list); err != nil {
		return nil, err
	}
	for _, item := range list {
		if item != nil && strings.TrimSpace(item.Iccid) != "" {
			result[strings.TrimSpace(item.Iccid)] = item
		}
	}
	return result, nil
}

// LockCurrentActiveBindsByIccids 锁定ICCID对应的当前有效绑定记录
func (r *Repository) LockCurrentActiveBindsByIccids(ctx context.Context, tx gdb.TX, iccids []string) (map[string]*entity.TSimCardBindPkg, error) {
	result := make(map[string]*entity.TSimCardBindPkg)
	priorities := make(map[string]int)
	uniqueIccids := uniqueStrings(iccids)
	if len(uniqueIccids) == 0 {
		return result, nil
	}

	var list []*entity.TSimCardBindPkg
	if err := tx.Ctx(ctx).Model(dao.TSimCardBindPkg.Table()).
		WhereIn(dao.TSimCardBindPkg.Columns().Iccid, uniqueIccids).
		WhereIn(dao.TSimCardBindPkg.Columns().EffectiveStatus, []int{consts.EffectiveStatusPending, consts.EffectiveStatusEffective}).
		OrderDesc(dao.TSimCardBindPkg.Columns().EffectiveStatus).
		OrderAsc(dao.TSimCardBindPkg.Columns().EffectiveTime).
		OrderAsc(dao.TSimCardBindPkg.Columns().Id).
		LockUpdate().
		Scan(&list); err != nil {
		return nil, err
	}
	for _, item := range list {
		if item == nil || strings.TrimSpace(item.Iccid) == "" {
			continue
		}
		iccid := strings.TrimSpace(item.Iccid)
		priority := bindPriority(item.EffectiveStatus)
		currentPriority, exists := priorities[iccid]
		if exists && priority < currentPriority {
			continue
		}
		if exists && priority == currentPriority {
			result[iccid] = nil
			continue
		}
		priorities[iccid] = priority
		result[iccid] = item
	}
	return result, nil
}

// LockPendingBindsByIccids 锁定ICCID对应的待生效绑定记录
func (r *Repository) LockPendingBindsByIccids(ctx context.Context, tx gdb.TX, iccids []string) ([]*entity.TSimCardBindPkg, error) {
	uniqueIccids := uniqueStrings(iccids)
	if len(uniqueIccids) == 0 {
		return nil, nil
	}

	var list []*entity.TSimCardBindPkg
	if err := tx.Ctx(ctx).Model(dao.TSimCardBindPkg.Table()).
		WhereIn(dao.TSimCardBindPkg.Columns().Iccid, uniqueIccids).
		Where(dao.TSimCardBindPkg.Columns().EffectiveStatus, consts.EffectiveStatusPending).
		OrderAsc(dao.TSimCardBindPkg.Columns().EffectiveTime).
		OrderAsc(dao.TSimCardBindPkg.Columns().Id).
		LockUpdate().
		Scan(&list); err != nil {
		return nil, err
	}
	return list, nil
}

// DeleteBindsBySubscriptionNos 删除指定订阅号的绑定记录
func (r *Repository) DeleteBindsBySubscriptionNos(ctx context.Context, tx gdb.TX, subscriptionNos []string) (int64, error) {
	uniqueNos := uniqueStrings(subscriptionNos)
	if len(uniqueNos) == 0 {
		return 0, nil
	}
	result, err := tx.Ctx(ctx).Model(dao.TSimCardBindPkg.Table()).
		WhereIn(dao.TSimCardBindPkg.Columns().SubscriptionNo, uniqueNos).
		Delete()
	if err != nil {
		return 0, err
	}
	return result.RowsAffected()
}

// ActiveBindCountsByOrderCodes 获取指定订单号的当前有效绑定记录数量
func (r *Repository) ActiveBindCountsByOrderCodes(ctx context.Context, tx gdb.TX, orderCodes []string) (map[string]int, error) {
	result := make(map[string]int)
	uniqueCodes := uniqueStrings(orderCodes)
	if len(uniqueCodes) == 0 {
		return result, nil
	}

	type row struct {
		OrderCode string `orm:"order_code"`
		Count     int    `orm:"count"`
	}
	var rows []row
	if err := tx.Ctx(ctx).Model(dao.TSimCardBindPkg.Table()).
		Fields(dao.TSimCardBindPkg.Columns().OrderCode, "COUNT(1) AS count").
		WhereIn(dao.TSimCardBindPkg.Columns().OrderCode, uniqueCodes).
		Group(dao.TSimCardBindPkg.Columns().OrderCode).
		Scan(&rows); err != nil {
		return nil, err
	}
	for _, item := range rows {
		result[strings.TrimSpace(item.OrderCode)] = item.Count
	}
	return result, nil
}

// bindPriority 获取绑定记录的优先级
func bindPriority(status int) int {
	switch status {
	case consts.EffectiveStatusEffective:
		return 2
	case consts.EffectiveStatusPending:
		return 1
	default:
		return 0
	}
}