职位描述合规性校验：基于规则引擎的内容安全审核方案

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

// 规则定义
type Rule struct {
    ID          string        `json:"id"`
    Name        string        `json:"name"`
    Category    string        `json:"category"`    // 违规分类
    RiskLevel   string        `json:"risk_level"`  // high/medium/low
    Condition   string        `json:"condition"`   // 条件表达式
    Action      string        `json:"action"`      // reject/warn/manual
    Message     string        `json:"message"`     // 提示信息
    Enabled     bool          `json:"enabled"`
}

// 审核上下文
type AuditContext struct {
    Title       string
    Description string
    SalaryMin   int
    SalaryMax   int
    CompanyID   int64
    CompanyName string
    CityID      int
    Position    string
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

[
  {
    "id": "discrimin_gender",
    "name": "性别歧视",
    "category": "discrimination",
    "risk_level": "high",
    "condition": "contains(description, '限男性') || contains(description, '限女性') || contains(description, '男士优先')",
    "action": "reject",
    "message": "职位描述包含性别歧视性要求，请修改后重新发布"
  },
  {
    "id": "salary_abnormal",
    "name": "薪资异常",
    "category": "fraud",
    "risk_level": "medium",
    "condition": "salary_max > 100000 && position != 'CEO' && position != 'CTO'",
    "action": "manual",
    "message": "薪资范围异常，需人工审核"
  },
  {
    "id": "contact_info",
    "name": "联系方式",
    "category": "violation",
    "risk_level": "medium",
    "condition": "regex_match(description, '1[3-9]\\d{9}') || regex_match(description, '[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}')",
    "action": "warn",
    "message": "职位描述包含联系方式，建议删除，求职者可通过平台联系"
  }
]

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

func (e *RuleEngine) Execute(ctx *AuditContext) *AuditResult {
    result := &AuditResult{Passed: true}

    for _, rule := range e.rules {
        if !rule.Enabled {
            continue
        }

        // 执行条件表达式
        matched, err := e.eval(rule.Condition, ctx)
        if err != nil {
            log.Errorf("rule %s eval error: %v", rule.ID, err)
            continue
        }

        if matched {
            result.Violations = append(result.Violations, Violation{
                RuleID: rule.ID,
                RuleName: rule.Name,
                Category: rule.Category,
                RiskLevel: rule.RiskLevel,
                Message: rule.Message,
            })

            // 根据 action 决定是否通过
            switch rule.Action {
            case "reject":
                result.Passed = false
                result.FinalAction = "reject"
            case "manual":
                result.NeedManual = true
            case "warn":
                result.Warnings = append(result.Warnings, rule.Message)
            }
        }
    }

    return result
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

func (s *AIAuditService) Audit(ctx *AuditContext) (*AIAuditResult, error) {
    prompt := fmt.Sprintf(`
你是一位招聘平台内容审核专家，请审核以下职位描述是否合规。

职位标题：%s
薪资范围：%d-%d
职位描述：
%s

请检查以下方面：
1. 是否包含虚假招聘信息（与职位严重不符的描述）
2. 是否包含歧视性要求（性别、年龄、地域、健康、婚育）
3. 是否包含违规词汇（涉黄、涉赌、涉毒、政治敏感）
4. 是否包含诱导性内容（骗取费用、押金、培训费）
5. 是否包含绕过平台的联系方式

请以JSON格式返回：
{
  "passed": true/false,
  "risk_level": "high/medium/low/none",
  "violations": [{"category": "...", "reason": "...", "suggestion": "..."}],
  "summary": "审核结论"
}
`, ctx.Title, ctx.SalaryMin, ctx.SalaryMax, ctx.Description)

    resp, err := s.aiClient.Chat(prompt)
    if err != nil {
        return nil, err
    }

    var result AIAuditResult
    json.Unmarshal([]byte(resp), &result)
    return &result, nil
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

func (s *AuditService) Audit(job *Job) *AuditResult {
    ctx := &AuditContext{
        Title: job.Title,
        Description: job.Description,
        SalaryMin: job.SalaryMin,
        SalaryMax: job.SalaryMax,
        CompanyID: job.CompanyID,
        CityID: job.CityID,
    }

    // 1. 规则引擎审核（快，毫秒级）
    ruleResult := s.ruleEngine.Execute(ctx)
    if ruleResult.FinalAction == "reject" {
        return ruleResult // 高风险直接拒绝
    }

    // 2. AI 辅助审核（慢，秒级，只对规则通过或人工审核的调用）
    if ruleResult.NeedManual || ruleResult.Passed {
        aiResult, err := s.aiService.Audit(ctx)
        if err == nil && aiResult.RiskLevel == "high" {
            ruleResult.Passed = false
            ruleResult.FinalAction = "reject"
            ruleResult.Violations = append(ruleResult.Violations, aiResult.Violations...)
        }
    }

    return ruleResult
}