KnowledgeBase_frontend/src/store/knowledgeBase/knowledgeBase.slice.js

import { createSlice } from '@reduxjs/toolkit';
import {
    fetchKnowledgeBases,
    createKnowledgeBase,
    updateKnowledgeBase,
    deleteKnowledgeBase,
    changeKnowledgeBaseType,
    searchKnowledgeBases,
    requestKnowledgeBaseAccess,
    getKnowledgeBaseById,
    uploadDocument,
    getKnowledgeBaseDocuments,
    deleteKnowledgeBaseDocument,
} from './knowledgeBase.thunks';

const initialState = {
    knowledgeBases: [],
    currentKnowledgeBase: null,
    searchResults: [],
    searchLoading: false,
    loading: false,
    error: null,
    pagination: {
        total: 0,
        page: 1,
        page_size: 10,
        total_pages: 1,
    },
    batchPermissions: {},
    batchLoading: false,
    editStatus: 'idle',
    requestAccessStatus: 'idle',
    uploadStatus: 'idle',
    documents: {
        items: [],
        loading: false,
        error: null,
        pagination: {
            total: 0,
            page: 1,
            page_size: 10,
        },
    },
};

const knowledgeBaseSlice = createSlice({
    name: 'knowledgeBase',
    initialState,
    reducers: {
        clearCurrentKnowledgeBase: (state) => {
            state.currentKnowledgeBase = null;
        },
        clearSearchResults: (state) => {
            state.searchResults = [];
        },
        clearEditStatus: (state) => {
            state.editStatus = 'idle';
        },
    },
    extraReducers: (builder) => {
        builder
            // 获取知识库列表
            .addCase(fetchKnowledgeBases.pending, (state) => {
                state.loading = true;
                state.error = null;
            })
            .addCase(fetchKnowledgeBases.fulfilled, (state, action) => {
                state.loading = false;
                state.knowledgeBases = action.payload.items || [];
                state.pagination = {
                    total: action.payload.total || 0,
                    page: action.payload.page || 1,
                    page_size: action.payload.page_size || 10,
                    total_pages: action.payload.total_pages || 1,
                };
            })
            .addCase(fetchKnowledgeBases.rejected, (state, action) => {
                state.loading = false;
                state.error = action.payload || 'Failed to fetch knowledge bases';
            })

            // 创建知识库
            .addCase(createKnowledgeBase.pending, (state) => {
                state.loading = true;
                state.error = null;
            })
            .addCase(createKnowledgeBase.fulfilled, (state, action) => {
                state.loading = false;
                state.editStatus = 'successful';
                // 不需要更新 knowledgeBases，因为创建后会跳转到详情页
            })
            .addCase(createKnowledgeBase.rejected, (state, action) => {
                state.loading = false;
                state.error = action.payload || 'Failed to create knowledge base';
                state.editStatus = 'failed';
            })

            // 更新知识库
            .addCase(updateKnowledgeBase.pending, (state) => {
                state.loading = true;
                state.error = null;
            })
            .addCase(updateKnowledgeBase.fulfilled, (state, action) => {
                state.loading = false;
                // 只更新基本信息，保留其他属性（如permissions等）
                if (state.currentKnowledgeBase) {
                    state.currentKnowledgeBase = {
                        ...state.currentKnowledgeBase,
                        name: action.payload.name,
                        desc: action.payload.desc || action.payload.description,
                        description: action.payload.description || action.payload.desc,
                        type: action.payload.type || state.currentKnowledgeBase.type,
                        department: action.payload.department || state.currentKnowledgeBase.department,
                        group: action.payload.group || state.currentKnowledgeBase.group,
                    };
                }
                state.editStatus = 'successful';
            })
            .addCase(updateKnowledgeBase.rejected, (state, action) => {
                state.loading = false;
                state.error = action.payload || 'Failed to update knowledge base';
                state.editStatus = 'failed';
            })

            // 删除知识库
            .addCase(deleteKnowledgeBase.pending, (state) => {
                state.loading = true;
                state.error = null;
            })
            .addCase(deleteKnowledgeBase.fulfilled, (state, action) => {
                state.loading = false;
                const deletedId = action.payload;
                state.knowledgeBases = state.knowledgeBases.filter((kb) => kb.id !== deletedId);
                if (state.pagination.total > 0) {
                    state.pagination.total -= 1;
                    state.pagination.total_pages = Math.ceil(state.pagination.total / state.pagination.page_size);
                }
            })
            .addCase(deleteKnowledgeBase.rejected, (state, action) => {
                state.loading = false;
                state.error = action.payload || 'Failed to delete knowledge base';
            })

            // 修改知识库类型
            .addCase(changeKnowledgeBaseType.pending, (state) => {
                state.loading = true;
                state.error = null;
            })
            .addCase(changeKnowledgeBaseType.fulfilled, (state, action) => {
                state.loading = false;
                if (state.currentKnowledgeBase) {
                    state.currentKnowledgeBase = {
                        ...state.currentKnowledgeBase,
                        type: action.payload.type,
                        department: action.payload.department,
                        group: action.payload.group,
                    };
                }
                state.editStatus = 'successful';
            })
            .addCase(changeKnowledgeBaseType.rejected, (state, action) => {
                state.loading = false;
                state.error = action.payload || 'Failed to change knowledge base type';
                state.editStatus = 'failed';
            })

            // 搜索知识库
            .addCase(searchKnowledgeBases.pending, (state) => {
                state.searchLoading = true;
                state.error = null;
            })
            .addCase(searchKnowledgeBases.fulfilled, (state, action) => {
                state.searchLoading = false;
                if (action.payload && action.payload.code === 200) {
                    state.searchResults = action.payload.data.items || [];
                } else {
                    state.searchResults = action.payload.items || [];
                }
            })
            .addCase(searchKnowledgeBases.rejected, (state, action) => {
                state.searchLoading = false;
                state.error = action.payload || 'Failed to search knowledge bases';
            })

            // 申请知识库访问权限
            .addCase(requestKnowledgeBaseAccess.pending, (state) => {
                state.requestAccessStatus = 'loading';
            })
            .addCase(requestKnowledgeBaseAccess.fulfilled, (state) => {
                state.requestAccessStatus = 'successful';
            })
            .addCase(requestKnowledgeBaseAccess.rejected, (state) => {
                state.requestAccessStatus = 'failed';
            })
            
            // 获取知识库详情
            .addCase(getKnowledgeBaseById.pending, (state) => {
                state.loading = true;
                state.error = null;
            })
            .addCase(getKnowledgeBaseById.fulfilled, (state, action) => {
                state.loading = false;
                state.currentKnowledgeBase = action.payload.knowledge_base || action.payload;
            })
            .addCase(getKnowledgeBaseById.rejected, (state, action) => {
                state.loading = false;
                state.error = action.payload || 'Failed to get knowledge base details';
            })
            
            // 上传文档
            .addCase(uploadDocument.pending, (state) => {
                state.uploadStatus = 'loading';
            })
            .addCase(uploadDocument.fulfilled, (state) => {
                state.uploadStatus = 'successful';
            })
            .addCase(uploadDocument.rejected, (state, action) => {
                state.uploadStatus = 'failed';
                state.error = action.payload || 'Failed to upload document';
            })
            
            // 获取知识库文档列表
            .addCase(getKnowledgeBaseDocuments.pending, (state) => {
                state.documents.loading = true;
                state.documents.error = null;
            })
            .addCase(getKnowledgeBaseDocuments.fulfilled, (state, action) => {
                state.documents.loading = false;
                state.documents.items = action.payload.items || [];
                state.documents.pagination = {
                    total: action.payload.total || 0,
                    page: 1,
                    page_size: 10,
                };
                console.log('文档数据已更新到store:', {
                    itemsCount: state.documents.items.length,
                    items: state.documents.items,
                });
            })
            .addCase(getKnowledgeBaseDocuments.rejected, (state, action) => {
                state.documents.loading = false;
                state.documents.error = action.payload || 'Failed to get documents';
            })
            
            // 删除知识库文档
            .addCase(deleteKnowledgeBaseDocument.pending, (state) => {
                state.documents.loading = true;
                state.documents.error = null;
            })
            .addCase(deleteKnowledgeBaseDocument.fulfilled, (state, action) => {
                state.documents.loading = false;
                const deletedDocId = action.payload;
                state.documents.items = state.documents.items.filter(
                    (doc) => doc.document_id !== deletedDocId
                );
                if (state.documents.pagination.total > 0) {
                    state.documents.pagination.total -= 1;
                }
            })
            .addCase(deleteKnowledgeBaseDocument.rejected, (state, action) => {
                state.documents.loading = false;
                state.documents.error = action.payload || 'Failed to delete document';
            });
    },
});

export const { clearCurrentKnowledgeBase, clearSearchResults, clearEditStatus } = knowledgeBaseSlice.actions;

export default knowledgeBaseSlice.reducer;