昨天 ad346a7e1f1c35b09a5550c1b60cebe68f0619bf
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
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
package com.ruoyi.approve.service.impl;
 
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.ruoyi.approve.dto.KnowledgeBaseVectorVO;
import com.ruoyi.approve.mapper.KnowledgeBaseVectorMapper;
import com.ruoyi.approve.pojo.KnowledgeBase;
import com.ruoyi.approve.pojo.KnowledgeBaseVector;
import com.ruoyi.approve.service.KnowledgeBaseService;
import com.ruoyi.approve.service.KnowledgeBaseVectorService;
import com.ruoyi.ai.service.KnowledgeRagService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.context.annotation.Lazy;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
 
import java.util.List;
 
/**
 * 知识库文件向量记录 Service实现
 */
@Slf4j
@Service
public class KnowledgeBaseVectorServiceImpl extends ServiceImpl<KnowledgeBaseVectorMapper, KnowledgeBaseVector>
        implements KnowledgeBaseVectorService {
 
    private final KnowledgeBaseService knowledgeBaseService;
    private final KnowledgeRagService knowledgeRagService;
 
    public KnowledgeBaseVectorServiceImpl(
            KnowledgeBaseService knowledgeBaseService,
            @Lazy KnowledgeRagService knowledgeRagService) {
        this.knowledgeBaseService = knowledgeBaseService;
        this.knowledgeRagService = knowledgeRagService;
    }
 
    @Override
    public List<KnowledgeBaseVectorVO> getVectorStatusByKnowledgeBaseId(Long knowledgeBaseId) {
        return baseMapper.selectByKnowledgeBaseId(knowledgeBaseId);
    }
 
    @Override
    public KnowledgeBaseVector createVectorRecord(Long knowledgeBaseId, Long storageBlobId,
                                                   String fileName, String fileType) {
        KnowledgeBase knowledgeBase = knowledgeBaseService.getById(knowledgeBaseId);
        if (knowledgeBase == null) {
            throw new RuntimeException("知识库不存在: " + knowledgeBaseId);
        }
 
        KnowledgeBaseVector vector = new KnowledgeBaseVector();
        vector.setKnowledgeBaseId(knowledgeBaseId);
        vector.setStorageBlobId(storageBlobId);
        vector.setFileName(fileName);
        vector.setFileType(fileType);
        vector.setVectorStatus(KnowledgeBaseVector.STATUS_PENDING);
        vector.setNamespace("kb-" + knowledgeBaseId);
        vector.setChunkCount(0);
        save(vector);
 
        // 异步触发向量化处理
        knowledgeRagService.processVectorAsync(vector.getId());
 
        return vector;
    }
 
    @Override
    public void updateVectorStatus(Long id, Integer status, Integer chunkCount, String error) {
        KnowledgeBaseVector vector = getById(id);
        if (vector == null) {
            return;
        }
        vector.setVectorStatus(status);
        if (chunkCount != null) {
            vector.setChunkCount(chunkCount);
        }
        if (error != null) {
            vector.setVectorError(error);
        }
        updateById(vector);
 
        // 如果完成,更新知识库统计
        if (status == KnowledgeBaseVector.STATUS_COMPLETED) {
            updateKnowledgeBaseStats(vector.getKnowledgeBaseId());
        }
    }
 
    @Override
    @Transactional(rollbackFor = Exception.class)
    public void reprocessVector(Long id) {
        KnowledgeBaseVector vector = getById(id);
        if (vector == null) {
            throw new RuntimeException("向量记录不存在: " + id);
        }
        vector.setVectorStatus(KnowledgeBaseVector.STATUS_PENDING);
        vector.setVectorError(null);
        vector.setChunkCount(0);
        updateById(vector);
 
        // 异步重新处理
        knowledgeRagService.processVectorAsync(id);
    }
 
    @Override
    @Transactional(rollbackFor = Exception.class)
    public void deleteVector(Long id) {
        KnowledgeBaseVector vector = getById(id);
        if (vector == null) {
            return;
        }
 
        // 删除向量库中的数据
        try {
            knowledgeRagService.deleteEmbeddings(vector.getNamespace(), vector.getStorageBlobId());
        } catch (Exception e) {
            log.error("删除向量库数据失败", e);
        }
 
        // 删除记录
        removeById(id);
 
        // 更新知识库统计
        updateKnowledgeBaseStats(vector.getKnowledgeBaseId());
    }
 
    @Override
    @Transactional(rollbackFor = Exception.class)
    public void deleteVectors(List<Long> ids) {
        for (Long id : ids) {
            deleteVector(id);
        }
    }
 
    private void updateKnowledgeBaseStats(Long knowledgeBaseId) {
        KnowledgeBase knowledgeBase = knowledgeBaseService.getById(knowledgeBaseId);
        if (knowledgeBase == null) {
            return;
        }
        int fileCount = baseMapper.countByKnowledgeBaseId(knowledgeBaseId);
        int totalChunkCount = baseMapper.sumChunkCountByKnowledgeBaseId(knowledgeBaseId);
        knowledgeBase.setFileCount(fileCount);
        knowledgeBase.setTotalChunkCount(totalChunkCount);
        knowledgeBaseService.updateById(knowledgeBase);
    }
}