f

app/main/api/internal/logic/query/queryservicelogic.go

@@ -49,17 +49,25 @@ func (l *QueryServiceLogic) QueryService(req *types.QueryServiceReq) (resp *type
 }
 
 var productProcessors = map[string]func(*QueryServiceLogic, *types.QueryServiceReq) (*types.QueryServiceResp, error){
-	"marriage":               (*QueryServiceLogic).ProcessMarriageLogic,
-	"homeservice":            (*QueryServiceLogic).ProcessHomeServiceLogic,
-	"riskassessment":         (*QueryServiceLogic).ProcessRiskAssessmentLogic,
-	"companyinfo":            (*QueryServiceLogic).ProcessCompanyInfoLogic,
-	"rentalinfo":             (*QueryServiceLogic).ProcessRentalInfoLogic,
-	"preloanbackgroundcheck": (*QueryServiceLogic).ProcessPreLoanBackgroundCheckLogic,
-	"backgroundcheck":        (*QueryServiceLogic).ProcessBackgroundCheckLogic,
-	"personalData":           (*QueryServiceLogic).ProcessPersonalDataLogic,
-	"toc_PersonalLawsuit":    (*QueryServiceLogic).ProcessTocPersonalLawsuitLogic,
-	"toc_Marriage":           (*QueryServiceLogic).ProcessTocMarriageLogic,
-	"toc_VehiclesUnderName":  (*QueryServiceLogic).ProcessTocVehiclesUnderNameLogic,
+	"marriage":                          (*QueryServiceLogic).ProcessMarriageLogic,
+	"homeservice":                       (*QueryServiceLogic).ProcessHomeServiceLogic,
+	"riskassessment":                    (*QueryServiceLogic).ProcessRiskAssessmentLogic,
+	"companyinfo":                       (*QueryServiceLogic).ProcessCompanyInfoLogic,
+	"rentalinfo":                        (*QueryServiceLogic).ProcessRentalInfoLogic,
+	"preloanbackgroundcheck":            (*QueryServiceLogic).ProcessPreLoanBackgroundCheckLogic,
+	"backgroundcheck":                   (*QueryServiceLogic).ProcessBackgroundCheckLogic,
+	"personalData":                      (*QueryServiceLogic).ProcessPersonalDataLogic,
+	"toc_PersonalLawsuit":               (*QueryServiceLogic).ProcessTocPersonalLawsuitLogic,
+	"toc_EnterpriseLawsuit":             (*QueryServiceLogic).ProcessTocEnterpriseLawsuitLogic,
+	"toc_ExecutedPerson":                (*QueryServiceLogic).ProcessTocExecutedPersonLogic,
+	"toc_LimitHigh":                     (*QueryServiceLogic).ProcessTocLimitHighLogic,
+	"toc_Marriage":                      (*QueryServiceLogic).ProcessTocMarriageLogic,
+	"toc_PersonalMarriageStatus":        (*QueryServiceLogic).ProcessTocPersonalMarriageStatusLogic,
+	"toc_MarriageStatusRegisterTime":    (*QueryServiceLogic).ProcessTocMarriageStatusRegisterTimeLogic,
+	"toc_MarriageStatusSupplement":     (*QueryServiceLogic).ProcessTocMarriageStatusSupplementLogic,
+	"toc_MarriageStatusVerify":          (*QueryServiceLogic).ProcessTocMarriageStatusVerifyLogic,
+	"toc_DualMarriageStatusRegisterTime": (*QueryServiceLogic).ProcessTocDualMarriageStatusRegisterTimeLogic,
+	"toc_VehiclesUnderName":             (*QueryServiceLogic).ProcessTocVehiclesUnderNameLogic,
 }
 
 func (l *QueryServiceLogic) PreprocessLogic(req *types.QueryServiceReq, product string) (*types.QueryServiceResp, error) {
@@ -551,122 +559,12 @@ func (l *QueryServiceLogic) ProcessPersonalDataLogic(req *types.QueryServiceReq)
 
 // 处理个人司法涉诉查询相关逻辑（二要素）
 func (l *QueryServiceLogic) ProcessTocPersonalLawsuitLogic(req *types.QueryServiceReq) (*types.QueryServiceResp, error) {
-	// AES解密
-	decryptData, DecryptDataErr := l.DecryptData(req.Data)
-	if DecryptDataErr != nil {
-		return nil, DecryptDataErr
-	}
-
-	// 校验参数
-	var data types.MarriageReq
-	if unmarshalErr := json.Unmarshal(decryptData, &data); unmarshalErr != nil {
-		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "查询服务, 解密后的数据格式不正确: %+v", unmarshalErr)
-	}
-
-	if validatorErr := validator.Validate(data); validatorErr != nil {
-		return nil, errors.Wrapf(xerr.NewErrCodeMsg(xerr.PARAM_VERIFICATION_ERROR, validatorErr.Error()), "查询服务, 参数不正确: %+v", validatorErr)
-	}
-
-	// 校验验证码
-	verifyCodeErr := l.VerifyCode(data.Mobile, data.Code)
-	if verifyCodeErr != nil {
-		return nil, verifyCodeErr
-	}
-
-	// 校验要素（代理走三要素，非代理走二要素）
-	verifyErr := l.Verify(data.Name, data.IDCard, data.Mobile)
-	if verifyErr != nil {
-		return nil, verifyErr
-	}
-
-	// 缓存
-	params := map[string]interface{}{
-		"name":    data.Name,
-		"id_card": data.IDCard,
-		"mobile":  data.Mobile,
-	}
-	userID, err := l.GetOrCreateUser()
-	if err != nil {
-		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "查询服务, 处理用户失败: %v", err)
-	}
-	cacheNo, cacheDataErr := l.CacheData(params, "toc_PersonalLawsuit", userID)
-	if cacheDataErr != nil {
-		return nil, cacheDataErr
-	}
-
-	token, err := l.svcCtx.UserService.GeneralUserToken(l.ctx, userID, model.UserTypeNormal)
-	if err != nil {
-		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "查询服务, 生成token失败 : %d", userID)
-	}
-
-	// 获取当前时间戳
-	now := time.Now().Unix()
-	return &types.QueryServiceResp{
-		Id:           cacheNo,
-		AccessToken:  token,
-		AccessExpire: now + l.svcCtx.Config.JwtAuth.AccessExpire,
-		RefreshAfter: now + l.svcCtx.Config.JwtAuth.RefreshAfter,
-	}, nil
+	return l.processTocPersonalLawsuitFlow(req, "toc_PersonalLawsuit")
 }
 
 // 处理婚姻状况查询相关逻辑（二要素）
 func (l *QueryServiceLogic) ProcessTocMarriageLogic(req *types.QueryServiceReq) (*types.QueryServiceResp, error) {
-	// AES解密
-	decryptData, DecryptDataErr := l.DecryptData(req.Data)
-	if DecryptDataErr != nil {
-		return nil, DecryptDataErr
-	}
-
-	// 校验参数
-	var data types.MarriageReq
-	if unmarshalErr := json.Unmarshal(decryptData, &data); unmarshalErr != nil {
-		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "查询服务, 解密后的数据格式不正确: %+v", unmarshalErr)
-	}
-
-	if validatorErr := validator.Validate(data); validatorErr != nil {
-		return nil, errors.Wrapf(xerr.NewErrCodeMsg(xerr.PARAM_VERIFICATION_ERROR, validatorErr.Error()), "查询服务, 参数不正确: %+v", validatorErr)
-	}
-
-	// 校验验证码
-	verifyCodeErr := l.VerifyCode(data.Mobile, data.Code)
-	if verifyCodeErr != nil {
-		return nil, verifyCodeErr
-	}
-
-	// 校验要素（代理走三要素，非代理走二要素）
-	verifyErr := l.Verify(data.Name, data.IDCard, data.Mobile)
-	if verifyErr != nil {
-		return nil, verifyErr
-	}
-
-	// 缓存
-	params := map[string]interface{}{
-		"name":    data.Name,
-		"id_card": data.IDCard,
-		"mobile":  data.Mobile,
-	}
-	userID, err := l.GetOrCreateUser()
-	if err != nil {
-		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "查询服务, 处理用户失败: %v", err)
-	}
-	cacheNo, cacheDataErr := l.CacheData(params, "toc_Marriage", userID)
-	if cacheDataErr != nil {
-		return nil, cacheDataErr
-	}
-
-	token, err := l.svcCtx.UserService.GeneralUserToken(l.ctx, userID, model.UserTypeNormal)
-	if err != nil {
-		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "查询服务, 生成token失败 : %d", userID)
-	}
-
-	// 获取当前时间戳
-	now := time.Now().Unix()
-	return &types.QueryServiceResp{
-		Id:           cacheNo,
-		AccessToken:  token,
-		AccessExpire: now + l.svcCtx.Config.JwtAuth.AccessExpire,
-		RefreshAfter: now + l.svcCtx.Config.JwtAuth.RefreshAfter,
-	}, nil
+	return l.processTocMarriageFlow(req, "toc_Marriage")
 }
 
 // 处理名下车辆查询相关逻辑（二要素）
@@ -729,6 +627,223 @@ func (l *QueryServiceLogic) ProcessTocVehiclesUnderNameLogic(req *types.QuerySer
 	}, nil
 }
 
+// 处理企业司法涉诉查询（企业名称+统一社会信用代码+手机+验证码）
+func (l *QueryServiceLogic) ProcessTocEnterpriseLawsuitLogic(req *types.QueryServiceReq) (*types.QueryServiceResp, error) {
+	decryptData, DecryptDataErr := l.DecryptData(req.Data)
+	if DecryptDataErr != nil {
+		return nil, DecryptDataErr
+	}
+	var data types.EntLawsuitReq
+	if unmarshalErr := json.Unmarshal(decryptData, &data); unmarshalErr != nil {
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "查询服务, 解密后的数据格式不正确: %+v", unmarshalErr)
+	}
+	if validatorErr := validator.Validate(data); validatorErr != nil {
+		return nil, errors.Wrapf(xerr.NewErrCodeMsg(xerr.PARAM_VERIFICATION_ERROR, validatorErr.Error()), "查询服务, 参数不正确: %+v", validatorErr)
+	}
+	verifyCodeErr := l.VerifyCode(data.Mobile, data.Code)
+	if verifyCodeErr != nil {
+		return nil, verifyCodeErr
+	}
+	params := map[string]interface{}{
+		"ent_name": data.EntName,
+		"ent_code": data.EntCode,
+		"mobile":   data.Mobile,
+	}
+	userID, err := l.GetOrCreateUser()
+	if err != nil {
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "查询服务, 处理用户失败: %v", err)
+	}
+	cacheNo, cacheDataErr := l.CacheData(params, "toc_EnterpriseLawsuit", userID)
+	if cacheDataErr != nil {
+		return nil, cacheDataErr
+	}
+	token, err := l.svcCtx.UserService.GeneralUserToken(l.ctx, userID, model.UserTypeNormal)
+	if err != nil {
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "查询服务, 生成token失败 : %d", userID)
+	}
+	now := time.Now().Unix()
+	return &types.QueryServiceResp{
+		Id:           cacheNo,
+		AccessToken:  token,
+		AccessExpire: now + l.svcCtx.Config.JwtAuth.AccessExpire,
+		RefreshAfter: now + l.svcCtx.Config.JwtAuth.RefreshAfter,
+	}, nil
+}
+
+// 处理被执行人查询（与个人司法涉诉同流程）
+func (l *QueryServiceLogic) ProcessTocExecutedPersonLogic(req *types.QueryServiceReq) (*types.QueryServiceResp, error) {
+	return l.processTocPersonalLawsuitFlow(req, "toc_ExecutedPerson")
+}
+
+// 处理限制高消费查询（与个人司法涉诉同流程）
+func (l *QueryServiceLogic) ProcessTocLimitHighLogic(req *types.QueryServiceReq) (*types.QueryServiceResp, error) {
+	return l.processTocPersonalLawsuitFlow(req, "toc_LimitHigh")
+}
+
+// processTocPersonalLawsuitFlow 个人司法涉诉/被执行人/限高共用流程（二要素+验证码）
+func (l *QueryServiceLogic) processTocPersonalLawsuitFlow(req *types.QueryServiceReq, product string) (*types.QueryServiceResp, error) {
+	decryptData, DecryptDataErr := l.DecryptData(req.Data)
+	if DecryptDataErr != nil {
+		return nil, DecryptDataErr
+	}
+	var data types.MarriageReq
+	if unmarshalErr := json.Unmarshal(decryptData, &data); unmarshalErr != nil {
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "查询服务, 解密后的数据格式不正确: %+v", unmarshalErr)
+	}
+	if validatorErr := validator.Validate(data); validatorErr != nil {
+		return nil, errors.Wrapf(xerr.NewErrCodeMsg(xerr.PARAM_VERIFICATION_ERROR, validatorErr.Error()), "查询服务, 参数不正确: %+v", validatorErr)
+	}
+	verifyCodeErr := l.VerifyCode(data.Mobile, data.Code)
+	if verifyCodeErr != nil {
+		return nil, verifyCodeErr
+	}
+	verifyErr := l.Verify(data.Name, data.IDCard, data.Mobile)
+	if verifyErr != nil {
+		return nil, verifyErr
+	}
+	params := map[string]interface{}{
+		"name":    data.Name,
+		"id_card": data.IDCard,
+		"mobile":  data.Mobile,
+	}
+	userID, err := l.GetOrCreateUser()
+	if err != nil {
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "查询服务, 处理用户失败: %v", err)
+	}
+	cacheNo, cacheDataErr := l.CacheData(params, product, userID)
+	if cacheDataErr != nil {
+		return nil, cacheDataErr
+	}
+	token, err := l.svcCtx.UserService.GeneralUserToken(l.ctx, userID, model.UserTypeNormal)
+	if err != nil {
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "查询服务, 生成token失败 : %d", userID)
+	}
+	now := time.Now().Unix()
+	return &types.QueryServiceResp{
+		Id:           cacheNo,
+		AccessToken:  token,
+		AccessExpire: now + l.svcCtx.Config.JwtAuth.AccessExpire,
+		RefreshAfter: now + l.svcCtx.Config.JwtAuth.RefreshAfter,
+	}, nil
+}
+
+// 处理个人婚姻状态 / 婚姻状态查询(登记时间版)/(补证版)/婚姻状态核验（与 toc_Marriage 同流程）
+func (l *QueryServiceLogic) ProcessTocPersonalMarriageStatusLogic(req *types.QueryServiceReq) (*types.QueryServiceResp, error) {
+	return l.processTocMarriageFlow(req, "toc_PersonalMarriageStatus")
+}
+
+func (l *QueryServiceLogic) ProcessTocMarriageStatusRegisterTimeLogic(req *types.QueryServiceReq) (*types.QueryServiceResp, error) {
+	return l.processTocMarriageFlow(req, "toc_MarriageStatusRegisterTime")
+}
+
+func (l *QueryServiceLogic) ProcessTocMarriageStatusSupplementLogic(req *types.QueryServiceReq) (*types.QueryServiceResp, error) {
+	return l.processTocMarriageFlow(req, "toc_MarriageStatusSupplement")
+}
+
+func (l *QueryServiceLogic) ProcessTocMarriageStatusVerifyLogic(req *types.QueryServiceReq) (*types.QueryServiceResp, error) {
+	return l.processTocMarriageFlow(req, "toc_MarriageStatusVerify")
+}
+
+// processTocMarriageFlow 婚姻状况类产品共用流程（二要素+验证码）
+func (l *QueryServiceLogic) processTocMarriageFlow(req *types.QueryServiceReq, product string) (*types.QueryServiceResp, error) {
+	decryptData, DecryptDataErr := l.DecryptData(req.Data)
+	if DecryptDataErr != nil {
+		return nil, DecryptDataErr
+	}
+	var data types.MarriageReq
+	if unmarshalErr := json.Unmarshal(decryptData, &data); unmarshalErr != nil {
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "查询服务, 解密后的数据格式不正确: %+v", unmarshalErr)
+	}
+	if validatorErr := validator.Validate(data); validatorErr != nil {
+		return nil, errors.Wrapf(xerr.NewErrCodeMsg(xerr.PARAM_VERIFICATION_ERROR, validatorErr.Error()), "查询服务, 参数不正确: %+v", validatorErr)
+	}
+	verifyCodeErr := l.VerifyCode(data.Mobile, data.Code)
+	if verifyCodeErr != nil {
+		return nil, verifyCodeErr
+	}
+	verifyErr := l.Verify(data.Name, data.IDCard, data.Mobile)
+	if verifyErr != nil {
+		return nil, verifyErr
+	}
+	params := map[string]interface{}{
+		"name":    data.Name,
+		"id_card": data.IDCard,
+		"mobile":  data.Mobile,
+	}
+	userID, err := l.GetOrCreateUser()
+	if err != nil {
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "查询服务, 处理用户失败: %v", err)
+	}
+	cacheNo, cacheDataErr := l.CacheData(params, product, userID)
+	if cacheDataErr != nil {
+		return nil, cacheDataErr
+	}
+	token, err := l.svcCtx.UserService.GeneralUserToken(l.ctx, userID, model.UserTypeNormal)
+	if err != nil {
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "查询服务, 生成token失败 : %d", userID)
+	}
+	now := time.Now().Unix()
+	return &types.QueryServiceResp{
+		Id:           cacheNo,
+		AccessToken:  token,
+		AccessExpire: now + l.svcCtx.Config.JwtAuth.AccessExpire,
+		RefreshAfter: now + l.svcCtx.Config.JwtAuth.RefreshAfter,
+	}, nil
+}
+
+// 处理双人婚姻状态(登记时间版)
+func (l *QueryServiceLogic) ProcessTocDualMarriageStatusRegisterTimeLogic(req *types.QueryServiceReq) (*types.QueryServiceResp, error) {
+	decryptData, DecryptDataErr := l.DecryptData(req.Data)
+	if DecryptDataErr != nil {
+		return nil, DecryptDataErr
+	}
+	var data types.TocDualMarriageReq
+	if unmarshalErr := json.Unmarshal(decryptData, &data); unmarshalErr != nil {
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "查询服务, 解密后的数据格式不正确: %+v", unmarshalErr)
+	}
+	if validatorErr := validator.Validate(data); validatorErr != nil {
+		return nil, errors.Wrapf(xerr.NewErrCodeMsg(xerr.PARAM_VERIFICATION_ERROR, validatorErr.Error()), "查询服务, 参数不正确: %+v", validatorErr)
+	}
+	verifyCodeErr := l.VerifyCode(data.Mobile, data.Code)
+	if verifyCodeErr != nil {
+		return nil, verifyCodeErr
+	}
+	if verifyErr := l.VerifyTwo(data.NameMan, data.IDCardMan); verifyErr != nil {
+		return nil, verifyErr
+	}
+	if verifyErr := l.VerifyTwo(data.NameWoman, data.IDCardWoman); verifyErr != nil {
+		return nil, verifyErr
+	}
+	params := map[string]interface{}{
+		"name":         data.NameMan,
+		"id_card":      data.IDCardMan,
+		"mobile":       data.Mobile,
+		"name_man":     data.NameMan,
+		"id_card_man":  data.IDCardMan,
+		"name_woman":   data.NameWoman,
+		"id_card_woman": data.IDCardWoman,
+	}
+	userID, err := l.GetOrCreateUser()
+	if err != nil {
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "查询服务, 处理用户失败: %v", err)
+	}
+	cacheNo, cacheDataErr := l.CacheData(params, "toc_DualMarriageStatusRegisterTime", userID)
+	if cacheDataErr != nil {
+		return nil, cacheDataErr
+	}
+	token, err := l.svcCtx.UserService.GeneralUserToken(l.ctx, userID, model.UserTypeNormal)
+	if err != nil {
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "查询服务, 生成token失败 : %d", userID)
+	}
+	now := time.Now().Unix()
+	return &types.QueryServiceResp{
+		Id:           cacheNo,
+		AccessToken:  token,
+		AccessExpire: now + l.svcCtx.Config.JwtAuth.AccessExpire,
+		RefreshAfter: now + l.svcCtx.Config.JwtAuth.RefreshAfter,
+	}, nil
+}
+
 func (l *QueryServiceLogic) DecryptData(data string) ([]byte, error) {
 	secretKey := l.svcCtx.Config.Encrypt.SecretKey
 	key, decodeErr := hex.DecodeString(secretKey)