chore: 并入 iotlcm-upstream-chan 历史到 upstream-chan/（原提交 1e74497）

2026-11-02 13:28:02 +08:00
parent 691b792391 1e74497728
commit 9c9f6c2a29
192 changed files with 33119 additions and 0 deletions
@@ -0,0 +1,495 @@
+package upstreamimpl
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"strconv"
+	"strings"
+	"time"
+
+	"git.5iot.com/iotlcm-public/iotlcm-upstream-chan/internal/consts"
+	"git.5iot.com/iotlcm-public/iotlcm-upstream-chan/internal/model"
+
+	"github.com/gogf/gf/v2/frame/g"
+)
+
+// 移动 OneLink「通信功能开停」接口（2026 接口改版后，替代原 ec/operate/sim-apn-function）。
+//
+//	7.2.1 单卡（CMIOT_API25M19）  GET /v5/ec/manage/sim-communication-service
+//	  functionType=01(APN上网功能)，businessType：0=开 1=停，APN 名称字段为 apn
+//	7.2.2 批量（CMIOT_API23M09）  GET /v5/ec/operate/sim-communication-function/batch
+//	  serviceType=11(数据通信服务)，operType：0=暂停(停) 1=恢复(开)，APN 名称字段为 apnName
+//
+// 分流策略（与产品约定）：
+//
+//	卡数 <10   逐张走 7.2.1
+//	10~100     一次走 7.2.2
+//	>100       按 100 拆块，不足 10 的尾块退回 7.2.1
+//
+// 批量接口 7.2.2 只认 msisdn，缺号码的卡降级走 7.2.1（用 iccid）。
+// 两个接口同卡同类型均有限流（3 分钟一次），且 7.2.2 批量中任一张被限流则整批失败（status 13009）。
+const (
+	ydCommunicationServicePath       = "ec/manage/sim-communication-service"
+	ydCommunicationFunctionBatchPath = "ec/operate/sim-communication-function/batch"
+	ydCommunicationBatchResultPath   = "ec/query/sim-batch-result" // 5.1.2 CMIOT_API23M10 批量办理结果查询
+	ydCommunicationFunctionTypeApn   = "01"                        // 7.2.1 functionType：APN 上网功能
+	ydCommunicationServiceTypeData   = "11"                        // 7.2.2 serviceType：数据通信服务
+	ydCommunicationBatchMin          = 10                          // 7.2.2 每批最少卡数
+	ydCommunicationBatchMax          = 100                         // 7.2.2 每批最多卡数
+)
+
+// 批量办理任务状态（5.1.2 sim-batch-result 返回的 jobStatus）。
+const (
+	ydJobStatusDone        = "2" // 处理完成（全部成功）
+	ydJobStatusDonePartial = "3" // 处理完成（含失败记录）
+	ydJobStatusFailed      = "4" // 处理失败
+)
+
+// ydBatchResultQueryFailedMessage 是批量异步任务结果查询失败（轮询超时 / 查询请求失败）时，
+// 逐卡写入执行日志明细的失败原因：该子批次下每张卡都记这一条，代表"结果未确认"而非"办理失败"。
+const ydBatchResultQueryFailedMessage = "查询上游通信结果失败，未取得最终办理结果，请稍后核对"
+
+// 批量结果轮询参数；声明为变量以便单测缩短周期。
+//
+// 两个值均维持原值，原因（实测：上游批量任务约 60s 出终态）：
+//   - 间隔只决定终态被捕获的延迟（0~interval）。整批 2 万张 = 200 子批 / 并发 5 = 40 波，
+//     总等待由"每波等上游 job 完成"主导，缩间隔对总时长影响可忽略，却成倍增加查询接口压力。
+//   - 上限若下调到 60s 会踩在上游耗时边界上，超时即把整个子批 100 张记为失败，而失败结果
+//     不回写本地 data_service_status，会造成平台状态与卡真实状态不一致。
+//
+// 真正压缩总等待应把"提交"与"结果查询"分离（全部子批先拿 jobId，再统一并发轮询），
+// 使总等待从 40 × 上限 降到 ≈ 1 × 上限，而不是靠缩短这里的超时。
+var (
+	ydBatchResultPollInterval = 5 * time.Second
+	ydBatchResultPollTimeout  = 180 * time.Second
+)
+
+// ydApnRequester 抽出移动通道发起请求所需的最小能力，供真实通道(sSimYD)与 mock 通道(sSimYDMock)
+// 共用同一套开停逻辑，避免两份实现走偏。
+type ydApnRequester interface {
+	getUrl(ctx context.Context, serviceUrl string) string
+	getTransId(ctx context.Context) string
+	requestYd(ctx context.Context, operation, url string, params g.Map) (*ydHTTPResponse, error)
+}
+
+// changeSimApnFunctionYD 平台「开通数据(dataStart)/停用数据(dataStop)/达量断网(dataCut)」在移动侧的统一入口。
+func changeSimApnFunctionYD(ctx context.Context, c ydApnRequester, input *model.SimCardOperateChangeApnInput) (model.SimCardOperateChangeApnOutput, error) {
+	items := make(model.SimCardOperateChangeApnOutput, 0, len(input.SimKeys))
+	if jobID := strings.TrimSpace(input.ReqData.QueryJobID); jobID != "" {
+		return mapYdQueryResult(input.SimKeys, jobID, queryBatchResultOnceYD(ctx, c, jobID)), nil
+	}
+
+	// 缺 msisdn 的卡不能进批量接口，先分流出来单独走单卡。
+	withMsisdn := make([]*model.SimKey, 0, len(input.SimKeys))
+	singleKeys := make([]*model.SimKey, 0)
+	for _, simKey := range input.SimKeys {
+		if simKey == nil {
+			continue
+		}
+		if strings.TrimSpace(simKey.MSISDN) == "" {
+			singleKeys = append(singleKeys, simKey)
+			continue
+		}
+		withMsisdn = append(withMsisdn, simKey)
+	}
+
+	for start := 0; start < len(withMsisdn); start += ydCommunicationBatchMax {
+		end := start + ydCommunicationBatchMax
+		if end > len(withMsisdn) {
+			end = len(withMsisdn)
+		}
+		chunk := withMsisdn[start:end]
+		if len(chunk) < ydCommunicationBatchMin {
+			singleKeys = append(singleKeys, chunk...)
+			continue
+		}
+		items = append(items, changeApnBatchYD(ctx, c, chunk, input.ReqData)...)
+		if input.ReqData.SubmitOnly {
+			if checkpoint, ok := ctx.Value(model.ApnOperationCheckpointKey{}).(func(model.SimCardOperateChangeApnOutput) error); ok {
+				if err := checkpoint(items); err != nil {
+					g.Log().Errorf(ctx, "APN批量结果持久化失败 operationId=%s error=%v", input.ReqData.OperationID, err)
+					return items, fmt.Errorf("APN批量结果持久化失败，停止后续办理：%w", err)
+				}
+			}
+		}
+	}
+
+	if input.ReqData.SubmitOnly {
+		for _, key := range singleKeys {
+			items = append(items, changeApnSingleYD(ctx, c, []*model.SimKey{key}, input.ReqData)...)
+			if checkpoint, ok := ctx.Value(model.ApnOperationCheckpointKey{}).(func(model.SimCardOperateChangeApnOutput) error); ok {
+				if err := checkpoint(items); err != nil {
+					g.Log().Errorf(ctx, "APN单卡结果持久化失败 operationId=%s error=%v", input.ReqData.OperationID, err)
+					return items, fmt.Errorf("APN单卡结果持久化失败，停止后续办理：%w", err)
+				}
+			}
+		}
+	} else {
+		items = append(items, changeApnSingleYD(ctx, c, singleKeys, input.ReqData)...)
+	}
+	return items, nil
+}
+
+// changeApnSingleYD 逐张调用 7.2.1 单卡接口办理。
+func changeApnSingleYD(ctx context.Context, c ydApnRequester, simKeys []*model.SimKey, req model.SimCardOperateChangeApnInputItem) model.SimCardOperateChangeApnOutput {
+	items := make(model.SimCardOperateChangeApnOutput, 0, len(simKeys))
+	if len(simKeys) == 0 {
+		return items
+	}
+
+	businessType, ok := convertYdCommunicationBusinessType(ctx, req.OperType)
+	if !ok {
+		for _, simKey := range simKeys {
+			items = append(items, ydApnErrorItem(simKey, "unsupported operType, expected 0(open) or 1(stop)"))
+		}
+		return items
+	}
+
+	url := c.getUrl(ctx, ydCommunicationServicePath)
+	// {"status":"0","message":"正确","result":[{"iccid":"89860000000000000002","orderNum":"xxxxxxx"}]}
+	type ydSingleResp struct {
+		Status  string `json:"status"`
+		Message string `json:"message"`
+		Result  []struct {
+			OrderNum string `json:"orderNum"`
+		} `json:"result"`
+	}
+
+	for _, simKey := range simKeys {
+		params := g.Map{
+			"transid":      c.getTransId(ctx),
+			"functionType": ydCommunicationFunctionTypeApn,
+			"businessType": businessType,
+			"apn":          req.ApnName,
+		}
+		// 卡号三选一，必须有且只有一项：优先 iccid，其次 msisdn，最后 imsi。
+		switch {
+		case strings.TrimSpace(simKey.ICCID) != "":
+			params["iccid"] = strings.TrimSpace(simKey.ICCID)
+		case strings.TrimSpace(simKey.MSISDN) != "":
+			params["msisdn"] = strings.TrimSpace(simKey.MSISDN)
+		case strings.TrimSpace(simKey.IMSI) != "":
+			params["imsi"] = strings.TrimSpace(simKey.IMSI)
+		default:
+			g.Log().Warningf(ctx, "changeApnSingleYD missing iccid/msisdn/imsi, simKey %+v", simKey)
+			items = append(items, ydApnErrorItem(simKey, "missing iccid/msisdn/imsi"))
+			continue
+		}
+
+		resp, err := c.requestYd(ctx, "ChangeSimApnFunction", url, params)
+		if err != nil {
+			g.Log().Errorf(ctx, "changeApnSingleYD request error %+v, url %s, params %+v", err, url, params)
+			item := ydApnErrorItem(simKey, err.Error())
+			item.ResData.Uncertain = req.SubmitOnly
+			items = append(items, item)
+			continue
+		}
+		body := resp.ReadAllString()
+		var ydResp ydSingleResp
+		if err = json.Unmarshal([]byte(body), &ydResp); err != nil {
+			g.Log().Errorf(ctx, "changeApnSingleYD unmarshal error %+v, url %s, params %+v, body %s", err, url, params, body)
+			item := ydApnErrorItem(simKey, err.Error())
+			item.ResData.Uncertain = req.SubmitOnly
+			items = append(items, item)
+			continue
+		}
+		if ydResp.Status != "0" {
+			g.Log().Warningf(ctx, "changeApnSingleYD upstream error %s, url %s, params %+v, body %s", ydResp.Message, url, params, body)
+			items = append(items, ydApnRejectedItem(simKey, ydResp.Status, ydResp.Message))
+			continue
+		}
+		orderNum := ""
+		if len(ydResp.Result) > 0 {
+			orderNum = ydResp.Result[0].OrderNum
+		}
+		items = append(items, ydApnResultItem(simKey, 0, ydResp.Message, orderNum))
+	}
+	return items
+}
+
+// changeApnBatchYD 用一批（10~100 张）调用 7.2.2 批量接口一次办理。
+// 该接口异步返回 jobId，status=0 即视为本批全部受理成功，逐卡回填同一个 jobId。
+func changeApnBatchYD(ctx context.Context, c ydApnRequester, simKeys []*model.SimKey, req model.SimCardOperateChangeApnInputItem) model.SimCardOperateChangeApnOutput {
+	items := make(model.SimCardOperateChangeApnOutput, 0, len(simKeys))
+
+	operType, ok := convertYdCommunicationOperType(ctx, req.OperType)
+	if !ok {
+		for _, simKey := range simKeys {
+			items = append(items, ydApnErrorItem(simKey, "unsupported operType, expected 0(open) or 1(stop)"))
+		}
+		return items
+	}
+
+	msisdns := make([]string, 0, len(simKeys))
+	for _, simKey := range simKeys {
+		msisdns = append(msisdns, strings.TrimSpace(simKey.MSISDN))
+	}
+
+	url := c.getUrl(ctx, ydCommunicationFunctionBatchPath)
+	params := g.Map{
+		"transid":     c.getTransId(ctx),
+		"msisdns":     strings.Join(msisdns, "_"),
+		"serviceType": ydCommunicationServiceTypeData,
+		"operType":    operType,
+		"apnName":     req.ApnName,
+	}
+	// {"status":"0","message":"正确","result":[{"jobId":"xxxxxxx"}]}
+	type ydBatchResp struct {
+		Status  string `json:"status"`
+		Message string `json:"message"`
+		Result  []struct {
+			JobId string `json:"jobId"`
+		} `json:"result"`
+	}
+
+	resp, err := c.requestYd(ctx, "ChangeSimApnFunction", url, params)
+	if err != nil {
+		g.Log().Errorf(ctx, "changeApnBatchYD request error %+v, url %s, params %+v", err, url, params)
+		for _, simKey := range simKeys {
+			item := ydApnErrorItem(simKey, err.Error())
+			item.ResData.Uncertain = req.SubmitOnly
+			items = append(items, item)
+		}
+		return items
+	}
+	body := resp.ReadAllString()
+	var ydResp ydBatchResp
+	if err = json.Unmarshal([]byte(body), &ydResp); err != nil {
+		g.Log().Errorf(ctx, "changeApnBatchYD unmarshal error %+v, url %s, params %+v, body %s", err, url, params, body)
+		for _, simKey := range simKeys {
+			item := ydApnErrorItem(simKey, err.Error())
+			item.ResData.Uncertain = req.SubmitOnly
+			items = append(items, item)
+		}
+		return items
+	}
+	if ydResp.Status != "0" {
+		g.Log().Warningf(ctx, "changeApnBatchYD upstream error %s, url %s, params %+v, body %s", ydResp.Message, url, params, body)
+		for _, simKey := range simKeys {
+			items = append(items, ydApnRejectedItem(simKey, ydResp.Status, ydResp.Message))
+		}
+		return items
+	}
+	jobId := ""
+	if len(ydResp.Result) > 0 {
+		jobId = ydResp.Result[0].JobId
+	}
+	if jobId == "" {
+		g.Log().Warningf(ctx, "changeApnBatchYD accepted without jobId, url %s, params %+v, body %s", url, params, body)
+		for _, simKey := range simKeys {
+			item := ydApnResultItem(simKey, consts.ApiStatusError, "上游受理成功但未返回 jobId，需核对受理结果", "")
+			item.ResData.Uncertain = true
+			items = append(items, item)
+		}
+		return items
+	}
+
+	if req.SubmitOnly {
+		for _, simKey := range simKeys {
+			item := ydApnResultItem(simKey, 0, "上游已受理，等待查询最终结果", jobId)
+			item.ResData.Pending = true
+			items = append(items, item)
+		}
+		return items
+	}
+
+	// 7.2.2 是异步接口：受理（status=0）不等于办理成功。必须轮询结果接口拿到每张卡的最终结果，
+	// 否则执行日志会把"部分失败"的批次整批误记为成功。
+	result := queryBatchResultYD(ctx, c, jobId)
+	switch {
+	case result.finished && result.failed:
+		for _, simKey := range simKeys {
+			items = append(items, ydApnResultItem(simKey, consts.ApiStatusError, "上游批量任务处理失败", jobId))
+		}
+	case result.finished:
+		for _, simKey := range simKeys {
+			card, exist := result.cards[strings.TrimSpace(simKey.MSISDN)]
+			if !exist {
+				item := ydApnResultItem(simKey, consts.ApiStatusError, "上游批量结果未返回该卡", jobId)
+				item.ResData.Uncertain = true
+				items = append(items, item)
+				continue
+			}
+			item := ydApnResultItem(simKey, card.code, card.message, jobId)
+			item.ResData.Uncertain = card.uncertain
+			items = append(items, item)
+		}
+	default:
+		// 轮询超时或查询失败：该子批下每张卡都按"查询上游通信结果失败"落库，避免误报成功。
+		// 该文案会逐卡写进执行日志明细；日后若增加"重新查询上游结果"的补偿能力，从这一层补做即可。
+		g.Log().Warningf(ctx, "changeApnBatchYD result poll not finished, jobId %s, params %+v", jobId, params)
+		for _, simKey := range simKeys {
+			item := ydApnResultItem(simKey, consts.ApiStatusError, ydBatchResultQueryFailedMessage+"："+result.reason, jobId)
+			item.ResData.Uncertain = true
+			items = append(items, item)
+		}
+	}
+	return items
+}
+
+func (s *sSimYD) QuerySimApnFunctionResult(ctx context.Context, input *model.SimCardOperateChangeApnInput) (model.SimCardOperateChangeApnOutput, error) {
+	return mapYdQueryResult(input.SimKeys, input.ReqData.QueryJobID, queryBatchResultOnceYD(ctx, s, input.ReqData.QueryJobID)), nil
+}
+
+func (s *sSimYDMock) QuerySimApnFunctionResult(ctx context.Context, input *model.SimCardOperateChangeApnInput) (model.SimCardOperateChangeApnOutput, error) {
+	return mapYdQueryResult(input.SimKeys, input.ReqData.QueryJobID, queryBatchResultOnceYD(ctx, s, input.ReqData.QueryJobID)), nil
+}
+
+// ydBatchCardResult 批量任务中单张卡的最终办理结果。
+type ydBatchCardResult struct {
+	code      int
+	message   string
+	uncertain bool
+}
+
+// ydBatchQueryResult 批量办理结果查询的结论。
+type ydBatchQueryResult struct {
+	finished bool                         // 是否已取得终态（jobStatus 2/3/4）
+	failed   bool                         // jobStatus=4，整批处理失败
+	cards    map[string]ydBatchCardResult // resultId（msisdn）-> 单卡结果
+	reason   string
+}
+
+// ydBatchResultItem 5.1.2 sim-batch-result 的逐卡结果项。
+type ydBatchResultItem struct {
+	Status     string `json:"status"`
+	Message    string `json:"message"`
+	ResultType string `json:"resultType"`
+	ResultId   string `json:"resultId"`
+}
+
+// ydBatchResultResp 5.1.2 sim-batch-result 的响应体。
+type ydBatchResultResp struct {
+	Status  string `json:"status"`
+	Message string `json:"message"`
+	Result  []struct {
+		JobStatus  string              `json:"jobStatus"`
+		ResultList []ydBatchResultItem `json:"resultList"`
+	} `json:"result"`
+}
+
+// queryBatchResultYD 轮询 7.2.2 批量任务结果，直到取得终态或超时。
+// 超时 / 请求失败均返回 finished=false，由调用方按"未确认"处理。
+func queryBatchResultYD(ctx context.Context, c ydApnRequester, jobId string) ydBatchQueryResult {
+	pollCtx, cancel := context.WithTimeout(ctx, ydBatchResultPollTimeout)
+	defer cancel()
+	var last ydBatchQueryResult
+	for {
+		if err := pollCtx.Err(); err != nil {
+			last.reason = "查询上游通信结果截止：" + err.Error() + "；" + last.reason
+			return last
+		}
+		last = queryBatchResultOnceYD(pollCtx, c, jobId)
+		if last.finished {
+			return last
+		}
+		timer := time.NewTimer(ydBatchResultPollInterval)
+		select {
+		case <-pollCtx.Done():
+			timer.Stop()
+			last.reason = "查询上游通信结果截止：" + pollCtx.Err().Error() + "；" + last.reason
+			return last
+		case <-timer.C:
+		}
+	}
+}
+
+// queryBatchResultOnceYD 只查询一次；持久化调度器负责后续补查。
+func queryBatchResultOnceYD(ctx context.Context, c ydApnRequester, jobID string) ydBatchQueryResult {
+	params := g.Map{"transid": c.getTransId(ctx), "jobId": jobID}
+	resp, err := c.requestYd(ctx, "QuerySimBatchResult", c.getUrl(ctx, ydCommunicationBatchResultPath), params)
+	if err != nil {
+		return ydBatchQueryResult{reason: "查询上游通信结果失败：" + err.Error()}
+	}
+	body := resp.ReadAllString()
+	var parsed ydBatchResultResp
+	if err := json.Unmarshal([]byte(body), &parsed); err != nil {
+		return ydBatchQueryResult{reason: "查询上游通信结果解析失败：" + err.Error()}
+	}
+	if parsed.Status != "0" {
+		return ydBatchQueryResult{reason: "查询上游通信结果失败，status=" + parsed.Status + "，message=" + parsed.Message}
+	}
+	if len(parsed.Result) == 0 {
+		return ydBatchQueryResult{reason: "上游查询未返回任务结果"}
+	}
+	switch parsed.Result[0].JobStatus {
+	case ydJobStatusDone, ydJobStatusDonePartial:
+		return ydBatchQueryResult{finished: true, cards: toYdBatchCardMap(parsed.Result[0].ResultList)}
+	case ydJobStatusFailed:
+		return ydBatchQueryResult{finished: true, failed: true, reason: parsed.Message}
+	default:
+		return ydBatchQueryResult{reason: "上游任务尚未完成，jobStatus=" + parsed.Result[0].JobStatus}
+	}
+}
+
+func mapYdQueryResult(keys []*model.SimKey, jobID string, result ydBatchQueryResult) model.SimCardOperateChangeApnOutput {
+	items := make(model.SimCardOperateChangeApnOutput, 0, len(keys))
+	for _, key := range keys {
+		if key == nil {
+			continue
+		}
+		item := ydApnResultItem(key, consts.ApiStatusError, result.reason, jobID)
+		switch {
+		case !result.finished:
+			item.ResData.Pending = true
+		case result.failed:
+			item.Message = "上游批量任务处理失败：" + result.reason
+		default:
+			if card, ok := result.cards[strings.TrimSpace(key.MSISDN)]; ok {
+				item.Code, item.Message = card.code, card.message
+				item.ResData.Uncertain = card.uncertain
+			} else {
+				item.Message = "上游批量结果未返回该卡，需继续核对"
+				item.ResData.Uncertain = true
+			}
+		}
+		items = append(items, item)
+	}
+	return items
+}
+
+// toYdBatchCardMap 把逐卡结果按 resultId（msisdn）建索引。
+func toYdBatchCardMap(list []ydBatchResultItem) map[string]ydBatchCardResult {
+	cards := make(map[string]ydBatchCardResult, len(list))
+	for _, item := range list {
+		id := strings.TrimSpace(item.ResultId)
+		if id == "" {
+			continue
+		}
+		code, err := strconv.Atoi(strings.TrimSpace(item.Status))
+		if err != nil {
+			cards[id] = ydBatchCardResult{code: consts.ApiStatusError, message: "上游逐卡结果状态无效，status=" + item.Status + "，message=" + item.Message, uncertain: true}
+			continue
+		}
+		cards[id] = ydBatchCardResult{code: code, message: item.Message}
+	}
+	return cards
+}
+
+func ydApnRejectedItem(key *model.SimKey, status, message string) *model.SimBaseRes[model.SimCardOperateChangeApnItem] {
+	code, err := strconv.Atoi(strings.TrimSpace(status))
+	if err != nil || code == 0 {
+		item := ydApnErrorItem(key, "上游受理状态无效，status="+status+"，message="+message)
+		item.ResData.Uncertain = true
+		return item
+	}
+	return ydApnResultItem(key, code, message, "")
+}
+
+func ydApnErrorItem(simKey *model.SimKey, message string) *model.SimBaseRes[model.SimCardOperateChangeApnItem] {
+	return &model.SimBaseRes[model.SimCardOperateChangeApnItem]{
+		SimKey:  simKey,
+		Code:    consts.ApiStatusError,
+		Message: message,
+	}
+}
+
+func ydApnResultItem(simKey *model.SimKey, code int, message, orderNum string) *model.SimBaseRes[model.SimCardOperateChangeApnItem] {
+	return &model.SimBaseRes[model.SimCardOperateChangeApnItem]{
+		SimKey:  simKey,
+		Code:    code,
+		Message: message,
+		ResData: model.SimCardOperateChangeApnItem{OrderNum: orderNum},
+	}
+}