knowledgebase_influencer/src/store/knowledgeBase/knowledgeBase.thunks.js

import { createAsyncThunk } from '@reduxjs/toolkit';
import { get, post, put, del, upload } from '../../services/api';
import { showNotification } from '../notification.slice';

/**
 * Fetch knowledge bases with pagination
 * @param {Object} params - Pagination parameters
 * @param {number} params.page - Page number (default: 1)
 * @param {number} params.page_size - Page size (default: 10)
 */
export const fetchKnowledgeBases = createAsyncThunk(
    'knowledgeBase/fetchKnowledgeBases',
    async ({ page = 1, page_size = 10 } = {}, { rejectWithValue }) => {
        try {
            const response = await get('/knowledge-bases', { params: { page, page_size } });
            // 处理新的返回格式
            if (response.data && response.data.code === 200) {
                return response.data.data;
            }
            return response.data;
        } catch (error) {
            console.log(error);

            return rejectWithValue(error.response?.data.error.message || 'Failed to fetch knowledge bases');
        }
    }
);

/**
 * Search knowledge bases
 * @param {Object} params - Search parameters
 * @param {string} params.keyword - Search keyword
 * @param {number} params.page - Page number (default: 1)
 * @param {number} params.page_size - Page size (default: 10)
 */
export const searchKnowledgeBases = createAsyncThunk('knowledgeBase/search', async (params, { rejectWithValue }) => {
    try {
        const { keyword, page = 1, page_size = 10 } = params;
        const response = await get('/knowledge-bases/search', {
            params: {
                keyword,
                page,
                page_size,
            },
        });

        // 处理新的返回格式
        if (response.data && response.data.code === 200) {
            return response.data;
        }
        return response.data;
    } catch (error) {
        return rejectWithValue(error.response?.data?.message || error.message);
    }
});

/**
 * Create a new knowledge base
 */
export const createKnowledgeBase = createAsyncThunk(
    'knowledgeBase/createKnowledgeBase',
    async (knowledgeBaseData, { rejectWithValue }) => {
        try {
            const response = await post('/knowledge-bases/', knowledgeBaseData);

            // 处理新的返回格式
            if (response.data && response.data.code === 200) {
                return response.data.data.knowledge_base;
            }

            return response.data;
        } catch (error) {
            return rejectWithValue(error.response?.data?.message || 'Failed to create knowledge base');
        }
    }
);

/**
 * Get knowledge base details by ID
 */
export const getKnowledgeBaseById = createAsyncThunk(
    'knowledgeBase/getKnowledgeBaseById',
    async (id, { rejectWithValue }) => {
        try {
            const response = await get(`/knowledge-bases/${id}/`);
            // 处理新的返回格式
            if (response.data && response.data.code === 200) {
                return response.data.data;
            }
            return response.data;
        } catch (error) {
            return rejectWithValue(error.response?.data?.message || 'Failed to get knowledge base details');
        }
    }
);

/**
 * Update knowledge base
 * @param {Object} params - Update parameters
 * @param {string} params.id - Knowledge base ID
 * @param {Object} params.data - Update data (name, desc)
 */
export const updateKnowledgeBase = createAsyncThunk(
    'knowledgeBase/updateKnowledgeBase',
    async ({ id, data }, { rejectWithValue }) => {
        try {
            const response = await put(`/knowledge-bases/${id}/`, data);

            // 处理新的返回格式
            if (response.data && response.data.code === 200) {
                return response.data.data.knowledge_base;
            }

            return response.data;
        } catch (error) {
            return rejectWithValue(error.response?.data?.message || 'Failed to update knowledge base');
        }
    }
);

/**
 * Delete knowledge base
 * @param {string} id - Knowledge base ID
 */
export const deleteKnowledgeBase = createAsyncThunk(
    'knowledgeBase/deleteKnowledgeBase',
    async (id, { rejectWithValue }) => {
        try {
            await del(`/knowledge-bases/${id}/`);
            return id;
        } catch (error) {
            return rejectWithValue(error.response?.data?.message || 'Failed to delete knowledge base');
        }
    }
);

/**
 * Change knowledge base type
 * @param {Object} params - Parameters
 * @param {string} params.id - Knowledge base ID
 * @param {string} params.type - New knowledge base type
 * @param {string} params.department - User department
 * @param {string} params.group - User group
 */
export const changeKnowledgeBaseType = createAsyncThunk(
    'knowledgeBase/changeType',
    async ({ id, type, department, group }, { rejectWithValue }) => {
        try {
            console.log(id, type, department, group);
            
            const response = await post(`/knowledge-bases/${id}/change_type/`, {
                type,
                department,
                group,
            });

            // 处理新的返回格式
            if (response.data && response.data.code === 200) {
                return response.data.data;
            }

            return response.data;
        } catch (error) {
            return rejectWithValue(error.response?.data?.message || '修改知识库类型失败');
        }
    }
);

/**
 * 申请知识库访问权限
 * @param {Object} params - 参数
 * @param {string} params.knowledge_base - 知识库ID
 * @param {Object} params.permissions - 权限对象
 * @param {string} params.reason - 申请原因
 * @param {string} params.expires_at - 过期时间
 * @returns {Promise} - Promise对象
 */
export const requestKnowledgeBaseAccess = createAsyncThunk(
    'knowledgeBase/requestAccess',
    async (params, { rejectWithValue, dispatch }) => {
        try {
            const response = await post('/permissions/', params);
            dispatch(
                showNotification({
                    type: 'success',
                    message: '权限申请已发送，请等待管理员审核',
                })
            );
            return response.data;
        } catch (error) {
            dispatch(
                showNotification({
                    type: 'danger',
                    message: error.response?.data?.detail || '权限申请失败，请稍后重试',
                })
            );
            return rejectWithValue(error.response?.data?.message || error.message);
        }
    }
);

/**
 * Upload documents to a knowledge base
 * @param {Object} params - Upload parameters
 * @param {string} params.knowledge_base_id - Knowledge base ID
 * @param {File[]} params.files - Files to upload
 */
export const uploadDocument = createAsyncThunk(
    'knowledgeBase/uploadDocument',
    async ({ knowledge_base_id, files }, { rejectWithValue, dispatch }) => {
        try {
            const formData = new FormData();
            
            // 支持单文件和多文件上传
            if (Array.isArray(files)) {
                // 多文件上传
                files.forEach(file => {
                    formData.append('files', file);
                });
            } else {
                // 单文件上传（向后兼容）
                formData.append('files', files);
            }

            const response = await post(`/knowledge-bases/${knowledge_base_id}/upload_document/`, formData, true);

            // 处理新的返回格式
            if (response.data && response.data.code === 200) {
                const result = response.data.data;
                
                // 使用API返回的消息作为通知
                dispatch(
                    showNotification({
                        type: 'success',
                        message: response.data.message || `文档上传完成，成功: ${result.uploaded_count}，失败: ${result.failed_count}`,
                    })
                );
                
                return result;
            }

            dispatch(
                showNotification({
                    type: 'success',
                    message: Array.isArray(files) 
                        ? `${files.length} 个文档上传成功` 
                        : `文档 ${files.name} 上传成功`,
                })
            );

            return response.data;
        } catch (error) {
            const errorMessage = error.response?.data?.message || error.message || '文档上传失败';
            dispatch(
                showNotification({
                    type: 'danger',
                    message: errorMessage,
                })
            );
            return rejectWithValue(errorMessage);
        }
    }
);

/**
 * Get documents list for a knowledge base
 * @param {Object} params - Parameters
 * @param {string} params.knowledge_base_id - Knowledge base ID
 */
export const getKnowledgeBaseDocuments = createAsyncThunk(
    'knowledgeBase/getDocuments',
    async ({ knowledge_base_id }, { rejectWithValue }) => {
        try {
            console.log('获取知识库文档列表:', knowledge_base_id);
            const { data, code } = await get(`/knowledge-bases/${knowledge_base_id}/documents`);
            console.log('文档列表API响应:', { data, code });
            
            // 处理返回格式
            if (code === 200) {
                console.log('API返回数据:', data);
                return { 
                    items: data || [],
                    total: (data || []).length 
                };
            } else {
                // 未知格式，尝试提取数据
                const items = data?.items || data || [];
                console.log('未识别格式,提取数据:', items);
                return { 
                    items: items,
                    total: items.length 
                };
            }
        } catch (error) {
            console.error('获取知识库文档失败:', error);
            return rejectWithValue(error.response?.data?.message || '获取文档列表失败');
        }
    }
);

/**
 * Delete a document from a knowledge base
 * @param {Object} params - Parameters
 * @param {string} params.knowledge_base_id - Knowledge base ID
 * @param {string} params.document_id - Document ID
 */
export const deleteKnowledgeBaseDocument = createAsyncThunk(
    'knowledgeBase/deleteDocument',
    async ({ knowledge_base_id, document_id }, { rejectWithValue, dispatch }) => {
        try {
            console.log(knowledge_base_id, document_id);
            
            await del(`/knowledge-bases/${knowledge_base_id}/delete_document?document_id=${document_id}`);

            dispatch(
                showNotification({
                    type: 'success',
                    message: '文档删除成功',
                })
            );

            return document_id;
        } catch (error) {
            dispatch(
                showNotification({
                    type: 'danger',
                    message: error.response?.data?.message || '文档删除失败',
                })
            );
            return rejectWithValue(error.response?.data?.message || '文档删除失败');
        }
    }
);