// Package realnamereset 提供二次实名批次的导入与撤销用例。 // 二次实名:清除卡的实名状态与当前实名时间,之后只有上游 archiveTime 晚于清除前时间才算重新实名(见 add-realname-time-history)。 package realnamereset import ( "context" "crypto/rand" "fmt" "math/big" "strings" "time" "github.com/bytedance/sonic" "gorm.io/gorm" cardobservationapp "github.com/break/junhong_cmp_fiber/internal/application/cardobservation" "github.com/break/junhong_cmp_fiber/internal/model" "github.com/break/junhong_cmp_fiber/internal/model/dto" "github.com/break/junhong_cmp_fiber/pkg/constants" "github.com/break/junhong_cmp_fiber/pkg/errors" "github.com/break/junhong_cmp_fiber/pkg/middleware" ) // CardResetter 执行单卡二次实名清除与撤销。 type CardResetter interface { ResetRealname(ctx context.Context, command cardobservationapp.RealnameResetCommand) error RevertRealnameReset(ctx context.Context, command cardobservationapp.RealnameResetCommand) error } // PermissionChecker 校验后台账号权限点。 type PermissionChecker interface { CheckPermission(ctx context.Context, userID uint, permCode string, platform string) (bool, error) } // Service 是二次实名批次用例。 type Service struct { db *gorm.DB resetter CardResetter perms PermissionChecker now func() time.Time } // NewService 创建二次实名批次用例。 func NewService(db *gorm.DB, resetter CardResetter, perms PermissionChecker) *Service { return &Service{db: db, resetter: resetter, perms: perms, now: time.Now} } // resetTarget 是一行资产号展开出的一张卡。 type resetTarget struct { CardID uint `gorm:"column:id"` ICCID string `gorm:"column:iccid"` } // Import 导入二次实名名单:逐行展开为卡并逐卡清除,不合格的行记录原因跳过,不影响其他行。 func (s *Service) Import(ctx context.Context, req dto.RealnameResetImportRequest) (*dto.RealnameResetBatchResponse, error) { operatorID, err := s.authorize(ctx) if err != nil { return nil, err } identifiers := normalizeIdentifiers(req.Identifiers) if len(identifiers) == 0 { return nil, errors.New(errors.CodeInvalidParam, "请导入至少一个资产号") } if len(identifiers) > constants.RealnameResetBatchMaxRows { return nil, errors.New(errors.CodeInvalidParam, fmt.Sprintf("单批最多导入 %d 个资产号", constants.RealnameResetBatchMaxRows)) } now := s.now() batch := &model.IotCardRealnameResetBatch{ BatchNo: generateBatchNo(now), ImportFileKey: strings.TrimSpace(req.ImportFileKey), Reason: strings.TrimSpace(req.Reason), Items: []byte("[]"), OperatorID: operatorID, OperatorName: middleware.GetUsernameFromContext(ctx), CreatedAt: now, UpdatedAt: now, } if err := s.db.WithContext(ctx).Create(batch).Error; err != nil { return nil, errors.Wrap(errors.CodeDatabaseError, err, "创建二次实名批次失败") } items := make([]dto.RealnameResetItem, 0, len(identifiers)) seen := make(map[uint]bool) succeeded, skipped := 0, 0 for index, identifier := range identifiers { rowNo := index + 1 targets, resolveErr := s.resolveTargets(ctx, identifier) if resolveErr != nil { return nil, resolveErr } if len(targets) == 0 { items = append(items, skippedItem(rowNo, identifier, resetTarget{}, "资产不存在或设备未绑定卡")) skipped++ continue } for _, target := range targets { if seen[target.CardID] { items = append(items, skippedItem(rowNo, identifier, target, "同一张卡在名单中重复")) skipped++ continue } seen[target.CardID] = true resetErr := s.resetter.ResetRealname(ctx, cardobservationapp.RealnameResetCommand{CardID: target.CardID, BatchID: batch.ID, OperatorID: operatorID}) switch { case resetErr == nil: items = append(items, dto.RealnameResetItem{RowNo: rowNo, Input: identifier, CardID: target.CardID, ICCID: target.ICCID, Result: constants.RealnameResetItemPending}) succeeded++ case isExpectedResetError(resetErr): items = append(items, skippedItem(rowNo, identifier, target, errorMessage(resetErr))) skipped++ default: items = append(items, dto.RealnameResetItem{RowNo: rowNo, Input: identifier, CardID: target.CardID, ICCID: target.ICCID, Result: constants.RealnameResetItemFailed, Reason: errorMessage(resetErr)}) skipped++ } } } encoded, err := sonic.Marshal(items) if err != nil { return nil, errors.Wrap(errors.CodeInternalError, err, "编码二次实名批次结果失败") } batch.Items, batch.TotalCount, batch.SucceededCount, batch.SkippedCount = encoded, len(items), succeeded, skipped if err := s.db.WithContext(ctx).Model(&model.IotCardRealnameResetBatch{}).Where("id = ?", batch.ID).Updates(map[string]any{ "items": encoded, "total_count": len(items), "succeeded_count": succeeded, "skipped_count": skipped, "updated_at": s.now(), }).Error; err != nil { return nil, errors.Wrap(errors.CodeDatabaseError, err, "更新二次实名批次结果失败") } return &dto.RealnameResetBatchResponse{ ID: batch.ID, BatchNo: batch.BatchNo, Reason: batch.Reason, ImportFileKey: batch.ImportFileKey, TotalCount: len(items), SucceededCount: succeeded, SkippedCount: skipped, PendingCount: succeeded, OperatorID: operatorID, OperatorName: batch.OperatorName, CreatedAt: batch.CreatedAt, Items: withResultNames(items), }, nil } // Revert 撤销批次中仍在等待二次实名的卡;card_ids 为空时撤销整批。 func (s *Service) Revert(ctx context.Context, req dto.RealnameResetRevertRequest) (*dto.RealnameResetRevertResponse, error) { operatorID, err := s.authorize(ctx) if err != nil { return nil, err } var batch model.IotCardRealnameResetBatch if err := s.db.WithContext(ctx).Select("id").Where("id = ?", req.ID).Take(&batch).Error; err != nil { if err == gorm.ErrRecordNotFound { return nil, errors.New(errors.CodeNotFound, "二次实名批次不存在") } return nil, errors.Wrap(errors.CodeDatabaseError, err, "查询二次实名批次失败") } query := s.db.WithContext(ctx).Model(&model.IotCardRealname{}). Where("reset_batch_id = ? AND reset_status = ?", batch.ID, constants.RealnameResetStatusPending) if len(req.CardIDs) > 0 { query = query.Where("card_id IN ?", req.CardIDs) } var cardIDs []uint if err := query.Pluck("card_id", &cardIDs).Error; err != nil { return nil, errors.Wrap(errors.CodeDatabaseError, err, "查询等待二次实名的卡失败") } result := &dto.RealnameResetRevertResponse{} for _, cardID := range cardIDs { if err := s.resetter.RevertRealnameReset(ctx, cardobservationapp.RealnameResetCommand{CardID: cardID, BatchID: batch.ID, OperatorID: operatorID}); err != nil { result.FailedCount++ result.Failures = append(result.Failures, fmt.Sprintf("卡 %d:%s", cardID, errorMessage(err))) continue } result.RevertedCount++ } if result.RevertedCount > 0 { if err := s.db.WithContext(ctx).Model(&model.IotCardRealnameResetBatch{}).Where("id = ?", batch.ID).Updates(map[string]any{ "reverted_count": gorm.Expr("reverted_count + ?", result.RevertedCount), "updated_at": s.now(), }).Error; err != nil { return nil, errors.Wrap(errors.CodeDatabaseError, err, "更新二次实名批次撤销数失败") } } return result, nil } // authorize 二次实名只允许平台账号,且需要 iot_card:realname_reset 权限(超级管理员不受限)。 func (s *Service) authorize(ctx context.Context) (uint, error) { operatorID := middleware.GetUserIDFromContext(ctx) switch middleware.GetUserTypeFromContext(ctx) { case constants.UserTypeSuperAdmin: return operatorID, nil case constants.UserTypePlatform: default: return 0, errors.New(errors.CodeForbidden, "仅平台账号可办理二次实名") } if s.perms == nil { return 0, errors.New(errors.CodeForbidden) } allowed, err := s.perms.CheckPermission(ctx, operatorID, constants.PermissionIotCardRealnameReset, constants.PlatformWeb) if err != nil { return 0, err } if !allowed { return 0, errors.New(errors.CodeForbidden, "无二次实名权限") } return operatorID, nil } // resolveTargets 把资产号展开为卡:先按卡 ICCID / 虚拟号,再按设备虚拟号 / IMEI 取设备当前全部绑定卡。 func (s *Service) resolveTargets(ctx context.Context, identifier string) ([]resetTarget, error) { var cards []resetTarget if err := s.db.WithContext(ctx).Table("tb_iot_card").Select("id, iccid"). Where("deleted_at IS NULL AND (iccid = ? OR virtual_no = ?)", identifier, identifier). Order("id").Limit(1).Scan(&cards).Error; err != nil { return nil, errors.Wrap(errors.CodeDatabaseError, err, "按资产号查询卡失败") } if len(cards) > 0 { return cards, nil } if err := s.db.WithContext(ctx).Table("tb_device AS d").Select("c.id, c.iccid"). Joins("JOIN tb_device_sim_binding AS b ON b.device_id = d.id AND b.bind_status = ? AND b.deleted_at IS NULL", constants.BindStatusBound). Joins("JOIN tb_iot_card AS c ON c.id = b.iot_card_id AND c.deleted_at IS NULL"). Where("d.deleted_at IS NULL AND (d.virtual_no = ? OR d.imei = ?)", identifier, identifier). Order("c.id").Scan(&cards).Error; err != nil { return nil, errors.Wrap(errors.CodeDatabaseError, err, "按资产号查询设备绑定卡失败") } return cards, nil } func normalizeIdentifiers(raw []string) []string { result := make([]string, 0, len(raw)) seen := make(map[string]bool, len(raw)) for _, value := range raw { value = strings.TrimSpace(value) if value == "" || seen[value] { continue } seen[value] = true result = append(result, value) } return result } func isExpectedResetError(err error) bool { return err == cardobservationapp.ErrRealnameResetNotVerified || err == cardobservationapp.ErrRealnameResetNoUpstream || err == cardobservationapp.ErrRealnameResetAlreadyReset } func errorMessage(err error) string { if appErr, ok := err.(*errors.AppError); ok && appErr.Message != "" { return appErr.Message } return err.Error() } func skippedItem(rowNo int, input string, target resetTarget, reason string) dto.RealnameResetItem { return dto.RealnameResetItem{RowNo: rowNo, Input: input, CardID: target.CardID, ICCID: target.ICCID, Result: constants.RealnameResetItemSkipped, Reason: reason} } // withResultNames 补结果中文名。 func withResultNames(items []dto.RealnameResetItem) []dto.RealnameResetItem { for index := range items { items[index].ResultName = constants.RealnameResetItemName(items[index].Result) } return items } func generateBatchNo(now time.Time) string { suffix, err := rand.Int(rand.Reader, big.NewInt(10000)) if err != nil { suffix = big.NewInt(now.UnixNano() % 10000) } return fmt.Sprintf("%s%s%04d", constants.RealnameResetBatchNoPrefix, now.Format("20060102150405"), suffix.Int64()) }