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,
+	"marriage":                          (*QueryServiceLogic).ProcessMarriageLogic,
-	"homeservice":            (*QueryServiceLogic).ProcessHomeServiceLogic,
+	"homeservice":                       (*QueryServiceLogic).ProcessHomeServiceLogic,
-	"riskassessment":         (*QueryServiceLogic).ProcessRiskAssessmentLogic,
+	"riskassessment":                    (*QueryServiceLogic).ProcessRiskAssessmentLogic,
-	"companyinfo":            (*QueryServiceLogic).ProcessCompanyInfoLogic,
+	"companyinfo":                       (*QueryServiceLogic).ProcessCompanyInfoLogic,
-	"rentalinfo":             (*QueryServiceLogic).ProcessRentalInfoLogic,
+	"rentalinfo":                        (*QueryServiceLogic).ProcessRentalInfoLogic,
-	"preloanbackgroundcheck": (*QueryServiceLogic).ProcessPreLoanBackgroundCheckLogic,
+	"preloanbackgroundcheck":            (*QueryServiceLogic).ProcessPreLoanBackgroundCheckLogic,
-	"backgroundcheck":        (*QueryServiceLogic).ProcessBackgroundCheckLogic,
+	"backgroundcheck":                   (*QueryServiceLogic).ProcessBackgroundCheckLogic,
-	"personalData":           (*QueryServiceLogic).ProcessPersonalDataLogic,
+	"personalData":                      (*QueryServiceLogic).ProcessPersonalDataLogic,
-	"toc_PersonalLawsuit":    (*QueryServiceLogic).ProcessTocPersonalLawsuitLogic,
+	"toc_PersonalLawsuit":               (*QueryServiceLogic).ProcessTocPersonalLawsuitLogic,
-	"toc_Marriage":           (*QueryServiceLogic).ProcessTocMarriageLogic,
+	"toc_EnterpriseLawsuit":             (*QueryServiceLogic).ProcessTocEnterpriseLawsuitLogic,
-	"toc_VehiclesUnderName":  (*QueryServiceLogic).ProcessTocVehiclesUnderNameLogic,
+	"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解密
+	return l.processTocPersonalLawsuitFlow(req, "toc_PersonalLawsuit")
-	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
 }
 
 // 处理婚姻状况查询相关逻辑（二要素）
 func (l *QueryServiceLogic) ProcessTocMarriageLogic(req *types.QueryServiceReq) (*types.QueryServiceResp, error) {
-	// AES解密
+	return l.processTocMarriageFlow(req, "toc_Marriage")
-	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
 }
 
 // 处理名下车辆查询相关逻辑（二要素）
@@ -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)

app/main/api/internal/types/query.go

@@ -83,6 +83,16 @@ type TocDualMarriage struct {
 	NameWoman   string `json:"name_woman" validate:"required,name"`
 	IDCardWoman string `json:"id_card_woman" validate:"required,idCard"`
 }
+
+// TocDualMarriageReq 双人婚姻状态查询（含手机号与验证码）
+type TocDualMarriageReq struct {
+	NameMan     string `json:"name_man" validate:"required,name"`
+	IDCardMan   string `json:"id_card_man" validate:"required,idCard"`
+	NameWoman   string `json:"name_woman" validate:"required,name"`
+	IDCardWoman string `json:"id_card_woman" validate:"required,idCard"`
+	Mobile      string `json:"mobile" validate:"required,mobile"`
+	Code        string `json:"code" validate:"required"`
+}
 type TocPersonVehicleVerification struct {
 	Name       string `json:"name" validate:"required,name"`
 	CarType    string `json:"car_type" validate:"required"`

deploy/sql/product_inquire_category_items.sql

@@ -0,0 +1,13 @@
+-- 司法涉诉、婚姻状况等二级分类小项产品（与前端 inquireCategories 配置对应）
+-- 执行前请确认 id 不与现有 product 表冲突；若已有 31+ 可改为更大起始 id 或去掉 id 让其自增
+
+INSERT INTO `product` (`id`, `create_time`, `update_time`, `delete_time`, `del_state`, `version`, `product_name`, `product_en`, `description`, `notes`, `cost_price`, `sell_price`) VALUES
+(31, NOW(), NOW(), NULL, 0, 0, '企业司法涉诉', 'toc_EnterpriseLawsuit', '<p>企业司法涉诉服务，可查询企业涉诉与执行信息，帮助您评估企业法律风险。</p>', NULL, 0.50, 28.80),
+(32, NOW(), NOW(), NULL, 0, 0, '被执行人', 'toc_ExecutedPerson', '<p>被执行人信息查询，帮助您了解个人或企业是否被列为被执行人及其执行案件情况。</p>', NULL, 0.36, 18.80),
+(33, NOW(), NOW(), NULL, 0, 0, '限制高消费', 'toc_LimitHigh', '<p>限制高消费信息查询，可核查个人或企业是否被采取限制高消费措施。</p>', NULL, 0.36, 18.80),
+(34, NOW(), NOW(), NULL, 0, 0, '个人婚姻状态', 'toc_PersonalMarriageStatus', '<p>个人婚姻登记状态查询，帮助您了解个人的婚姻状态（未登记/结婚/离婚）。</p>', NULL, 1.00, 39.90),
+(35, NOW(), NOW(), NULL, 0, 0, '婚姻状态查询(登记时间版)', 'toc_MarriageStatusRegisterTime', '<p>按登记时间查询婚姻状态，提供婚姻登记时间维度的核查服务。</p>', NULL, 1.00, 39.90),
+(36, NOW(), NOW(), NULL, 0, 0, '婚姻状态查询(补证版)', 'toc_MarriageStatusSupplement', '<p>补证版婚姻状态查询，适用于补领婚姻登记证明等场景的婚姻状态核查。</p>', NULL, 1.00, 39.90),
+(37, NOW(), NOW(), NULL, 0, 0, '婚姻状态核验', 'toc_MarriageStatusVerify', '<p>婚姻状态核验服务，对指定人员的婚姻状态进行快速核验。</p>', NULL, 1.00, 39.90),
+(38, NOW(), NOW(), NULL, 0, 0, '双人婚姻状态(登记时间版)', 'toc_DualMarriageStatusRegisterTime', '<p>双人婚姻状态按登记时间查询，可同时核查双方婚姻登记状态及登记时间信息。</p>', NULL, 1.50, 59.90);
+COMMIT;