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

package outbound

import (
	"context"
	"strings"

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

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

const (
	outboundDatabaseChunkSize       = 5000
	outboundDatabaseInsertChunkSize = 500
)

type Repository struct{}

type StockCard struct {
	Iccid       string `orm:"iccid"`
	Msisdn      string `orm:"msisdn"`
	Imsi        string `orm:"imsi"`
	Imei        string `orm:"imei"`
	ChanKey     string `orm:"chan_key"`
	CreatedDept int64  `orm:"created_dept"`
	BatchNo     string `orm:"batch_no"`
}

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

func (r *Repository) GetStockCardsByIccids(ctx context.Context, iccids []string) (map[string]*StockCard, error) {
	columns := dao.TSimCardStock.Columns()
	return r.getStockCardsByColumn(ctx, columns.Iccid, iccids)

}

func (r *Repository) GetStockCardsByMsisdns(ctx context.Context, msisdns []string) (map[string]*StockCard, error) {
	columns := dao.TSimCardStock.Columns()
	return r.getStockCardsByColumn(ctx, columns.Msisdn, msisdns)
}

func (r *Repository) GetStockCardsByImsis(ctx context.Context, imsis []string) (map[string]*StockCard, error) {
	columns := dao.TSimCardStock.Columns()
	return r.getStockCardsByColumn(ctx, columns.Imsi, imsis)
}

func (r *Repository) getStockCardsByColumn(ctx context.Context, column string, values []string) (map[string]*StockCard, error) {
	result := make(map[string]*StockCard)
	uniqueValues := uniqueStrings(values)
	if len(uniqueValues) == 0 {
		return result, nil
	}

	columns := dao.TSimCardStock.Columns()
	for start := 0; start < len(uniqueValues); start += outboundDatabaseChunkSize {
		end := start + outboundDatabaseChunkSize
		if end > len(uniqueValues) {
			end = len(uniqueValues)
		}

		var list []*StockCard
		if err := dao.TSimCardStock.Ctx(ctx).
			Fields(columns.Iccid, columns.Msisdn, columns.Imsi, columns.Imei, columns.ChanKey, columns.CreatedDept, columns.BatchNo).
			WhereIn(column, uniqueValues[start:end]).
			Scan(&list); err != nil {
			return nil, err
		}
		for _, item := range list {
			if item == nil {
				continue
			}
			key := ""
			switch column {
			case columns.Msisdn:
				key = item.Msisdn
			case columns.Imsi:
				key = item.Imsi
			default:
				key = item.Iccid
			}
			if key != "" {
				result[key] = item
			}
		}
	}
	return result, nil
}

func (r *Repository) LockStockCardsByIccids(ctx context.Context, tx gdb.TX, iccids []string) (map[string]*entity.TSimCardStock, error) {
	result := make(map[string]*entity.TSimCardStock)
	uniqueIccids := uniqueStrings(iccids)
	if len(uniqueIccids) == 0 {
		return result, nil
	}

	for start := 0; start < len(uniqueIccids); start += outboundDatabaseChunkSize {
		end := start + outboundDatabaseChunkSize
		if end > len(uniqueIccids) {
			end = len(uniqueIccids)
		}

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

func (r *Repository) GetExistingFormalIccids(ctx context.Context, iccids []string) (map[string]bool, error) {
	result := make(map[string]bool)
	uniqueIccids := uniqueStrings(iccids)
	if len(uniqueIccids) == 0 {
		return result, nil
	}

	columns := dao.TSimCardInfo.Columns()
	for start := 0; start < len(uniqueIccids); start += outboundDatabaseChunkSize {
		end := start + outboundDatabaseChunkSize
		if end > len(uniqueIccids) {
			end = len(uniqueIccids)
		}

		var list []struct {
			Iccid string `orm:"iccid"`
		}
		if err := dao.TSimCardInfo.Ctx(ctx).
			Fields(columns.Iccid).
			WhereIn(columns.Iccid, uniqueIccids[start:end]).
			Scan(&list); err != nil {
			return nil, err
		}
		for _, item := range list {
			if item.Iccid != "" {
				result[item.Iccid] = true
			}
		}
	}
	return result, nil
}

func (r *Repository) GetInboundBatchInfos(ctx context.Context, tx gdb.TX, batchNos []string) (map[string]*gjson.Json, error) {
	result := make(map[string]*gjson.Json)
	uniqueBatchNos := uniqueStrings(batchNos)
	if len(uniqueBatchNos) == 0 {
		return result, nil
	}

	var list []struct {
		BatchNo   string      `orm:"batch_no"`
		BatchInfo *gjson.Json `orm:"batch_info"`
	}
	dbModel := dao.BatchMain.Ctx(ctx)
	if tx != nil {
		dbModel = tx.Ctx(ctx).Model(dao.BatchMain.Table()).Safe()
	}
	columns := dao.BatchMain.Columns()
	if err := dbModel.
		Fields(columns.BatchNo, columns.BatchInfo).
		WhereIn(columns.BatchNo, uniqueBatchNos).
		Scan(&list); err != nil {
		return nil, err
	}
	for _, item := range list {
		if item.BatchNo != "" {
			result[item.BatchNo] = item.BatchInfo
		}
	}
	return result, nil
}

func (r *Repository) LoadPackage(ctx context.Context, tx gdb.TX, tenantId, packageCode string) (*entity.TSimFlowPackageInfo, error) {
	packageCode = strings.TrimSpace(packageCode)
	if packageCode == "" {
		return nil, nil
	}

	mod := dao.TSimFlowPackageInfo.Ctx(ctx)
	if tx != nil {
		mod = tx.Ctx(ctx).Model(dao.TSimFlowPackageInfo.Table()).Safe()
	}
	mod = mod.Where(dao.TSimFlowPackageInfo.Columns().PackageCode, packageCode)
	if strings.TrimSpace(tenantId) != "" {
		mod = mod.Where(dao.TSimFlowPackageInfo.Columns().TenantId, strings.TrimSpace(tenantId))
	}

	var pkg *entity.TSimFlowPackageInfo
	if err := mod.Scan(&pkg); err != nil {
		return nil, err
	}
	return pkg, nil
}